From 105f9b66b5d839914db15d0bc7e35c8ed978ef03 Mon Sep 17 00:00:00 2001 From: David Turner Date: Thu, 2 Sep 2021 23:19:03 -0400 Subject: [PATCH 01/96] Added version of pr-check for running on della --- della-pr-check.sh | 175 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100755 della-pr-check.sh diff --git a/della-pr-check.sh b/della-pr-check.sh new file mode 100755 index 00000000..249e50d0 --- /dev/null +++ b/della-pr-check.sh @@ -0,0 +1,175 @@ +#!/bin/bash + +# Copyright 2016 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Check readiness for pull request + +set -e + +# Load some modules we will need on della +module load anaconda3 + +# Turn off infiniband +export OMPI_MCA_btl="tcp,self,sm" + +if [ ! -f brainiak/__init__.py ] +then + echo "Run "$(basename "$0")" from the root of the BrainIAK hierarchy." + exit 1 +fi + +basedir=$(pwd) + +function create_venv_venv { + python3 -m venv ../$1 +} + +function activate_venv_venv { + source ../$1/bin/activate +} + +function deactivate_venv_venv { + deactivate +} + +function remove_venv_venv { + rm -r ../$1 +} + +function create_conda_venv { + conda create -n $1 --yes python=3.8 +} + +function activate_conda_venv { + source activate $1 + # Pip may update setuptools while installing BrainIAK requirements and + # break the Conda cached package, which breaks subsequent runs. + conda install --yes -f setuptools +} + +function deactivate_conda_venv { + conda deactivate +} + +function remove_conda_venv { + conda env remove -n $1 --yes +} + +function exit_with_error { + echo $1 >&2 + exit 1 +} + +function exit_with_error_and_venv { + $deactivate_venv + cd $basedir + #$remove_venv $venv + exit_with_error "$1" +} + +if [ -z $IGNORE_CONDA ] && [ $(which conda) ] +then + export PYTHONNOUSERSITE=True + create_venv=create_conda_venv + activate_venv=activate_conda_venv + deactivate_venv=deactivate_conda_venv + remove_venv=remove_conda_venv + + # Turn of ignore installed for conda environments since we are going to install mpi4py\mpich + # via conda before pip installing brainiak and dependencies. + #ignore_installed="--ignore-installed" +else + create_venv=create_venv_venv + activate_venv=activate_venv_venv + deactivate_venv=deactivate_venv_venv + remove_venv=remove_venv_venv +fi + +# Check if running in an sdist +if git ls-files --error-unmatch pr-check.sh 2> /dev/null +then + git clean -Xf . +else + sdist_mode="--sdist-mode" +fi + +venv=$(mktemp -u brainiak_pr_venv_XXXXX) || \ + exit_with_error "mktemp -u error" +$create_venv $venv || { + exit_with_error "Virtual environment creation failed." +} +$activate_venv $venv || { + $remove_venv $venv + exit_with_error "Virtual environment activation failed." +} + + +# On Della, I can't get openmpi or intel-mpi to work with tests. OpenMPI fails +# because of a sub-process fork() and intel-mpi crashes because of some floating +# point exception. Lets install mpi4py from conda (with mpich) for now, less than +# ideal. +conda install mpi4py --yes + + +python3 -m pip install -U pip || \ + exit_with_error_and_venv "Failed to update Pip." + + +# Needed to install type-pkg-resources to get mypy to stop complaining. Not +# sure if there is a better solution. +python3 -m pip install types-pkg-resources || \ + exit_with_error_and_venv "Failed to install type-pkg-resources for mypy." + + +# install brainiak in editable mode (required for testing) +# brainiak will also be installed together with the developer dependencies, but +# we install it first here to check that installation succeeds without the +# developer dependencies. +python3 -m pip install --no-cache-dir $ignore_installed -U -e .[matnormal] || \ + exit_with_error_and_venv "Failed to install BrainIAK." + +# install developer dependencies +python3 -m pip install $ignore_installed -U -r requirements-dev.txt || \ + exit_with_error_and_venv "Failed to install development requirements." + + +echo "Running checks ... " +# static analysis +#./run-checks.sh || \ +# exit_with_error_and_venv "run-checks failed" + +# run tests +export BRAINIAKDEV_MPI_COMMAND=srun +salloc -t 00:30:00 -N 1 -n 4 ./run-tests.sh $sdist_mode || \ + exit_with_error_and_venv "run-tests failed" + +# build documentation +cd docs +export THEANO_FLAGS='device=cpu,floatX=float64,blas.ldflags=-lblas' + +if [ ! -z $SLURM_NODELIST ] +then + make_wrapper="srun -t 00:30:00 -N 1 -n 4 " +fi +$make_wrapper make || { + cd - + exit_with_error_and_venv "make docs failed" +} +cd - + +$deactivate_venv +$remove_venv $venv + +echo "pr-check finished successfully." From 2d252987cc7adf997ce0412f325eba1245b59946 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 24 Jan 2022 14:36:08 -0500 Subject: [PATCH 02/96] Added example notebook tests Notebooks have been added under docs/examples. Examples that need to fetch data before running can include this in a download_data.sh script that is present in their working directory. When tests are run in CI environment on della, these scripts will be invoked and data will be fetched into a cache if it isn't already present. The data will then be copied to the working directory of the notebook. Code for handling this has been added to pr-check.sh script and only runs when on della host. --- .gitignore | 6 + della-pr-check.sh | 175 - docs/examples/brsa/brsa_demo.ipynb | 1401 +++ docs/examples/brsa/example_design.1D | 272 + docs/examples/download_data.sh | 2 + .../eventseg/Event_Segmentation.ipynb | 686 ++ docs/examples/eventseg/download_data.sh | 4 + docs/examples/fcma/FCMA_demo.ipynb | 1023 ++ .../fcma/FCMA_script/fcma_classify.py | 178 + .../FCMA_script/fcma_voxel_selection_cv.py | 117 + .../fcma/FCMA_script/make_top_voxel_mask.sh | 35 + .../fcma/sim_info/simualte_FCMA_dat.py | 221 + docs/examples/fmrisim/download_data.sh | 8 + .../fmrisim_multivariate_example.ipynb | 9047 +++++++++++++++++ docs/examples/htfa/Dockerfile | 53 + docs/examples/htfa/download_data.sh | 16 + docs/examples/htfa/helpers.py | 327 + docs/examples/htfa/htfa.ipynb | 2772 +++++ docs/examples/iem/download_data.sh | 4 + docs/examples/iem/iem.ipynb | 948 ++ .../iem_example_synthetic_RF_data.ipynb | 0 docs/examples/isc/ISC.ipynb | 649 ++ docs/examples/isc/download_data.sh | 4 + .../Matrix-normal model prototyping.ipynb | 1075 ++ .../examples/real-time/README_INSTRUCTIONS.md | 32 + docs/examples/real-time/certs/cookie-secret | 1 + docs/examples/real-time/certs/passwd | 0 docs/examples/real-time/config.toml | 30 + docs/examples/real-time/finalize.py | 19 + docs/examples/real-time/initialize.py | 19 + .../examples/real-time/rtcloud_notebook.ipynb | 354 + docs/examples/real-time/sample.py | 284 + docs/examples/srm/SRM.ipynb | 563 + docs/examples/srm/download_data.sh | 3 + pr-check.sh | 100 +- requirements-dev.txt | 1 + setup.cfg | 5 + setup.py | 2 +- tests/conftest.py | 2 + tests/test_notebooks.py | 50 + 40 files changed, 20302 insertions(+), 186 deletions(-) delete mode 100755 della-pr-check.sh create mode 100644 docs/examples/brsa/brsa_demo.ipynb create mode 100644 docs/examples/brsa/example_design.1D create mode 100644 docs/examples/download_data.sh create mode 100644 docs/examples/eventseg/Event_Segmentation.ipynb create mode 100644 docs/examples/eventseg/download_data.sh create mode 100644 docs/examples/fcma/FCMA_demo.ipynb create mode 100644 docs/examples/fcma/FCMA_script/fcma_classify.py create mode 100644 docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py create mode 100644 docs/examples/fcma/FCMA_script/make_top_voxel_mask.sh create mode 100755 docs/examples/fcma/sim_info/simualte_FCMA_dat.py create mode 100644 docs/examples/fmrisim/download_data.sh create mode 100644 docs/examples/fmrisim/fmrisim_multivariate_example.ipynb create mode 100644 docs/examples/htfa/Dockerfile create mode 100644 docs/examples/htfa/download_data.sh create mode 100644 docs/examples/htfa/helpers.py create mode 100644 docs/examples/htfa/htfa.ipynb create mode 100644 docs/examples/iem/download_data.sh create mode 100644 docs/examples/iem/iem.ipynb rename docs/examples/{ => iem_synthetic_RF}/iem_example_synthetic_RF_data.ipynb (100%) create mode 100644 docs/examples/isc/ISC.ipynb create mode 100644 docs/examples/isc/download_data.sh create mode 100644 docs/examples/matnormal/Matrix-normal model prototyping.ipynb create mode 100644 docs/examples/real-time/README_INSTRUCTIONS.md create mode 100644 docs/examples/real-time/certs/cookie-secret create mode 100644 docs/examples/real-time/certs/passwd create mode 100644 docs/examples/real-time/config.toml create mode 100644 docs/examples/real-time/finalize.py create mode 100644 docs/examples/real-time/initialize.py create mode 100644 docs/examples/real-time/rtcloud_notebook.ipynb create mode 100644 docs/examples/real-time/sample.py create mode 100644 docs/examples/srm/SRM.ipynb create mode 100644 docs/examples/srm/download_data.sh create mode 100644 tests/test_notebooks.py diff --git a/.gitignore b/.gitignore index f3fdb42a..6a62af12 100644 --- a/.gitignore +++ b/.gitignore @@ -38,3 +38,9 @@ __MACOSX brainiak/fcma/cython_blas.c brainiak/eventseg/_utils.c examples/fcma/face_scene/ + + +docs/examples/fmrisim/Corr_MVPA_archive.tar.gz +docs/examples/iem/RademakerEtAl2019_WM_S05_avgTime.npz +docs/examples/isc/brainiak-aperture-isc-data.tgz +docs/examples/srm/brainiak-aperture-srm-data.tgz diff --git a/della-pr-check.sh b/della-pr-check.sh deleted file mode 100755 index 249e50d0..00000000 --- a/della-pr-check.sh +++ /dev/null @@ -1,175 +0,0 @@ -#!/bin/bash - -# Copyright 2016 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# Check readiness for pull request - -set -e - -# Load some modules we will need on della -module load anaconda3 - -# Turn off infiniband -export OMPI_MCA_btl="tcp,self,sm" - -if [ ! -f brainiak/__init__.py ] -then - echo "Run "$(basename "$0")" from the root of the BrainIAK hierarchy." - exit 1 -fi - -basedir=$(pwd) - -function create_venv_venv { - python3 -m venv ../$1 -} - -function activate_venv_venv { - source ../$1/bin/activate -} - -function deactivate_venv_venv { - deactivate -} - -function remove_venv_venv { - rm -r ../$1 -} - -function create_conda_venv { - conda create -n $1 --yes python=3.8 -} - -function activate_conda_venv { - source activate $1 - # Pip may update setuptools while installing BrainIAK requirements and - # break the Conda cached package, which breaks subsequent runs. - conda install --yes -f setuptools -} - -function deactivate_conda_venv { - conda deactivate -} - -function remove_conda_venv { - conda env remove -n $1 --yes -} - -function exit_with_error { - echo $1 >&2 - exit 1 -} - -function exit_with_error_and_venv { - $deactivate_venv - cd $basedir - #$remove_venv $venv - exit_with_error "$1" -} - -if [ -z $IGNORE_CONDA ] && [ $(which conda) ] -then - export PYTHONNOUSERSITE=True - create_venv=create_conda_venv - activate_venv=activate_conda_venv - deactivate_venv=deactivate_conda_venv - remove_venv=remove_conda_venv - - # Turn of ignore installed for conda environments since we are going to install mpi4py\mpich - # via conda before pip installing brainiak and dependencies. - #ignore_installed="--ignore-installed" -else - create_venv=create_venv_venv - activate_venv=activate_venv_venv - deactivate_venv=deactivate_venv_venv - remove_venv=remove_venv_venv -fi - -# Check if running in an sdist -if git ls-files --error-unmatch pr-check.sh 2> /dev/null -then - git clean -Xf . -else - sdist_mode="--sdist-mode" -fi - -venv=$(mktemp -u brainiak_pr_venv_XXXXX) || \ - exit_with_error "mktemp -u error" -$create_venv $venv || { - exit_with_error "Virtual environment creation failed." -} -$activate_venv $venv || { - $remove_venv $venv - exit_with_error "Virtual environment activation failed." -} - - -# On Della, I can't get openmpi or intel-mpi to work with tests. OpenMPI fails -# because of a sub-process fork() and intel-mpi crashes because of some floating -# point exception. Lets install mpi4py from conda (with mpich) for now, less than -# ideal. -conda install mpi4py --yes - - -python3 -m pip install -U pip || \ - exit_with_error_and_venv "Failed to update Pip." - - -# Needed to install type-pkg-resources to get mypy to stop complaining. Not -# sure if there is a better solution. -python3 -m pip install types-pkg-resources || \ - exit_with_error_and_venv "Failed to install type-pkg-resources for mypy." - - -# install brainiak in editable mode (required for testing) -# brainiak will also be installed together with the developer dependencies, but -# we install it first here to check that installation succeeds without the -# developer dependencies. -python3 -m pip install --no-cache-dir $ignore_installed -U -e .[matnormal] || \ - exit_with_error_and_venv "Failed to install BrainIAK." - -# install developer dependencies -python3 -m pip install $ignore_installed -U -r requirements-dev.txt || \ - exit_with_error_and_venv "Failed to install development requirements." - - -echo "Running checks ... " -# static analysis -#./run-checks.sh || \ -# exit_with_error_and_venv "run-checks failed" - -# run tests -export BRAINIAKDEV_MPI_COMMAND=srun -salloc -t 00:30:00 -N 1 -n 4 ./run-tests.sh $sdist_mode || \ - exit_with_error_and_venv "run-tests failed" - -# build documentation -cd docs -export THEANO_FLAGS='device=cpu,floatX=float64,blas.ldflags=-lblas' - -if [ ! -z $SLURM_NODELIST ] -then - make_wrapper="srun -t 00:30:00 -N 1 -n 4 " -fi -$make_wrapper make || { - cd - - exit_with_error_and_venv "make docs failed" -} -cd - - -$deactivate_venv -$remove_venv $venv - -echo "pr-check finished successfully." diff --git a/docs/examples/brsa/brsa_demo.ipynb b/docs/examples/brsa/brsa_demo.ipynb new file mode 100644 index 00000000..4f076fba --- /dev/null +++ b/docs/examples/brsa/brsa_demo.ipynb @@ -0,0 +1,1401 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# （Group) Bayesian Representational Similarity Analysis\n", + "\n", + "## Overview\n", + "Author: Ming Bo Cai ([mingbo.cai@ircn.jp](mailto:mingbo.cai@ircn.jp))\n", + "\n", + "This demo shows how to use the Bayesian Representational Similarity Analysis (Bayesian RSA, [Cai et al., 2016](https://proceedings.neurips.cc/paper/2016/hash/b06f50d1f89bd8b2a0fb771c1a69c2b0-Abstract.html),[2019](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006299&rev=2)) with a simulated dataset.\n", + "\n", + "Bayesian RSA builds a generative model for fMRI data which include a covariance structure as estimation target. The covariance structure specifies the distribution by which the unknown spatial neural response patterns for each task condition follow. In the model, the task-evoked patterns modulated by the design matrix, together with spontaneous activity and noise, constitute the fMRI data. By marginalizing the intermediate unknown variables including voxel-wise response amplitudes to the task conditions, the model computes a log likelihood for any possible covariance structure of condition-evoked response patterns to give rise to the fMRI data. It can then directly infer the most likely covariance structure, and convert it to the similarity structure of the neural representation for the task conditions in a region of interest. This is different from the traditional RSA approach which first estimates neural response patterns from data and then treats the noisy estimated patterns as true patterns to calculate their similarity structure. It was shown ([Cai et al., 2016](https://proceedings.neurips.cc/paper/2016/hash/b06f50d1f89bd8b2a0fb771c1a69c2b0-Abstract.html),[2019](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006299&rev=2)) that the traditional approach can introduce bias to the estimated similarity structure and BRSA reduces this bias.\n", + "\n", + "The BrainIAK Bayesian RSA module (brainiak.reprsimil.brsa) includes the following variants of Bayesian RSA:\n", + "* (the original) BRSA: a model that estimates representational similarity structure for one subject, and maximum likelihood estimates of SNR and noise parameters for each voxel.\n", + "* GBRSA: a model that can either estimate representaitonal similarity structure for one subject, or the shared similarity structure across a group of subjects. It marginalizes voxel-wise SNR and noise parameters and is likely more accurate, but may be slower than BRSA. \"G\" stands for \"Group\".\n", + "\n", + "This notebook demonstrates the usage of GBRSA on multiple subjects using simulated data. The usage of BRSA method is similar, and readers can refer to this [example](https://github.com/brainiak/brainiak/blob/master/examples/reprsimil/bayesian_rsa_example.ipynb)\n", + "\n", + "To run GBRSA on single subject, you can provide data to GBRSA in the same format as for a group of subjects shown in this notebook, except that the data is a list of numpy array of one subject's data\n", + "\n", + "## Annotated Bibliography\n", + "1. Cai, M. B., Schuck, N. W., Pillow, J. W., & Niv, Y. (2016). A Bayesian method for reducing bias in neural representational similarity analysis. *Advances in Neural Information Processing Systems* (pp. 4951-4959). [link](https://proceedings.neurips.cc/paper/2016/hash/b06f50d1f89bd8b2a0fb771c1a69c2b0-Abstract.html) *Describes potential biases in computing RSA that could lead to spurious results and introduces a Bayesian approach to reduce bias.*\n", + "\n", + "2. Cai, M. B., Schuck, N. W., Pillow, J. W., & Niv, Y. (2019). Representational structure or task structure? Bias in neural representational similarity analysis and a Bayesian method for reducing bias. *PLoS Computational Biology*, 15(5), e1006299. [link](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006299&rev=2) *This paper improves the earlier version of BRSA by additionally modeling the spatial noise correlation and marginalizing voxel-wise noise parameters. The paper also introduces group BRSA and the use of cross-validation to compare an estimated model against a null model, and further extends BRSA to task-signal decoding, using the estimated similarity structure as an empirical prior for estimating neural patterns.*\n", + "\n", + "## Table of contents\n", + "* [Simulate data](#simulate)\n", + "* [Fit Group Bayesian RSA to simulated data](#fit)\n", + "* [Evaluation](#evaluation)\n", + "* [Other usage: \"decoding\" task-related signal from new data](#decoding)\n", + "* [Model selection by cross-validataion](#cross-validation)\n", + "* [Avoid false discovery](#avoiding)\n", + "* [Summary](#summary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Notes on data preparation\n", + "When you apply this tool to real fMRI data, it is required that the data of each participant to be motion corrected. If multiple runs are acquired for each participant, they should be spatially aligned. Slice-timing correction is recommended. \n", + "\n", + "\n", + "You will need to have the mask of the Region of Interest (ROI) ready (typically defined anatomically or by independent tasks). nilearn provides tools to extract signal from mask. You can refer to this [tutorial](http://nilearn.github.io/manipulating_images/manipulating_images.html)\n", + "\n", + "##### Notes on model assumption\n", + "Please note that the model assumes that the covariance matrix U which all $\\beta_i$ follow describe a multi-variate Gaussian distribution that is zero-meaned. This assumption does not imply that there must be both positive and negative responses across voxels.\n", + "However, it means that (Group) Bayesian RSA treats the task-evoked activity against baseline BOLD level as signal, while in other RSA tools the deviation of task-evoked activity in each voxel from the average task-evoked activity level across voxels may be considered as signal of interest.\n", + "Due to this assumption in (G)BRSA, relatively high degree of similarity may be expected when the activity patterns of two task conditions share a strong sensory driven components. When two task conditions elicit exactly the same activity pattern but only differ in their global magnitudes, under the assumption in (G)BRSA, their similarity is 1. However, if one take the assumption that only deviation of pattern from average patterns is signal of interest (which is currently not supported by (G)BRSA), their similarity would be -1 because the deviations of the two patterns from their average pattern are exactly opposite." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load some package which we will use in this demo.\n", + "If you see error related to loading any package, you can install that package. For example, if you use Anaconda, you can use \"conda install matplotlib\" to install matplotlib." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import scipy.spatial.distance as spdist\n", + "from scipy import stats\n", + "import numpy as np\n", + "from brainiak.reprsimil.brsa import GBRSA\n", + "import brainiak.utils.utils as utils\n", + "import matplotlib.pyplot as plt\n", + "import logging\n", + "np.random.seed(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You might want to keep a log of the output." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "logging.basicConfig(\n", + " level=logging.DEBUG,\n", + " filename='gbrsa_example.log',\n", + " format='%(relativeCreated)6d %(threadName)s %(message)s')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulate data \n", + "We want to simulate some data in which each voxel responds to different task conditions differently, but following a common covariance structure.\n", + "\n", + "This example simulate 5 subjects. If you find the whole notebook runs for too long on your computer, you can reduce the number of simulated subjects by changing `n_subj` below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load an example design matrix.\n", + "To use BRSA, you need to prepare design matrix for the task with your favorate software, such as using `3ddeconvolve` of AFNI, or using SPM or FSL.\n", + "\n", + "The design matrix reflects your belief of how fMRI signal should respond to a task (if a voxel does respond).\n", + "The common assumption is that a neural event that you are interested in will elicit a slow hemodynamic response in some voxels. The response peaks around 4-6 seconds after the event onset and dissipatess ~12 seconds after the event. Therefore, typically you convolve a time series A, composed of delta (stem) functions reflecting the time of each neural event belonging to the same category (e.g. all trials in which a participant sees a face), with a hemodynamic response function B, to form the hypothetic response of any voxel to such type of neural event.\n", + "One convoluted time course can be generated this way for each type of event. The time courses corresponding to all events, put together, are called design matrix.\n", + "Our goal is to figure out how the (spatial) response patterns of a population of voxels (in an Region of Interest, ROI) to different types of tasks (e.g., watching different categories of animals, different conditions of a cognitive task) are similar or disimilar. So we need the design matrix in order to estimate the similarity matrix we are interested in.\n", + "\n", + "Basically, (G)BRSA just needs a numpy array which is in size of {time points} * {condition}.\n", + "We can use the utility called `ReadDesign` from `brainiak.utils` to read a design matrix generated from AFNI. For design matrix saved as Matlab data file by SPM or or other toolbox, you can use `scipy.io.loadmat('YOURFILENAME')` and extract the design matrix from the dictionary returned. \n", + "You can also generate design matrix using the function `gen_design` in `brainiak.utils`. It takes in (names of) event timing files in AFNI or FSL format (denoting onsets, duration, and weight for each event belonging to the same condition) and outputs the design matrix as numpy array.\n", + "\n", + "#### details about design matrix\n", + "In this simulation, we use a design matrix of a task consisting of 16 different conditions, which by design cannot be fully counter-balanced in their orders. For simplicity, we repeat the design matrix of one run by 2 to 3 times, mimicking 2 to 3 fMRI runs with identical timing.\n", + "Note that different subjects do not have to have the same number of voxels or time points. The timing of the task conditions can also differ across subjects. The simulation below reflects this.\n", + "\n", + "In typical fMRI analysis, some nuisance regressors such as head motion, baseline time series and slow drift are also entered into regression. **In using (G)BRSA, you should not include such nuisance regressors into the design matrix, because the spatial spread of such nuisance regressors might be quite different from the spatial spread of task related signal.** Including such nuisance regressors in design matrix might influence the pseudo-SNR map, which in turn influences the estimation of the shared covariance matrix. But you may include motion time course in the nuisance parameter.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_subj = 5\n", + "n_run = np.random.randint(2, 4, n_subj)\n", + "ROI_edge = np.random.randint(20, 40, n_subj)\n", + "# We simulate \"ROIs\" of a square shape\n", + "design = [None] * n_subj\n", + "for subj in range(n_subj):\n", + " design[subj] = utils.ReadDesign(fname=\"example_design.1D\")\n", + " design[subj].n_TR = design[subj].n_TR * n_run[subj]\n", + " design[subj].design_task = np.tile(design[subj].design_task[:,:-1],\n", + " [n_run[subj], 1])\n", + " # The last \"condition\" in design matrix\n", + " # codes for trials subjects made an error.\n", + " # We ignore it here.\n", + "n_C = np.size(design[0].design_task, axis=1)\n", + "# The total number of conditions.\n", + "n_V = [int(roi_e**2) for roi_e in ROI_edge]\n", + "# The total number of simulated voxels\n", + "n_T = [d.n_TR for d in design]\n", + "# The total number of time points,\n", + "# after concatenating all fMRI runs\n", + "fig = plt.figure(num=None, figsize=(12, 3),\n", + " dpi=150, facecolor='w', edgecolor='k')\n", + "plt.plot(design[0].design_task)\n", + "plt.ylim([-0.2, 0.4])\n", + "plt.title('hypothetic fMRI response time courses '\n", + " 'of all conditions for one subject\\n'\n", + " '(design matrix)')\n", + "plt.xlabel('time')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### simulate noise\n", + "We simulate noise which is Gaussian Process (mimicking smooth noise in fMRI) in space and AR(1) in time" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noise_bot = 0.5\n", + "noise_top = 1.5\n", + "noise_level = [None] * n_subj\n", + "noise = [None] * n_subj\n", + "rho1 = [None] * n_subj\n", + "white_noise_magnitude = 0.4\n", + "for subj in range(n_subj):\n", + " # each subject may have different noise level\n", + " noise_level[subj] = np.random.rand(n_V[subj]) * \\\n", + " (noise_top - noise_bot) + noise_bot\n", + " # The standard deviation of the noise is in the range of [noise_bot, noise_top]\n", + " # In fact, we simulate autocorrelated noise with AR(1) model. So the noise_level reflects\n", + " # the independent additive noise at each time point (the \"fresh\" noise)\n", + "\n", + "# AR(1) coefficient\n", + "rho1_top = 0.8\n", + "rho1_bot = -0.1\n", + "for subj in range(n_subj):\n", + " rho1[subj] = np.random.rand(n_V[subj]) \\\n", + " * (rho1_top - rho1_bot) + rho1_bot\n", + "\n", + "noise_smooth_width = 10.0\n", + "dist2 = [None] * n_subj\n", + "for subj in range(n_subj):\n", + " coords = np.mgrid[0:ROI_edge[subj], 0:ROI_edge[subj], 0:1]\n", + " coords_flat = np.reshape(coords,[3, n_V[subj]]).T\n", + " dist2[subj] = spdist.squareform(spdist.pdist(coords_flat, 'sqeuclidean'))\n", + "\n", + " # generating noise\n", + " K_noise = noise_level[subj][:, np.newaxis] \\\n", + " * (np.exp(-dist2[subj] / noise_smooth_width**2 / 2.0) \\\n", + " + np.eye(n_V[subj]) * white_noise_magnitude ** 2) * noise_level[subj]\n", + " # We make spatially correlated noise by generating\n", + " # noise at each time point from a Gaussian Process\n", + " # defined over the coordinates.\n", + " L_noise = np.linalg.cholesky(K_noise)\n", + " noise[subj] = np.zeros([n_T[subj], n_V[subj]])\n", + " noise[subj][0, :] = np.dot(L_noise, np.random.randn(n_V[subj]))\\\n", + " / np.sqrt(1 - rho1[subj]**2)\n", + " for i_t in range(1, n_T[subj]):\n", + " noise[subj][i_t, :] = noise[subj][i_t - 1, :] * rho1[subj] \\\n", + " + np.dot(L_noise,np.random.randn(n_V[subj]))\n", + " # For each voxel, the noise follows AR(1) process:\n", + " # fresh noise plus a dampened version of noise at\n", + " # the previous time point.\n", + " # In this simulation, we also introduced spatial smoothness resembling a Gaussian Process.\n", + " # Notice that we simulated in this way only to introduce spatial noise correlation.\n", + " # Gaussian Process is not the assumption of the form of spatial noise correlation in the model.\n", + " noise[subj] += np.random.randn()\n", + "plt.pcolor(K_noise)\n", + "plt.colorbar()\n", + "plt.xlim([0, ROI_edge[-1] * ROI_edge[-1]])\n", + "plt.ylim([0, ROI_edge[-1] * ROI_edge[-1]])\n", + "plt.title('Spatial covariance matrix of noise\\n of one participant in a simulated square \"ROI\"')\n", + "plt.xlabel('x coordinates of voxels')\n", + "plt.ylabel('y coordinates of voxels')\n", + "plt.show()\n", + "\n", + "fig = plt.figure(num=None, figsize=(12, 2), dpi=150,\n", + " facecolor='w', edgecolor='k')\n", + "plt.plot(noise[-1][:, 0])\n", + "plt.title('noise in an example voxel')\n", + "plt.xlabel('TR')\n", + "plt.ylabel('demeaned signal')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### specify simulated similarity matrix\n", + "We assume the magnitude of response to each condition follows a common covariance matrix, underlying a similarity structure displayed below, for easy visualization of the effectiveness of different RSA approaches. \n", + "\n", + "Let's keep the pattern of the ideal covariance / correlation below in mind and see how well BRSA can recover their patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# ideal covariance matrix\n", + "ideal_cov = np.zeros([n_C, n_C])\n", + "ideal_cov = np.eye(n_C) * 0.6\n", + "ideal_cov[8:12, 8:12] = 0.6\n", + "for cond in range(8, 12):\n", + " ideal_cov[cond,cond] = 1\n", + "\n", + "fig = plt.figure(num=None, figsize=(4, 4), dpi=100)\n", + "plt.pcolor(ideal_cov)\n", + "plt.colorbar()\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('ideal covariance matrix')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()\n", + "\n", + "std_diag = np.diag(ideal_cov)**0.5\n", + "ideal_corr = ideal_cov / std_diag / std_diag[:, None]\n", + "fig = plt.figure(num=None, figsize=(4, 4), dpi=100)\n", + "plt.pcolor(ideal_corr)\n", + "plt.colorbar()\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.title('ideal correlation matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulate task-related signals\n", + "We make a realistic assumption that signal-to-noise ratio (SNR) is not constant across voxels. In the following, the map of pseudo-SNR (proportional to real SNR) is generated from a Gaussian Process defined on a \"square\" ROI, just for simplicity of code. Task-evoked response amplitudes are then simulated as samples drawn from multi-variate Gaussian distributions with covariance matrix equaling the ideal covariance matrix above, times the pseudo-SNR of each voxel. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "L_full = np.linalg.cholesky(ideal_cov) \n", + "\n", + "# generating signal\n", + "snr_level = np.random.rand(n_subj) * 0.6 + 0.4\n", + "# Notice that accurately speaking this is not SNR.\n", + "# The magnitude of signal depends not only on beta but also on x.\n", + "# (noise_level*snr_level)**2 is the factor multiplied\n", + "# with ideal_cov to form the covariance matrix from which\n", + "# the response amplitudes (beta) of a voxel are drawn from.\n", + "\n", + "tau = np.random.rand(n_subj) * 0.8 + 0.2\n", + "# magnitude of Gaussian Process from which the log(SNR) is drawn\n", + "smooth_width = np.random.rand(n_subj) * 5.0 + 3.0\n", + "# spatial length scale of the Gaussian Process, unit: voxel\n", + "\n", + "\n", + "\n", + "snr = [None] * n_subj\n", + "signal = [None] * n_subj\n", + "betas_simulated = [None] * n_subj\n", + "\n", + "for subj in range(n_subj):\n", + "\n", + " K = np.exp(-dist2[subj] / smooth_width[subj]**2 / 2.0) * tau[subj]**2 \\\n", + " + np.eye(n_V[subj]) * tau[subj]**2 * 0.01\n", + " # K is the spatial covariance of SNR.\n", + " # A tiny amount is added to the diagonal of\n", + " # the GP covariance matrix to make sure it can be inverted\n", + " L = np.linalg.cholesky(K)\n", + " snr[subj] = np.exp(np.dot(L, np.random.randn(n_V[subj]))) * snr_level[subj]\n", + " sqrt_v = noise_level[subj] * snr[subj]\n", + " betas_simulated[subj] = np.dot(L_full, np.random.randn(n_C, n_V[subj])) * sqrt_v\n", + " # Simulated activation pattern (beta)\n", + " signal[subj] = np.dot(design[subj].design_task, betas_simulated[subj])\n", + "\n", + "\n", + "fig = plt.figure(num=None, figsize=(4, 4), dpi=100)\n", + "plt.pcolor(np.reshape(snr[0], [ROI_edge[0], ROI_edge[0]]))\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('pseudo-SNR in a square \"ROI\" \\nof participant 0')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.show() \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Synthesize data by adding signal with noise" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "Y = [None] * n_subj\n", + "for subj in range(n_subj):\n", + " Y[subj] = signal[subj] + noise[subj]\n", + " # The data to be fed to the program.\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we take a look at the voxels with the lowest SNR and highest SNR for the participant with median level of overall SNR\n", + "\n", + "The reason that the pseudo-SNRs in the example voxels are not too small, while the signal looks much smaller is because we happen to have low amplitudes in our design matrix. The true SNR depends on both the amplitudes in design matrix and the pseudo-SNR. Therefore, be aware that pseudo-SNR does not directly reflects how much signal the data have, but rather a map indicating the relative strength of signal in differerent voxels." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "snr_all = np.concatenate(snr)\n", + "idx = np.argmin(np.abs(snr_all - np.median(snr_all)))\n", + "median_subj = np.min(np.where(idx - np.cumsum(n_V) < 0))\n", + "\n", + "idx = idx - np.cumsum(np.concatenate([[0], n_V]))[median_subj]\n", + "# choose a voxel of medium level SNR.\n", + "fig = plt.figure(num=None, figsize=(12, 3), dpi=150,\n", + " facecolor='w', edgecolor='k')\n", + "noise_plot, = plt.plot(noise[median_subj][:,idx],'g')\n", + "signal_plot, = plt.plot(signal[median_subj][:,idx],'b')\n", + "plt.legend([noise_plot, signal_plot], ['noise', 'signal'])\n", + "plt.title('simulated data in an example voxel'\n", + " ' with pseudo-SNR of {:.3f} in participant {}'.format(snr[median_subj][idx], median_subj))\n", + "plt.xlabel('TR')\n", + "plt.show()\n", + "\n", + "fig = plt.figure(num=None, figsize=(12, 3), dpi=150,\n", + " facecolor='w', edgecolor='k')\n", + "data_plot, = plt.plot(Y[median_subj][:,idx],'r')\n", + "plt.title('observed data of the voxel (signal+noise)')\n", + "plt.xlabel('TR')\n", + "plt.show()\n", + "\n", + "idx = np.argmin(np.abs(snr_all - np.max(snr_all)))\n", + "highest_subj = np.min(np.where(idx - np.cumsum(n_V) < 0))\n", + "idx = idx - np.cumsum(np.concatenate([[0], n_V]))[highest_subj]\n", + "# display the voxel of the highest level SNR.\n", + "fig = plt.figure(num=None, figsize=(12, 3), dpi=150,\n", + " facecolor='w', edgecolor='k')\n", + "noise_plot, = plt.plot(noise[highest_subj][:,idx],'g--')\n", + "signal_plot, = plt.plot(signal[highest_subj][:,idx],'b--')\n", + "plt.legend([noise_plot, signal_plot], ['noise', 'signal'])\n", + "plt.title('simulated data in the voxel with the highest'\n", + " ' pseudo-SNR of {:.3f} in subject {}'.format(snr[highest_subj][idx], highest_subj))\n", + "plt.xlabel('TR')\n", + "plt.show()\n", + "\n", + "fig = plt.figure(num=None, figsize=(12, 3), dpi=150,\n", + " facecolor='w', edgecolor='k')\n", + "data_plot, = plt.plot(Y[highest_subj][:,idx],'r')\n", + "plt.title('observed data of the voxel (signal+noise)')\n", + "plt.xlabel('TR')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fit Group Bayesian RSA to simulated data \n", + "\n", + "\n", + "In BRSA and GBRSA, the nuisance regressors in typical fMRI analysis (such as head motion signal) are replaced by principal components estimated from residuals after subtracting mean posterior estimation of task-related response. `n_nureg` tells the model how many principal components to keep from the residual as nuisance regressors, in order to account for spatial correlation in noise. When it is set to None and `auto_nuisance=True`, this number will be estimated automatically by an algorithm of [Gavish & Dohono 2014](https://ieeexplore.ieee.org/document/6846297). If you prefer not using this approach based on principal components of residuals, you can set `auto_nuisance=False`, and optionally provide your own nuisance regressors as a list (one numpy array per subject) as nuisance argument to `GBRSA.fit()`. In practice, we find that the result is much better with `auto_nuisance=True`.\n", + "\n", + "Apparently one can imagine that the choice of the number of principal components used as nuisance regressors can influence the result. If you just choose 1 or 2, perhaps only the global drift would be captured. But including too many nuisance regressors would slow the fitting speed and might have risk of overfitting. Among all the algorithms we have tested with simulation data, the Gavish & Donoho algorithm appears the most robust and the estimate is closest to the true simulated number. But it does have a tendency to under-estimate the number of components, which is one limitation in (G)BRSA module." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Prepare onset information for model fitting\n", + "When you have multiple runs, the noise won't be correlated between runs. Therefore, you should tell BRSA when is the onset of each scan. \n", + "\n", + "Note that the data (variable Y above) you feed to BRSA is the concatenation of data from all runs along the time dimension, as a 2-D matrix of time x space" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scan onsets: [array([ 0, 186, 372], dtype=int32), array([ 0, 186, 372], dtype=int32), array([ 0, 186], dtype=int32), array([ 0, 186, 372], dtype=int32), array([ 0, 186], dtype=int32)]\n" + ] + } + ], + "source": [ + "scan_onsets = [np.int32(np.linspace(0, design[i].n_TR,num=n_run[i] + 1)[: -1]) for i in range(n_subj)]\n", + "print('scan onsets: {}'.format(scan_onsets))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Instantiate a GBRSA object\n", + "To reduce the running time at a cost of inaccuracy, you may specify `SNR_prior='equal'` and a smaller `rho_bins` parameter, as the code commented out below. There are multiple other parameters, we take the defaults in this example." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "gbrsa = GBRSA()\n", + "\n", + "# gbrsa = GBRSA(SNR_prior='equal', rho_bins=11)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fit model to the data\n", + "This may take a while." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GBRSA(nureg_method=. at 0x7f3d0bc79b90>)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "gbrsa.fit(X=Y, design=[d.design_task for d in design],scan_onsets=scan_onsets)\n", + "# The data to fit should be given to the argument X.\n", + "# Design matrix goes to design. And so on.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluation \n", + "\n", + "### Result of GBRSA\n", + "We can have a look at the estimated similarity in matrix `gbrsa.C_`. \n", + "\n", + "We can also compare the ideal covariance above with the one recovered, `gbrsa.U_`" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(num=None, figsize=(4, 4), dpi=100)\n", + "plt.pcolor(gbrsa.C_, vmin=-0.1, vmax=1)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Estimated correlation structure\\n shared between voxels\\n'\n", + " 'This constitutes the output of Bayesian RSA\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()\n", + "\n", + "fig = plt.figure(num=None, figsize=(4, 4), dpi=100)\n", + "plt.pcolor(gbrsa.U_)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Estimated covariance structure\\n shared between voxels\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare with result of traditional RSA\n", + "\n", + "In this approach, estimated activation patterns of each task condition ($\\beta$) are obtained by regressing data against design matrix.\n", + "And then Pearson correlation or other (dis)similarity metric is calculated between the noisy estimates of $\\beta$s of different conditions." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example result from one participant (traditional RSA)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Group average result of traditional RSA\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compare with the result of Group Bayesian RSA\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sum_point_corr = np.zeros((n_C, n_C))\n", + "sum_point_cov = np.zeros((n_C, n_C))\n", + "betas_point = [None] * n_subj\n", + "print('Example result from one participant (traditional RSA)')\n", + "for subj in range(n_subj):\n", + " regressor = np.insert(design[subj].design_task,\n", + " 0, 1, axis=1)\n", + " betas_point[subj] = np.linalg.lstsq(regressor, Y[subj], rcond=None)[0]\n", + " point_corr = np.corrcoef(betas_point[subj][1:, :])\n", + " point_cov = np.cov(betas_point[subj][1:, :])\n", + " sum_point_corr += point_corr\n", + " sum_point_cov += point_cov\n", + " if subj == 0:\n", + " fig = plt.figure(num=None, figsize=(10, 4), dpi=100)\n", + " plt.subplot(1,2,1)\n", + " plt.pcolor(point_corr, vmin=-0.1, vmax=1)\n", + " plt.xlim([0, 16])\n", + " plt.ylim([0, 16])\n", + " plt.colorbar()\n", + " ax = plt.gca()\n", + " ax.set_aspect(1)\n", + " plt.title('Correlation structure estimated\\n'\n", + " 'based on point estimates of betas\\n'\n", + " 'for subject {}'.format(subj))\n", + " plt.xlabel('conditions')\n", + " plt.ylabel('conditions')\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " plt.subplot(1,2,2)\n", + " plt.pcolor(point_cov)\n", + " plt.xlim([0, 16])\n", + " plt.ylim([0, 16])\n", + " plt.colorbar()\n", + " ax = plt.gca()\n", + " ax.set_aspect(1)\n", + " plt.title('Covariance structure of\\n'\n", + " 'point estimates of betas\\n'\n", + " 'for subject {}'.format(subj))\n", + " plt.xlabel('conditions')\n", + " plt.ylabel('conditions')\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.show()\n", + "print('Group average result of traditional RSA')\n", + "fig = plt.figure(num=None, figsize=(10, 4), dpi=100)\n", + "plt.subplot(1,2,1)\n", + "plt.pcolor(sum_point_corr / n_subj, vmin=-0.1, vmax=1)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Correlation structure estimated\\n'\n", + " 'based on point estimates of betas\\n'\n", + " 'averaged over subjects (traditional RSA)\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.pcolor(sum_point_cov / n_subj)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Covariance structure of\\n'\n", + " 'point estimates of betas\\n'\n", + " 'averaged over subjects (traditional RSA)\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()\n", + "\n", + "print('Compare with the result of Group Bayesian RSA')\n", + "fig = plt.figure(num=None, figsize=(10, 4), dpi=100)\n", + "plt.subplot(1,2,1)\n", + "plt.pcolor(gbrsa.C_, vmin=-0.1, vmax=1)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Estimated correlation structure\\n'\n", + " 'shared between voxels (Bayesian RSA)\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.pcolor(gbrsa.U_)\n", + "plt.xlim([0, 16])\n", + "plt.ylim([0, 16])\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('Estimated covariance structure\\n'\n", + " 'shared between voxels (Bayesian RSA)\\n')\n", + "plt.xlabel('conditions')\n", + "plt.ylabel('conditions')\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the root mean squared error between the estimated similarity and simulated similarity structures" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMS error of group Bayesian RSA: 0.08086539168945868\n", + "RMS error of standard RSA: 0.34747836290315093\n" + ] + } + ], + "source": [ + "RMS_GBRSA = np.mean((gbrsa.C_ - ideal_corr)**2)**0.5\n", + "RMS_RSA = np.mean((point_corr - ideal_corr)**2)**0.5\n", + "print('RMS error of group Bayesian RSA: {}'.format(RMS_GBRSA))\n", + "print('RMS error of standard RSA: {}'.format(RMS_RSA))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating estimated pseudo-SNR map against the simulated SNR map\n", + "If you have chosen `SNR_prior='equal'`, the estimated pseudo-SNR map will be flat" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "subj = highest_subj\n", + "\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "\n", + "\n", + "vmax = np.max([np.max(gbrsa.nSNR_[s]) for s in range(n_subj)])\n", + "for s in range(n_subj):\n", + " im = axes[s].pcolor(np.reshape(gbrsa.nSNR_[s], [ROI_edge[s], ROI_edge[s]]),\n", + " vmin=0,vmax=vmax)\n", + " axes[s].set_aspect(1)\n", + " \n", + "fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.75)\n", + "\n", + "plt.suptitle('estimated pseudo-SNR',fontsize=\"xx-large\" )\n", + "plt.show()\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "vmax = np.max([np.max(snr[s]) for s in range(n_subj)])\n", + "for s in range(n_subj):\n", + " im = axes[s].pcolor(np.reshape(snr[s], [ROI_edge[s], ROI_edge[s]]),\n", + " vmin=0,vmax=vmax)\n", + " axes[s].set_aspect(1)\n", + "fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.75)\n", + "plt.suptitle('simulated pseudo-SNR',fontsize=\"xx-large\" )\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Examine the recovery of activation pattern\n", + "Scatter plot of the recovered $\\beta$s and true $\\beta$s. Each column is result from one subject. Ｔhe closer the dots are close to the diagnal line, the better the recovery is.\n", + "Top: result by GBRSA. Bottom: result by standard regression analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "for s in range(n_subj):\n", + " im = axes[s].scatter(betas_simulated[s] , gbrsa.beta_[s])\n", + " if s == 0:\n", + " axes[s].set_ylabel('recovered betas by GBRSA',fontsize='xx-large')\n", + " if s == int(n_subj/2):\n", + " axes[s].set_xlabel('true betas',fontsize='xx-large')\n", + " axes[s].set_aspect(1)\n", + " axes[s].set_title('r={:0.3f}'.format(\n", + " stats.pearsonr(betas_simulated[s].ravel(), gbrsa.beta_[s].ravel())[0]))\n", + "plt.suptitle('estimated vs. simulated betas, \\nby GBRSA',fontsize=\"xx-large\" )\n", + "plt.show()\n", + "\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "for s in range(n_subj):\n", + " im = axes[s].scatter(betas_simulated[s] , betas_point[s][1:, :])\n", + " if s == 0:\n", + " axes[s].set_ylabel('recovered betas by simple regression',fontsize='xx-large')\n", + " if s == int(n_subj/2):\n", + " axes[s].set_xlabel('true betas',fontsize='xx-large')\n", + " axes[s].set_aspect(0.5)\n", + " axes[s].set_title('r={:0.3f}'.format(\n", + " stats.pearsonr(betas_simulated[s].ravel(), betas_point[s][1:, :].ravel())[0]))\n", + "plt.suptitle('estimated vs. simulated betas, \\nby simple regression',fontsize=\"xx-large\" )\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Other usage: \"decoding\" task-related signal from new data \n", + "\n", + "Now we generate a new data set.\n", + "We keep the signal the same as in training data, but generate new noise.\n", + "\n", + "We can use the `transform()` function of gbrsa to estimate the \"design matrix\" in this new dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "average SNR level: [0.46520476 0.59677297 0.51632359 0.41470869 0.69860492]\n", + "Apparently how much the recovered time course resembles the true design matrix depends on SNR\n" + ] + } + ], + "source": [ + "noise_new = [None] * n_subj\n", + "Y_new = [None] * n_subj\n", + "for subj in range(n_subj):\n", + " \n", + " # generating noise\n", + " K_noise = noise_level[subj][:, np.newaxis] \\\n", + " * (np.exp(-dist2[subj] / noise_smooth_width**2 / 2.0) \\\n", + " + np.eye(n_V[subj]) * white_noise_magnitude ** 2) * noise_level[subj]\n", + " # We make spatially correlated noise by generating\n", + " # noise at each time point from a Gaussian Process\n", + " # defined over the coordinates.\n", + " L_noise = np.linalg.cholesky(K_noise)\n", + " noise_new[subj] = np.zeros([n_T[subj], n_V[subj]])\n", + " noise_new[subj][0, :] = np.dot(L_noise, np.random.randn(n_V[subj]))\\\n", + " / np.sqrt(1 - rho1[subj]**2)\n", + " for i_t in range(1, n_T[subj]):\n", + " noise_new[subj][i_t, :] = noise_new[subj][i_t - 1, :] * rho1[subj] \\\n", + " + np.dot(L_noise,np.random.randn(n_V[subj]))\n", + " Y_new[subj] = signal[subj] + noise_new[subj] \n", + "\n", + "\n", + "\n", + "ts, ts0 = gbrsa.transform(Y_new,scan_onsets=scan_onsets)\n", + "# ts is the estimated task-related time course, with each column corresponding to the task condition of the same\n", + "# column in design matrix.\n", + "# ts0 is the estimated time courses that have the same spatial spread as those in the training data (X0).\n", + "# It is possible some task related signal is still in X0 or ts0, but not captured by the design matrix.\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "for s in range(n_subj):\n", + " recovered_plot, = axes[s].plot(ts[s][:200, 8], 'b')\n", + " design_plot, = axes[s].plot(design[s].design_task[:200, 8], 'g')\n", + " if s == int(n_subj/2):\n", + " axes[s].set_xlabel('time',fontsize='xx-large')\n", + " \n", + "fig.legend([design_plot, recovered_plot],\n", + " ['design matrix for one condition', 'recovered time course for the condition'],\n", + " fontsize='xx-large')\n", + "\n", + "plt.show()\n", + "\n", + "# We did not plot the whole time series for the purpose of seeing closely how much the two\n", + "# time series overlap\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=n_subj, figsize=(25, 5))\n", + "for s in range(n_subj):\n", + " c = np.corrcoef(design[s].design_task.T, ts[s].T)\n", + " im = axes[s].pcolor(c[0:16, 16:],vmin=-0.5,vmax=1)\n", + " axes[s].set_aspect(1)\n", + " if s == int(n_subj/2):\n", + " axes[s].set_xlabel('recovered time course',fontsize='xx-large')\n", + " if s == 0:\n", + " axes[s].set_ylabel('true design matrix',fontsize='xx-large')\n", + "fig.suptitle('correlation between true design matrix \\nand the recovered task-related activity')\n", + "fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.75)\n", + "plt.show()\n", + "\n", + "\n", + "print('average SNR level:', snr_level)\n", + "print('Apparently how much the recovered time course resembles the true design matrix depends on SNR')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model selection by cross-validataion \n", + "\n", + "Both BRSA and GBRSA can compare full model against a null model (without task-related responses) by cross-validating the parameters of one model learnt from some training data on some testing data. GBRSA provides a `score()` function, which returns a pair of cross-validated log likelihood for the testing data. \n", + "\n", + "The first returned item is a numpy array of the cross-validated log likelihood of the model you have specified, for the testing data of all the subjects.\n", + "The second is a numpy arrary of those of a null model which assumes everything else the same except that there is no task-related activity.\n", + "\n", + "Notice that comparing the score of your model of interest against its corresponding null model is not the only way to compare models. You might also want to compare against a model using the same set of design matrix, but a different rank (especially rank 1, which means all task conditions have the same response pattern, only differing in their magnitude).\n", + "\n", + "In general, in the context of GBRSA, a model means the timing of each event and the way these events are grouped, together with other trivial parameters such as the rank of the covariance matrix and the number of nuisance regressors. All these parameters can influence model performance.\n", + "In future, we may provide interface to evaluate the predictive power for the data by different predefined similarity matrix or covariance matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "When cross-validating on new data that have the same property of signal and noise with training data., full model should be better than null model\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "When cross-validating on pure noise, full model should not be better than null model\n" + ] + } + ], + "source": [ + "\n", + "width = 0.35\n", + "[score, score_null] = gbrsa.score(X=Y_new, design=[d.design_task for d in design], scan_onsets=scan_onsets)\n", + "\n", + "plt.bar(np.arange(n_subj),np.asarray(score)-np.asarray(score_null), width=width)\n", + "# plt.ylim(0, np.max([np.asarray(score)-np.asarray(score_null)])+100)\n", + "plt.ylabel('cross-validated log likelihood')\n", + "plt.xlabel('partipants')\n", + "plt.title('Difference between cross-validated log likelihoods\\n of full model and null model\\non new data containing signal')\n", + "plt.show()\n", + "print('When cross-validating on new data that have the same property of signal and noise with training data., full model should be better than null model')\n", + "\n", + "Y_nosignal = [noise_new[s] for s in range(n_subj)]\n", + "[score_noise, score_null_noise] = gbrsa.score(X=Y_nosignal, design=[d.design_task for d in design], scan_onsets=scan_onsets)\n", + "\n", + "plt.bar(np.arange(n_subj),np.asarray(score_noise)-np.asarray(score_null_noise), width=width)\n", + "# plt.ylim(np.min([np.asarray(score_noise)-np.asarray(score_null_noise)])-100,\n", + "# 0)\n", + "plt.ylabel('cross-validated log likelihood')\n", + "plt.xlabel('partipants')\n", + "plt.title('Difference between cross-validated log likelihoods\\n of full model and null model\\non pure noise')\n", + "plt.show()\n", + "print('When cross-validating on pure noise, full model should not be better than null model')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Avoid false discovery \n", + "\n", + "If a model is fit to pure noise, some result of similarity structure can still be returned. How do we know if the result is valid?\n", + "\n", + "One approach is to examine the cross-validation score on left-out scans acquired with the same task.\n", + "\n", + "Below, we fit the model to data containing only noise and cross-validate it on another set of noise.\n", + "\n", + "When fitted to noise, the result should be meaningless. Ideally the cross-validated log likelihood of the full model should be smaller than that of the null model." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gbrsa_noise = GBRSA(n_iter=40)\n", + "gbrsa_noise.fit(X=[noise[s] for s in range(n_subj)],\n", + " design=[d.design_task for d in design],scan_onsets=scan_onsets)\n", + "Y_nosignal = [noise_new[s] for s in range(n_subj)]\n", + "[score_noise, score_null_noise] = gbrsa_noise.score(X=Y_nosignal,\n", + " design=[d.design_task for d in design], scan_onsets=scan_onsets)\n", + "\n", + "plt.bar(np.arange(n_subj),np.asarray(score_noise)-np.asarray(score_null_noise), width=width)\n", + "plt.ylim(np.min([np.asarray(score_noise)-np.asarray(score_null_noise)])-100,\n", + " np.max([np.asarray(score_noise)-np.asarray(score_null_noise)])+100)\n", + "plt.ylabel('cross-validated log likelihood')\n", + "plt.xlabel('partipants')\n", + "plt.title('Difference between cross-validated log likelihoods\\n of full model and null model\\ntrained on pure noise')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the difference is smaller but full model generally performs slightly worse, because of overfitting. This is expected.\n", + "\n", + "So, after fitting a model to your data, you should also check cross-validated log likelihood on separate runs from the same group of participants, and make sure your model is at least better than a null model before you trust your similarity matrix. \n", + "\n", + "Another diagnostic of bad model to your data is very small diagonal values in the shared covariance structure `U_` as shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'covariance matrix of task conditions estimated from pure noise')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolor(gbrsa_noise.U_)\n", + "plt.colorbar()\n", + "ax = plt.gca()\n", + "ax.set_aspect(1)\n", + "plt.title('covariance matrix of task conditions estimated from pure noise')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary \n", + "\n", + "(Group) Bayesian RSA models the covariance structure of the task-related activation patterns, and how the activation patterns and task-unrelated fluctuations together contribute to the temporal correlation in the fMRI data. By simulating fMRI data containing both task-related activation and spatio-temporally correlated noise, we show that (Group) Bayesian RSA recovers the similarity structure of activation patterns better than traditional RSA and suffers less from spurious correlation structure. GBRSA can additionally be used to decode task-related signals from new data. GBRSA also provides the ability to cross-validate the full model containing task-related signals against a null model assuming only spatiotemporally correlated noise, to prevent false discoveries." + ] + } + ], + "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.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/examples/brsa/example_design.1D b/docs/examples/brsa/example_design.1D new file mode 100644 index 00000000..7385edea --- /dev/null +++ b/docs/examples/brsa/example_design.1D @@ -0,0 +1,272 @@ +# + 1 -1.0000000112159 0.99459451576695 -0.99999999935909 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0067129032686353 0.010406452231109 -0.009523656219244 -0.050046753138304 0.00098924792837352 0.014952690340579 + 1 -0.98918920040512 0.9623373937801 -0.93600852797536 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0.0085870968177915 -0.0038935476914048 -0.010923656169325 0.019553247839212 0.0039892479544505 -0.20644730236381 + 1 -0.97837838959431 0.93043089268441 -0.87375120856684 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0.030487096868455 0.1236064536497 -0.040723655372858 -0.054246752988547 -0.0075107525335625 -0.0066473102197051 + 1 -0.9675675787835 0.89887501247988 -0.81320908865291 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0.067987094633281 0.064706451259553 -0.047223657369614 0.010453246533871 -0.024510751594789 0.085652687586844 + 1 -0.95675676797268 0.86766975316651 -0.75436321575299 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -0.067487093620002 0.11460645031184 -0.074723657220602 -0.12964675202966 -0.030410750885494 0.30405268166214 + 1 -0.94594595716187 0.8368151147443 -0.69719463738645 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.027775989845395 -0.099387097172439 0.11130645405501 -0.059223655611277 -0.0059467516839504 -0.010510752093978 0.0095526902005076 + 1 -0.93513514635106 0.80631109721326 -0.64168440107271 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.14959700405598 -0.089187095873058 0.15680645685643 -0.070323657244444 -0.050846753118094 -0.0029107519658282 0.14565269742161 + 1 -0.92432433554025 0.77615770057338 -0.58781355433115 0 0 0 0 0 0.037642534822226 0 0 0 0 0 0 0 0 0 0 0.12429390102625 -0.083387094549835 0.12480645161122 -0.054423656314611 -0.050246753133251 0.013389248284511 0.11435268912464 + 1 -0.91351352472944 0.74635492482465 -0.53556314468118 0 0 0 0 0 0.12830232083797 0 0 0 0 0 0 0 0 0 0 0.049149610102177 -0.062687094323337 0.13770644646138 -0.042223654687405 -0.046746753156185 0.018289248342626 0.072352689690888 + 1 -0.90270271391863 0.71690276996709 -0.48491421964219 0 0 0 0 0 0.17503398656845 0 0 0 0 0 0 0 0 0 0 0.0058261859230697 -0.045587095431983 0.2022064505145 -0.047923658043146 -0.12844675406814 0.016089248354547 0.16415269766003 + 1 -0.89189190310782 0.6878012360007 -0.43584782673358 0.00055640988284722 0 0 0 0 0.12353418022394 0 0 0 0 0 0 0 0 0 0 -0.011150837875903 -0.056987094692886 0.12560645025223 -0.06052365526557 -0.073546752333641 0.0068892481504008 -0.025347310118377 + 1 -0.88108109229701 0.65905032292546 -0.38834501347474 0.085981301963329 0 0 0 0 0.043058145791292 0 0 0 0 0 0 0 0 0 0 -0.0138487406075 0.029312903992832 -0.087693546898663 -0.014023656025529 0.021853249520063 -0.022210751776583 -0.050747311674058 + 1 -0.8702702814862 0.63065003074138 -0.34238682738507 0.13706742227077 0 0 0 0 -0.0014883950352669 0 0 0 0 0 0 0 0 0.00446742400527 0 -0.010243398137391 0.030112902633846 -0.098093544133008 -0.025723656639457 0.082353252917528 -0.023310751770623 -0.20704731252044 + 1 -0.85945947067539 0.60260035944847 -0.29795431598397 0.074951887130737 0 0 0 0 -0.016573801636696 0 0 0 0 0 0 0 0 0.13216799497604 0 -0.0057357279583812 0.043912903405726 -0.12029355484992 -0.026223655790091 0.087853241711855 0.0078892478486523 -0.07564730849117 + 1 -0.84864865986458 0.57490130904671 -0.25502852679083 0.020650556311011 0 0 0 0 -0.016711676493287 0 0.064530149102211 0 0 0 0 0 0 0.16308039426804 0 -0.0026250404771417 0.069412906654179 -0.029693548567593 -0.015923656057566 -0.02844675257802 0.027189248125069 0.088752687908709 + 1 -0.83783784905377 0.54755287953612 -0.21359050732505 -0.0044987495057285 0 0 0 0 -0.011434393003583 0 0.20859688520432 0 0 0 0 0 0 0.07964064925909 0 0 0.029712903313339 0.11960645299405 -0.00012365635484457 -0.19364675506949 0.012089247698896 0.15545268449932 + 1 -0.82702703824295 0.52055507091669 -0.17362130510603 -0.012204987928271 0 0 0 0 -0.0061583844944835 0 0.24455913901329 0 0 0 0 0 0 0.018422532826662 0 0 0.013712903484702 0.10110645275563 -0.00042365584522486 -0.062646753154695 0.0082892481004819 0.024252690374851 + 1 -0.81621622743214 0.49390788318842 -0.13510196765317 -0.011045500636101 0 0 0 0 -0.0020890964660794 0 0.26294341683388 0 0 0 0 0 0 -0.0083925630897284 0 0 0.01411290327087 0.092506448738277 0.0008763438090682 -0.053346753120422 -0.0057107518659905 -0.13064731564373 + 1 -0.80540541662133 0.46761131635132 -0.098013542485854 -0.0070121213793755 0 0 0 0 0 0 0.20453441143036 0 0 0 0 0 0 -0.015550730749965 0 0 0.025512902997434 0.13680644612759 0.0012763440608978 -0.14484675601125 -0.0033107522176579 0.010352690238506 + 1 -0.79459460581052 0.44166537040537 -0.062337077123487 -0.0035262261517346 0 0 0 0 0 0 0.19082318246365 0 0 0 0 0 0 -0.01305516064167 0 0 0.022012903355062 0.15430645924062 0.006576344370842 -0.14244675263762 0.0068892481504008 0.073352691717446 + 1 -0.78378379499971 0.41607004535059 -0.028053619085463 -0.0014841681113467 0 0 0 0 0 0 0.21973279118538 0 0 0 0 0 0 -0.0079289497807622 0 0 0.01741290371865 0.040706452913582 0.0064763445407152 -0.052846753038466 0.00058924793847837 0.0023526903241873 + 1 -0.7729729841889 0.39082534118696 0.0048557841088193 0 0 0 0 0 0 0 0.16675978899002 0 0 0 0 0 0 -0.0038589551113546 0 0 -0.0357870971784 -0.13709354121238 -0.022623656317592 0.030053246766329 -0.017310752649792 -0.0009473105892539 + 1 -0.76216217337809 0.3659312579145 0.036410084939965 0 0 0 0 0 0 0 0.18963772058487 0 0 0 0 0 0 0 0 0 -0.024887095205486 -0.13729354459792 -0.045723658055067 0.063253249973059 -0.003910752129741 -0.030147309415042 + 1 -0.75135136256728 0.3413877955332 0.066628235888576 0 0 0 0 0 0 0 0.15496288239956 0 0 0 0 0 0 0 0 0 -0.011787096969783 -0.19019354600459 -0.030823655426502 0.10135324671865 0.017589247669093 -0.20194731559604 + 1 -0.74054055175647 0.31719495404306 0.095529189435256 0 0 6.292293255683e-05 0 0 0 0 0.17730142176151 0 0 0 0 0 0 0 0 0 -0.015487096272409 -0.17039355356246 -0.030923657119274 0.12055324390531 0.014289247686975 -0.15214730706066 + 1 -0.72972974094566 0.29335273344408 0.12313189806061 0 0 0.095935180783272 0 0 0 0 0.12749932706356 0 0 0 0 0 0 0 0 0 0.034612902440131 0.1443064538762 0.0044763442128897 -0.13524674996734 -0.022810752619989 0.2602526852861 + 1 -0.71891893013485 0.26986113373627 0.14945531424524 0 0 0.19222097098827 0 0 0 0 0.036020509898663 0 0 0 0 0 0 0 0 0 0.03431290294975 0.077506455592811 0.0023763440549374 -0.011446751654148 -0.02061075263191 0.042452690191567 + 1 -0.70810811932404 0.24672015491961 0.17451839046975 0 0 0.11517268419266 0 0 0 0 -0.012899462133646 0.047586746513844 0 0 0 0 0 0 0 0 0.0031129033304751 -0.11499355453998 0.007476344704628 0.12395324185491 -0.0040107519598678 -0.13654731120914 + 1 -0.69729730851323 0.22392979699412 0.19834007921474 0 0 0.035251531749964 0 1.7466900317231e-06 0 0 -0.025363964959979 0.17251434922218 0 0 0 0 0 0 0 0 -0.00048709660768509 -0.16689355392009 -0.008623656234704 0.1636532433331 0.00328924797941 -0.26004731561989 + 1 -0.68648649770241 0.20149005995979 0.22093933296081 0 0 -0.0034804616589099 0 0.058831561356783 0 0 -0.021560948342085 0.1271647810936 0 0 0 0 0 0 0 0 -0.0016870964318514 -0.099493545480072 0.0053763436153531 0.046653244644403 0.0083892479306087 0.076252688653767 + 1 -0.6756756868916 0.17940094381662 0.24233510418858 0 0 -0.016322674229741 0 0.15306103229523 0 0 -0.014806993305683 0.046425126492977 0 0 0 0 0 0 0 0 0.0041129032615572 -0.1288935514167 0.0052763437852263 0.10215324535966 0.013489248114638 -0.063347308896482 + 1 -0.66486487608079 0.15766244856461 0.26254634537864 0 0 -0.015743028372526 0 0.22671715915203 0 0 -0.0065927244722843 0.0028545362874866 0 0 0 0 0 0 0 0 -0.0088870963081717 -0.06669354904443 -0.0042236563749611 0.062953244894743 0.0053892479045317 -0.028147309087217 + 1 -0.65405406526998 0.13627457420376 0.28159200901159 0 0 -0.010351501405239 0 0.21719300746918 0 0 -0.0031336443498731 -0.013423582538962 0 0 0 0 0 0 0 0 -0.0025870967656374 -0.10389354545623 -0.0022236560471356 0.034853246062994 0.014289247686975 -0.067447311244905 + 1 -0.64324325445917 0.11523732073408 0.29949104756804 0 0 -0.0053398911841214 0 0.18410536646843 0 0 0 -0.015115818940103 0 0 0 0 0 0 0 0 -0.01188709679991 -0.087793548591435 0.0061763431876898 0.040753249078989 -0.0085107517661527 0.015252690354828 + 1 -0.63243244364836 0.094550688155553 0.3162624135286 0 0 -0.0022931022103876 0 0.17885300517082 0 0 0 -0.010725096799433 0 0 0 0 0 0 0 0 -0.0017870971933007 -0.059793551452458 0.0063763447105885 0.015653248876333 -0.018010751460679 0.079052687622607 + 1 -0.62162163283755 0.07421467646819 0.33192505937386 0 0 0 0 0.16898131370544 0 0 0 -0.005837693810463 0 0 0 0 0 0 0 0 -0.0010870965197682 -0.1001935498789 0.010876344516873 0.028153244405985 8.924794383347e-05 -0.035947310738266 + 1 -0.61081082202674 0.054229285671989 0.34649793758443 0 0 0 0 0.14792582392693 0 0 0 -0.0026140084955841 0 0 0 0 0 0 0 0 -0.015187096782029 -0.1052935468033 0.0063763447105885 0.056053247302771 0.003689247998409 -0.019047311507165 + 1 -0.60000001121593 0.034594515766948 0.36000000064091 0 0 0 0 0.12118621170521 0 0 0 0 0 0 0 0 0 0 0 0 -0.0023870971053839 -0.094993551261723 0.015476344153285 0.02055324986577 -0.0034107520477846 0.099752687849104 + 1 -0.58918920040512 0.01531036675307 0.37245020102391 0 0.0016005024081096 0 0 0.12434333562851 0 0 0 0 0 0 0 0 0 0 0 0 -0.015487096272409 -0.11449354607612 0.0011763442307711 0.074553247541189 -0.0011107519967481 -0.027947309426963 + 1 -0.57837838959431 -0.0036231613696476 0.38386749121403 0 0.096228934824467 0 0 0.054626442492008 0 0 0 0 0 0 0 0 0 0 0 0 0.018212903290987 -0.08299354929477 0.015376344323158 0.0053532458841801 0.00078924793342594 0.028352689929307 + 1 -0.5675675787835 -0.022206068601203 0.39427082369186 0 0.13414172828197 0 0 0.0015350170433521 0 0 0 0 0 0 0 0 1.3503349691746e-05 0 0 0 0.012112903408706 -0.099593547172844 0.012776343151927 0.0025532469153404 0.0090892481384799 -0.10724730696529 + 1 -0.55675676797268 -0.040438354941598 0.40367915093803 0 0.069246374070644 0 0 -0.018672101199627 0 0 0 0 0 0 0 0 0.072324976325035 0 0 0 0.0093129032757133 -0.038593546487391 0.010976344347 -0.0063467547297478 0.0104892476229 0.028652690351009 + 1 -0.54594595716187 -0.058320020390831 0.41211142543312 0 0.017592553049326 0 0.014113682322204 -0.019757304340601 0 0 0 0 0 0 0 0 0.15773610770702 0 0 0 0.0073129032971337 -0.064593550749123 0.015476344153285 0.036053244024515 0.0092892477987334 -0.10364731308073 + 1 -0.53513514635106 -0.075851064948903 0.41958659965775 0 -0.0056622386910021 0 0.12503287196159 -0.013525931164622 0 0 0 0 0 0 0 0 0.097588993608952 0 0 0 0.012712903320789 -0.0035935482010245 0.0058763436973095 -0.023246753960848 -0.0033107522176579 0.025152690708637 + 1 -0.52432433554025 -0.093031488615813 0.42612362609251 0 -0.012351076118648 0 0.11872909218073 -0.0082509722560644 0 0 0 0 0 0 0.012349472381175 0 0.030836544930935 0 0 0 0.016412903554738 -0.037193548865616 0.01207634434104 0.019053246825933 -0.0079107518540695 -0.10244730766863 + 1 -0.51351352472944 -0.10986129139156 0.43174145721801 0 -0.010752606205642 0 0.050772178918123 -0.0035070178564638 0 0 0 0 0 0 0.1094037592411 0 -0.0020397072657943 0 0 0 0.017712903209031 0.030806452967227 0.0045763440430164 -0.016246754676104 -0.011410752427764 0.01055269036442 + 1 -0.50270271391863 -0.12634047327615 0.43645904551486 0 -0.0066744363866746 0 0.0084341736510396 -0.0015163091011345 0.04815686494112 0 0 0 0 0 0.10388795286417 0 -0.01319295912981 0 0 0 0.023812904022634 -0.030193549580872 0.012576343491673 0.026353243738413 -0.0029107519658282 -0.13134731259197 + 1 -0.49189190310782 -0.14246903426957 0.44029534346365 0 -0.0033013850916177 0 -0.0088908206671476 0 0.13978426158428 0 0 0 0 0 0.044425655156374 0 -0.013019875623286 0 0 0 0.025112903676927 0.036006451584399 0.00097634363919497 -0.051846753107384 0.011489247786812 0.041552689857781 + 1 -0.48108109229701 -0.15824697437184 0.44326930354498 0 -0.0013714701635763 0 -0.012442322447896 0 0.13858208060265 0 0 0 0 0 0.0073799015954137 0 -0.0086652403697371 0 0 0 0.021412903442979 -0.0093935476616025 0.01237634383142 0.044653248041868 0.013189247692935 -0.1755473157391 + 1 -0.4702702814862 -0.17367429358294 0.44539987823947 0.0030656999442726 0 0 -0.0096218045800924 0 0.18833549320698 0 0 0 0 0 -0.0077794678509235 0 -0.0045090229250491 0 0 0 0.022612904198468 -0.014093547128141 0.0094763431698084 0.061953250318766 -0.0081107524456456 -0.16874730493873 + 1 -0.45945947067539 -0.18875099190288 0.44670602002772 0.12636050581932 0 0 -0.0055486336350441 0 0.11498866230249 0 0 0 0 0 -0.010887031443417 0 -0.0019495403394103 0 0 0 0.040712905116379 0.071606452576816 0.0063763447105885 -0.038346753455698 -0.0038107522996143 -0.03504731040448 + 1 -0.44864865986458 -0.20347706933166 0.44720668139032 0.16548715531826 0 0 -0.0025971501599997 0 0.030592679977417 0 0 0 0 0 -0.0084190787747502 0 0 0.053775411099195 0 0 0.020712903700769 0.052206452004611 0.0067763440310955 -0.020446753129363 -0.0027107520727441 0.13395269308239 + 1 -0.43783784905377 -0.21785252586928 0.44692081480789 0.083070278167725 0 0.00069552229251713 0 0 -0.0093372892588377 0 0 0 0 0 -0.0048550544306636 0 0 0.17381578683853 0 0 0.023612902499735 0.031806453131139 0.0089763440191746 0.01885324344039 -0.0023107520537451 0.0600526900962 + 1 -0.42702703824295 -0.23187736151574 0.44586737276102 0.020175436511636 0 0.10747677832842 0 0 -0.020309561863542 0 0 0 0 0 -0.0022725064773113 0 0 0.12343865633011 0 0 0.054112904705107 0.063506453298032 0.013076344504952 -0.10814675316215 -0.00681075186003 0.09105268958956 + 1 -0.41621622743214 -0.24555157627104 0.44406530773032 -0.0077522136271 0 0.17133423686028 0 0 -0.018001658841968 0 0 0 0 0.00055644899839535 0 0 0 0.043845765292645 0 0 0.05091290269047 0.047706454060972 0.011776342988014 -0.072146752849221 0.0052892480744049 -0.058047308586538 + 1 -0.40540541662133 -0.25887517013517 0.4415335721964 -0.015503321774304 0 0.093689776957035 0 0 -0.011593883857131 0 0 0 0 0.085981898009777 0 0 0 0.0017423888202757 0 0 0.063712903298438 0.080906453542411 -0.001023655757308 -0.16354675218463 0.0059892478166148 0.03335269074887 + 1 -0.39459460581052 -0.27184814310814 0.43829111863984 -0.013250176794827 0 0.025813156738877 0 0 -0.0052539245225489 0 0 0 0 0.13706727325916 0 0 0 -0.013717586174607 0 0 0.062212903983891 0.095306451432407 -0.00042365584522486 -0.17324675247073 -0.001310752122663 -0.022447309456766 + 1 -0.38378379499971 -0.28447049518995 0.43435689954127 -0.008134912699461 0 -0.0056234514340758 0 0 0.006489459425211 0 0 0 0 0.074951559305191 0 0 0 -0.015004207380116 0 0 0.051512901671231 0.058706454001367 0.0025763437151909 -0.10944675281644 -0.011610752088018 -0.15204730536789 + 1 -0.3729729841889 -0.2967422263806 0.42974986738128 -0.0039911866188049 0 -0.015256236307323 0 0 0.11816956847906 0 0 0 0 0.020650375634432 0 0 0 -0.010505273938179 0 0 0.053812903352082 0.1143064526841 -0.011323656188324 -0.19274675473571 -0.012810751912184 0.055052691139281 + 1 -0.36216217337809 -0.30866333668009 0.42448897464048 0 0 -0.013806872069836 0 0 0.12816107273102 0 0 0 0 -0.0044988198205829 0 0 0 -0.0056656016968191 0 0 0.045312904752791 0.049706450663507 0.0063763447105885 -0.060146752744913 0.004089248017408 0.00065269041806459 + 1 -0.35135136256728 -0.32023382608842 0.41859317379946 0 0 -0.008765147998929 0 0 0.15216007828712 0 0 0 0 -0.012204997241497 0 0 0 -0.0025189006701112 0 0 0.041512903757393 0.10200645308942 0.0028763441368937 -0.084046754986048 -0.0025107521796599 0.19385269377381 + 1 -0.34054055175647 -0.33145369460559 0.41208141733884 0.00042675601434894 0 -0.0044077797792852 0 0 0.12315040826797 0 0 0 0 -0.011045484803617 0 0 0 0 0 0 0.043612902052701 0.092406454496086 0.0044763442128897 -0.044746753294021 -0.016510752146132 0.060752690769732 + 1 -0.32972974094566 -0.34232294223159 0.40497265773921 0.12098247557878 0 -0.001855208654888 0 0 0.045295763760805 0 0 0 0 -0.0070121022872627 0 0 0 0 0 0 0.047312905080616 0.0077064521610737 0.011176344007254 0.020053248852491 -0.019710752298124 -0.024547311477363 + 1 -0.31891893013485 -0.35284156896643 0.39728584748118 0.20731872320175 0 0 0 0 -0.00076612085103989 0 0 0 0 -0.0035262131132185 0 0.017642103135586 0 0 0 0 0.04471290204674 0.050606450997293 0.006076343357563 -0.032946752384305 -0.0031107520917431 0.017152690328658 + 1 -0.30810811932404 -0.36300957481012 0.38903993904535 0.11678945273161 0 0 0 0 -0.01625781878829 0 0 0 0 -0.0014841614756733 0 0.15629108250141 0 0 0 0 0.055312902666628 0.081206451170146 0.005676344037056 -0.071046752855182 -0.001310752122663 0.070552689023316 + 1 -0.29729730851323 -0.37282695976264 0.38025388491233 0.033387824892998 0 0 0 0 -0.016767358407378 0.028632424771786 0 0 0 0 0 0.14841136336327 0 0 0 0 0.052412902005017 0.038706452585757 0.01857634447515 -0.032746752724051 -0.0019107520347461 -0.017247310839593 + 1 -0.28648649770241 -0.38229372382399 0.37094663756271 -0.0058099492453039 0 0 0 0 -0.011784705333412 0.17964339256287 0 0 0 0 0 0.063465222716331 0 0 0 0 0.048512903042138 0.039306451566517 0.0098763443529606 -0.030746752396226 0.005889247986488 -0.020847308449447 + 1 -0.2756756868916 -0.39140986699419 0.36113714947711 -0.018164224922657 0 0 0 0 -0.005407671444118 0.15981185436249 0 0 0 0 0 0.010542716830969 0 0 0 0 0.053912905044854 0.058206452988088 0.0033763442188501 -0.060346753336489 0.0084892477607355 0.01635269029066 + 1 -0.26486487608079 -0.40017538927323 0.35084437313612 -0.016777858138084 0 0 0 0 -0.0026109907776117 0.18218821287155 0 0 0 0 0 -0.011113525368273 0 0 0 0 0.045912903733552 0.074306453578174 -0.0034236563369632 -0.05854675360024 0.016989248688333 0.071852688677609 + 1 -0.25405406526998 -0.4085902906611 0.34008726102035 -0.010774576105177 0 0 0 0 0 0.17693194746971 0 0 0 0 0 -0.015552902594209 0 0 0 0 0.04131290409714 0.071206453256309 0.0021763434633613 -0.045946753118187 -0.0020107520977035 0.024952690117061 + 1 -0.24324325445917 -0.41665457115781 0.32888476561041 -0.0054639861918986 0 0 0 0 0 0.17483820021152 0 0 0 0 0 -0.012027255259454 0 0 0 0 0.039012902416289 0.069406452588737 -0.001923656091094 -0.024946752935648 -0.003910752129741 -0.0061473092064261 + 1 -0.23243244364836 -0.42436823076337 0.31725583938689 -0.0023150618653744 0 0 0 0 0 0.12542612850666 0 0 0 0 0 -0.0069357920438051 0 0 0 0 0.035812904126942 0.060206453315914 0.0042763436213136 0.026653248816729 0.00018924794858322 -0.099747306667268 + 1 -0.22162163283755 -0.43173126947776 0.3052194348304 0 0 0 0 0 0 0.13749043643475 0 0 0 0 0 -0.0032464377582073 0 0 0 0 0.029112902469933 0.11720644962043 0.0043763434514403 0.0016532465815544 0.0012892479426228 0.0097526903264225 + 1 -0.21081082202674 -0.43874368730098 0.29279450442154 0 0 0 0 0 0 0.14846354722977 0 0 0 0 0 0 0 0 0 0 0.031112902797759 0.03860645275563 0.014176344498992 0.043153245002031 -0.0030107522616163 -0.070447309873998 + 1 -0.20000001121593 -0.44540548423305 0.28000000064091 0 0 0 0 0 0 0.19279418885708 0 0 0 0 0 0 0 0 0 0 0.022912903688848 0.10360645037144 0.0073763430118561 0.010053247213364 0.00078924793342594 0.13845268730074 + 1 -0.18918920040512 -0.45171666027396 0.26685487596912 0 0 0 0 0 0 0.21137630939484 0 0 0 0 0 0 0 0 0 0 0.015312903560698 0.082306454889476 0.0033763442188501 0.041253250092268 0.004089248017408 0.18055269215256 + 1 -0.17837838959431 -0.4576772154237 0.25337808288678 0 0 0 0.043020330369473 0 0 0.14208625257015 0 0 0 0 0 0 0 0 0 0 0.0055129032116383 0.077706451527774 -0.0071236561052501 -0.037946753203869 0.0025892478879541 0.2391526857391 + 1 -0.1675675787835 -0.46328714968228 0.23958857387448 0 0 0 0.13905262947083 0 0 0.041933041065931 0 0 0 0 0 0 0 0 0 0 0.023912903852761 0.15820645075291 -0.025423657149076 -0.1429467536509 0.0025892478879541 0.15375268552452 + 1 -0.15675676797268 -0.46854646304971 0.22550530141283 0 0 0 0.098750926554203 0 0 -0.012082259170711 0 0 0.018220633268356 0 0 0 0 0 0 0 0.011012903414667 0.10640645306557 -0.010123656247742 -0.062346752732992 -0.0088107521878555 -0.021447311155498 + 1 -0.14594595716187 -0.47345515552597 0.21114721798243 0 0 0 0.03507661446929 0 0 -0.026482511311769 0 0 0.11431851238012 0 0 0 0 0 0 0 -0.011787096969783 -0.048293546773493 0.00067634414881468 0.074753243476152 -0.0072107521118596 -0.055747306905687 + 1 -0.13513514635106 -0.47801322711106 0.19653327606389 0 0.017292505130172 0 0.0013939110795036 0 0 -0.024222373962402 0 0 0.099139772355556 0 0 0 0 0 0 0 -0.0036870967596769 -0.067493547685444 0.0023763440549374 0.068653244525194 -0.010410752263851 -0.10984730627388 + 1 -0.12432433554025 -0.482220677805 0.1816824281378 0 0.12800069153309 0 -0.01097406912595 0 0 -0.015291653573513 0 0 0.04024151340127 0 0 0 0 0 0 0 0.016112903133035 -0.025893547572196 0.00077634397894144 -0.031946752220392 -0.024710751255043 0.090352692641318 + 1 -0.11351352472944 -0.48607750760778 0.16661362668478 0 0.11605546623468 0 -0.012003365904093 0 0 -0.0082694683223963 0 0 0.0054445695132017 0 0 0 0 0 0.0059029059484601 0 -0.016587096266448 -0.076993544586003 0.012976344674826 0.1091532446444 -0.021610752795823 -0.16014730837196 + 1 -0.10270271391863 -0.48958371651939 0.15134582418542 0 0.048352032899857 0 -0.0084042195230722 0 0 -0.0028834280092269 0 0 -0.0083946632221341 0 0 0 0 0 0.10000795125961 0 -0.02848709654063 -0.032693547196686 0.0011763442307711 0.096353251487017 0.0047892479924485 -0.094947307370603 + 1 -0.09189190310782 -0.49273930453984 0.13589797312033 0 0.0073072644881904 0.004996741656214 -0.0045324815437198 0 0 0 0 0 -0.010818615555763 0 0 0 0 0 0.11038105934858 0 -0.03128709550947 -0.040093549527228 0.0051763439550996 0.11825324967504 0.0080892479745671 -0.25064730551094 + 1 -0.081081092297009 -0.49554427166914 0.12028902597011 0 -0.009253709577024 0.11014425009489 -0.0020151205826551 0 0 0 0 0 -0.0081188511103392 0 0 0 0 0 0.051077321171761 0 -0.028087097220123 0.020306452177465 -0.0021236562170088 0.028753247112036 -0.019210751284845 0.077652693726122 + 1 -0.070270281486198 -0.49799861790727 0.10453793521537 0 -0.012408400885761 0.12837927043438 0 0 0 0 0 0.0099470904096961 -0.004590333905071 0 0 0 0 0 0.010568294674158 0 -0.039187095128 -0.094093550927937 0.0050763441249728 0.22715326026082 -0.021210751612671 -0.30834731366485 + 1 -0.059459470675387 -0.50010234325423 0.088663653336703 0 -0.0094509832561016 0.061017215251923 0 1.7468818214184e-06 0 0 0 0.1329403668642 -0.0021164785139263 0 0 0 0 0 -0.0067023267038167 0 -0.033887098543346 0.002206452190876 0.0094763431698084 0.092953253537416 0.002489247941412 -0.019747308455408 + 1 -0.048648659864576 -0.50185544771004 0.07268513281472 0 -0.0053962054662406 0.013384091667831 0 0.058831807225943 0 0 0 0.13926292955875 0 0 0 0 0 0 -0.010917749255896 0 -0.044387097470462 -0.085793544538319 0.0021763434633613 0.14515324309468 -0.004710752167739 -0.266447304748 + 1 -0.037837849053766 -0.50325793127469 0.056621326130022 0 -0.0025067001115531 -0.0071999179199338 0 0.14035293459892 0 0 0 0.062757529318333 0 0 0 0 0 0 -0.0088573601096869 0 -0.019987096078694 0.0048064524307847 0.0029763439670205 0.027753245085478 -0.0056107520358637 0.03505268972367 + 1 -0.027027038242955 -0.50430979394817 0.040491185763213 0 0.053441412746906 -0.012465350329876 0 0.089743755757809 0 0 0 0.012170788832009 0 0 0 0 0 0 -0.0052667763084173 0 -0.026087096892297 -0.04249354917556 0.0045763440430164 0.039753247052431 -0.019710752298124 -0.044147307984531 + 1 -0.016216227432144 -0.50501103573049 0.024313664194895 0 0.14021460711956 -0.010284850373864 0 0.029239932075143 0 0 0 -0.0091062942519784 0 0 0 0 0.0018005651654676 0 -0.0025229994207621 0 -0.039087097160518 -0.041293547488749 0.005676344037056 0.12005325034261 -0.015110752661712 -0.17924730386585 + 1 -0.0054054166213331 -0.50536165662166 0.0081077139056723 0 0.092748634517193 -0.0061801802366972 0 -0.0010622846893966 0 0 0 -0.014036962762475 0 0 0 0 0.10825754702091 0 0 0 -0.02738709654659 0.0081064521800727 0.00407634396106 0.039853248745203 -0.025110752438195 -0.0091473096981645 + 1 0.0054053941894776 -0.50536165662166 -0.008107712623852 0 0.031126981601119 -0.0029839819762856 0 -0.011565917171538 0 0.028552377596498 0 -0.011202690191567 0 0 0 0 0.15090943872929 0 0 0 -0.03188709821552 -0.042693548835814 0.0083763431757689 0.05095325037837 0.0030892478534952 0.014852690343105 + 1 0.016216205000289 -0.50501103573049 -0.024313662913075 0 -0.00027817318914458 0 0 -0.011690891347826 0 0.10350869596004 0 -0.0065927179530263 0 0 0 0 0.077902160584927 0 0 0 -0.065387095324695 -0.029893548227847 -0.011423656251281 0.11095324531198 0.010989247704856 0.1039526918903 + 1 0.027027015811099 -0.50430979394817 -0.040491184481393 0 -0.011387062259018 0 0.017292505130172 -0.007877248339355 0 0.076298668980598 0 -0.0031336380634457 0 0 0 0 0.01979162171483 0 0 0 -0.054587095044553 -0.038393546827137 -0.0098236562334932 0.07965325191617 0.0057892481563613 0.071052690036595 + 1 0.03783782662191 -0.50325793127469 -0.056621324848202 0 -0.011802065186203 0 0.12800069153309 -0.0041351648978889 0 0.027854926884174 0 0 1.9652418359328e-06 0 0 0 -0.0063700182363391 0 0 0 -0.047287098132074 -0.025793549604714 -0.0038236561231315 0.066753249615431 0.004089248017408 0.1022526929155 + 1 0.048648637432721 -0.50185544771004 -0.0726851315329 0 -0.008052596822381 0 0.11605546623468 -0.0018002366414294 0 0.0017126569291577 0 0 0.066185779869556 0 0 0 -0.013894959352911 0 0 0 -0.065787094645202 -0.0054935486987233 -0.016723656095564 0.030953247100115 -0.0070107524516061 0.095652692951262 + 1 0.059459448243532 -0.50010234325423 -0.088663652054883 0 -0.0028645200654864 0 0.048352032899857 0 0 -0.0080541670322418 0 0 0.15789704024792 0 0 0 -0.012096680700779 0 0 0 -0.051787096075714 -0.030793548561633 -0.014523656107485 0.094953242689371 -0.0089107520179823 -0.056247307918966 + 1 0.070270259054343 -0.49799861790727 -0.10453793393355 0 0.082330644130707 0 0.0073072644881904 0 0 -0.0090694855898619 0 0 0.10096172243357 0 0 0 -0.007508740760386 0 0 0 -0.048587097786367 0.04140645172447 -0.0070236562751234 -0.040346752852201 -0.029810751904733 0.063552689738572 + 1 0.081081069865153 -0.49554427166914 -0.12028902468829 0 0.11737401038408 0 -0.009253709577024 0 0 -0.0064350459724665 0 0 0.032894920557737 0 0 0 -0.0037140580825508 0 0.014120560139418 0 -0.046387097798288 -0.042093546129763 -0.0041236560791731 0.059353243559599 -0.010510752093978 -0.18344731535763 + 1 0.091891880675964 -0.49273930453984 -0.13589797183851 0 0.060590572655201 2.4012949066087e-26 -0.012408400885761 0 0 -0.0035026066470891 0 0 -0.0011950702173635 0 0 0 -0.0015429038321599 0 0.15219141542912 0 -0.053587096743286 0.0074064522050321 -0.015923656057566 0.002253245562315 0.0090892481384799 -0.063547312282026 + 1 0.10270269148678 -0.48958371651939 -0.1513458229036 0 0.015393483452499 0.084276184439659 -0.0094509832561016 0 0 -0.0015683997189626 0 0 -0.013011656701565 0 0 0 0 0 0.15163862705231 0 -0.041287097148597 -0.031393547542393 -0.0029236562550068 0.088153246790171 0.01738924800884 -0.19314731564373 + 1 0.11351350229759 -0.48607750760778 -0.16661362540296 0 -0.0049544586800039 0.2446226477623 -0.0053962054662406 0 0 0 0 0 -0.013152251951396 0.0011044126003981 0 0 0 0 0.066562041640282 0 -0.029687098227441 -0.078893546946347 -0.0059236562810838 0.017553243786097 -0.0053107520798221 -0.036047308705747 + 1 0.1243243131084 -0.482220677805 -0.18168242685598 0 -0.01080719102174 0.16756856441498 -0.0025067604146898 0 0 0 0 0 -0.0088619040325284 0.10258268564939 0 0 0 0 0.012005048803985 0 -0.021687096916139 -0.032093548215926 -0.006923656212166 0.062953244894743 -0.0041107522556558 -0.077147311531007 + 1 0.13513512391921 -0.47801322711106 -0.19653327478207 0.02777655608952 -0.0094085298478603 0.057876385748386 0 0 0 0 0 0 -0.0046520605683327 0.15266855061054 0 0 0 0 -0.010630848817527 0 -0.028887095861137 -0.02389354724437 -0.0087236562394537 0.0098532475531101 0.0017892479081638 0.061852690763772 + 1 0.14594593473002 -0.47345515552597 -0.21114721670061 0.1495973020792 -0.0058401320129633 0.00094535760581493 0 0 0 0 0 0 -0.0020252661779523 0.081088602542877 0 7.5448255643096e-08 0 0 -0.015581800602376 0 -0.025487097911537 -0.00049354787915945 -0.011723656207323 0.024553250521421 0.00038924789987504 -0.0054473103955388 + 1 0.15675674554083 -0.46854646304971 -0.22550530013101 0.12429348379374 -0.002888711867854 -0.019582450389862 0 0 0 0 0 0 0 0.021482115611434 0 0.066801764070988 0 0 -0.01223857421428 0 -0.02568709757179 -0.0035935482010245 -0.0018236562609673 0.02225324884057 -0.0075107525335625 -0.031247309409082 + 1 0.16756755635164 -0.46328714968228 -0.23958857259266 0.049149297177792 -0.001200036262162 -0.020836120471358 0 0 0 0.0026805191300809 0 0 0 -0.0057318191975355 0 0.17526826262474 0 0 -0.007129117846489 0 -0.019887096248567 -0.010493547655642 -0.0091236562293489 0.0025532469153404 0.0011892479233211 -0.095247312448919 + 1 0.17837836716245 -0.4576772154237 -0.25337808160496 0.0058260434307158 0 -0.014399533160031 0 0 0 0.079301044344902 0 0 0 -0.013821039348841 0 0.11593579500914 0 0 -0.003362531773746 0 -0.029887097887695 -0.024893549270928 -0.012123656226322 0.053453247994184 0.0093892476288602 -0.051047309301794 + 1 0.18918917797326 -0.45171666027396 -0.2668548746873 -0.011150880716741 0 -0.0076954429969192 0.0011043065460399 0 0 0.097848139703274 0 0 0 -0.012263779528439 0 0.03890872746706 0 0 0 0 -0.036987095139921 0.0021064523607492 -0.016323656309396 0.029853243380785 0.0075892478926107 -0.0091473096981645 + 1 0.19999998878407 -0.44540548423305 -0.27999999935909 -0.013848732225597 0 -0.0033972456585616 0.10258162766695 0 0 0.047784235328436 0 0 0 -0.0076978113502264 0 -0.00034771647187881 0 0 0 0 -0.037287096492946 0.020606452599168 -0.013623656239361 -0.017846751958132 -0.0050107521237805 0.12615268770605 + 1 0.21081079959488 -0.43874368730098 -0.29279450313971 -0.010243374854326 0 0 0.15266886353493 0 0 0.011053452268243 0 0 0 -0.0038390003610402 0.00055644899839535 -0.014233827590942 0 0 0 0 -0.036187096498907 0.0076064523309469 -0.011723656207323 0.018653247505426 -0.0022107519907877 0.023652690462768 + 1 0.22162161040569 -0.43173126947776 -0.30521943354858 -0.0057357028126717 0 0 0.081089183688164 0 0 -0.0050355666317046 0 0 0 -0.0016052267747 0.085981898009777 -0.014752581715584 0 0 0 0 -0.040587096475065 0.023506452329457 -0.021523656323552 0.022353250533342 0.016689247335307 -0.076547308824956 + 1 0.2324324212165 -0.42436823076337 -0.31725583810507 -0.002625027904287 0 0 0.021482426673174 0 0.00028454218409024 -0.009330440312624 0 0 0 0 0.13706727325916 -0.010065745562315 0 0 0 0 -0.032887096516788 -0.013293548487127 -0.017923655919731 0.014253247529268 0.016589247505181 -0.096347308717668 + 1 0.24324323202732 -0.41665457115781 -0.32888476432859 0 0 0 -0.0057317009195685 0 0.080655962228775 -0.0078330878168344 0 0 0 0 0.074951559305191 -0.0053311996161938 0 0 0 0 -0.044587097130716 -0.039993547834456 -0.019323656335473 0.11035325005651 -0.022410751436837 -0.097647308371961 + 1 0.25405404283813 -0.4085902906611 -0.34008725973853 0.00062593474285677 0 0 -0.01382102444768 0 0.13821229338646 -0.0047573610208929 0 0 0 0 0.020650375634432 -0.0023370909038931 0 0 0 0 -0.049287098459899 0.028606452979147 -0.027623657137156 0.03745324537158 -0.014610751648434 0.037952690385282 + 1 0.26486485364894 -0.40017538927323 -0.3508443718543 0.096728548407555 0 0 -0.012263810262084 0 0.077859088778496 -0.0023153687361628 0 0 0 0 -0.0044988198205829 0 0 0 0 0 -0.025887097232044 -0.1584935458377 0.010576343163848 0.28665323927999 0.0081892478046939 -0.28344732429832 + 1 0.27567566445975 -0.39140986699419 -0.36113714819529 0.15420092642307 0 0 -0.0076978439465165 0 0.022258253768086 0 0 0 0 0 -0.012204997241497 0 0 0.0040207784622908 0 0 -0.03188709821552 -0.1056935461238 -0.016523656435311 0.082253251224756 0.012089247698896 0.23425269220024 + 1 0.28648647527056 -0.38229372382399 -0.37094663628089 0.084321089088917 0 0 -0.0038390222471207 0 -0.0038734152913094 0 0 0 0 0 -0.011045484803617 0 0 0.11895155161619 0 0 -0.011487097479403 0.15390645246953 -0.02732365578413 -0.33114675804973 -0.0015107520157471 0.46645268891007 + 1 0.29729728608137 -0.37282695976264 -0.38025388363051 0.023231994360685 0 0 -0.0016052387654781 0 -0.012109502218664 0 0.021616401150823 0 0 0 -0.0070121022872627 0 0 0.14677220582962 0 0 -0.014587095938623 0.12170645128936 -0.021123656071723 -0.25024675950408 -0.0087107523577288 0.30875268671662 + 1 0.30810809689218 -0.36300957481012 -0.38903993776353 -0.0050610406324267 0 8.3067540401771e-08 0 0 -0.011185213923454 0 0.16000151634216 0 0 0 -0.0035262131132185 0 0 0.071676351130009 0 0 -0.011187096126378 -0.021293547935784 0.013976342976093 0.075053248554468 -0.0037107520038262 -0.023047308437526 + 1 0.31891890770299 -0.35284156896643 -0.39728584619936 -0.013730604201555 0 0.073483273386955 0 0 -0.0071830214001238 0 0.14506870508194 0 0 0 -0.0014841614756733 0 0 0.016580177471042 0 0 -0.010987096466124 -0.010493547655642 0.0095763429999352 -0.01044675335288 -0.004710752167739 -0.013647309504449 + 1 0.3297297185138 -0.34232294223159 -0.40497265645739 -0.012426199391484 0 0.19279517233372 0 0 -0.0036426351871341 0 0.060439497232437 0.0062459269538522 0 0 0 0 0 -0.0075533492490649 0 0 -0.02088709641248 -0.050193549133837 -0.0023236563429236 0.046753246337175 -0.017410752479918 -0.12824730481952 + 1 0.34054052932461 -0.33145369460559 -0.41208141605701 -0.007888650521636 0 0.12752863764763 0 0 -0.0015433629741892 0 0.0091338297352195 0.13768030703068 0 0 0 0 0 -0.013995659537613 0 0 0.0065129032736877 0.018406452611089 0.0043763434514403 -0.090446751564741 -0.023310751770623 0.15285268519074 + 1 0.35135134013542 -0.32023382608842 -0.41859317251764 -0.0039670118130744 0.0024526501074433 0.042799100279808 0 0 0 0 -0.011567215435207 0.16047409176826 0 0 0 0 0 -0.011749630793929 0 0 -0.017287096939981 -0.054993544705212 0.003176343627274 0.041453246027231 0.011889248038642 -0.00044730957597494 + 1 0.36216215094623 -0.30866333668009 -0.42448897335866 -0.0016696940874681 0.10108884423971 -0.00038268772186711 0 0 0 0 -0.015510492026806 0.076271519064903 0 0 0 0 0 -0.0071360412985086 0 0 -0.0055870963260531 -0.018493547104299 -0.0011236565187573 -0.0085467547178268 0.015189248020761 0.18875269684941 + 1 0.37297296175705 -0.2967422263806 -0.42974986609946 0 0.13238954544067 -0.01565725915134 0 0 0 0 -0.011813691817224 0.016730114817619 0 0 0 0 0 -0.0034730527549982 0.041677042841911 0 0.0019129030406475 -0.038693548180163 -0.00032365601509809 -4.6752393245697e-05 -0.00031075207516551 0.11815269384533 + 1 0.38378377256786 -0.28447049518995 -0.43435689825945 0 0.066455982625484 -0.016227813437581 0 0 0 0 -0.0067452238872647 -0.0089998971670866 0 0 0 0 0 0 0.17081795632839 0 -0.0021870965138078 -0.0014935480430722 -0.011423656251281 0.028053250163794 8.924794383347e-05 0.13765268865973 + 1 0.39459458337867 -0.27184814310814 -0.43829111735802 0 0.016140213236213 -0.0098451487720013 0 0 0 0 -0.0031334289815277 -0.015581687912345 0 0 0 0 0 0 0.13085924088955 0 -0.012287096120417 -0.031593547202647 -0.0014236560091376 0.042453248053789 -0.0017107521416619 -0.05474731232971 + 1 0.40540539418948 -0.25887517013517 -0.44153357091458 0 -0.0062018162570894 0.10811647772789 0 0 0 0 0 -0.012856062501669 0 0 0 0 0 0 0.049078978598118 0 -0.020487097091973 -0.050293547101319 -0.0031236563809216 0.083953250199556 0.00098924792837352 -0.12484730686992 + 1 0.41621620500029 -0.24555157627104 -0.4440653064485 0 -0.012402662076056 0.16706095635891 0 0 0 0 0 -0.0061247227713466 0 0 0 0 0 0 0.0040129679255188 0 -0.0066870963200927 0.034006453119218 -0.010323656199034 -0.067946752533317 0.0021892479853705 0.20965269301087 + 1 0.4270270158111 -0.23187736151574 -0.4458673714792 0 -0.010600126348436 0.090098448097706 0 0 0 0 0 0.092498958110809 0 0 0 0 0 0 -0.01310474704951 0 -0.02568709757179 -0.034993548877537 -0.015623656101525 0.092453245073557 0.010789248044603 -0.083147308789194 + 1 0.43783782662191 -0.21785252586928 -0.44692081352607 0 0.0093702841550112 0.023869017139077 0 0 0 0 0 0.13414172828197 0 0 0 0 0 0 -0.015217265114188 0 -0.034987098537385 -0.014693547971547 -0.021223655901849 0.061453249305487 0.013389248284511 -0.2369472971186 + 1 0.44864863743272 -0.20347706933166 -0.4472066801085 0 0.1374693363905 -0.0063686883077025 0 0 0 0 0 0.069246374070644 0 0 0 0 1.2008145858999e-05 0 -0.010944607667625 0 -0.021287097595632 0.0089064522180706 -0.017023656051606 -0.023146752268076 0.013789247605018 -0.078247307799757 + 1 0.45945944824353 -0.18875099190288 -0.4467060187459 0 0.13356995582581 -0.015356711111963 0 0 0 0 0 0.017592553049326 0 0 0 0 0.06429036706686 0 -0.0060129929333925 0 -0.030487096868455 -0.014193546958268 -0.017123656347394 0.047353249043226 0.00018924794858322 0.023852690123022 + 1 0.47027025905434 -0.17367429358294 -0.44539987695765 0 0.057118438184261 -0.013626421801746 0.0040210401639342 0 0 0 0 -0.0056622386910021 0 0 0 0 0.14020979404449 0 -0.0027119813021272 0 -0.042687098495662 -0.0022935476154089 -0.020723655819893 0.055353250354528 0.0013892479182687 0.095052690245211 + 1 0.48108106986515 -0.15824697437184 -0.44326930226316 0 0.009488333016634 -0.0085531240329146 0.11895248293877 0 0 0 0 -0.012351076118648 0 0 0 0 0.086744964122772 0 0 0 -0.017187097109854 0.080606455914676 -0.026223655790091 -0.095046754926443 -0.011210751836188 0.24795268569142 + 1 0.49189188067596 -0.14246903426957 -0.44029534218182 0 -0.01000221259892 -0.0042655561119318 0.14677180349827 0 0 0 0 -0.010752606205642 0.0067461780272424 0 0 0 0.027409762144089 0 0 0 -0.043387095443904 0.013006452238187 -0.0074236562941223 0.03295324370265 -0.014210752327926 -0.0089473100379109 + 1 0.50270269148678 -0.12634047327615 -0.43645904423304 0 -0.013997609727085 -0.0017835852922872 0.071675792336464 0 0 0 0 -0.0066744363866746 0.11429480463266 0 0 0 -0.0018132763216272 0 0 0 -0.014087096787989 -0.10489354748279 0.028776343911886 0.20875324681401 -0.00061075203120708 -0.30814731027931 + 1 0.51351350229759 -0.10986129139156 -0.43174145593619 0 -0.010824510827661 0 0.016579894348979 0.0021460687275976 0 0 0 -0.0033013850916177 0.12614978849888 0 0 0 -0.011727117933333 0 0 0 -0.022487097419798 -0.0638935463503 0.0048763435333967 0.085353244096041 0.011989247868769 -0.43564730789512 + 1 0.5243243131084 -0.093031488615813 -0.42612362481069 0 -0.0062421360053122 0 -0.0075534516945481 0.088452741503716 0 0 0 -0.0013714701635763 0.058374084532261 0 0 0 -0.011573190800846 0 0 0 0.0099129031877965 0.14590645115823 -0.021523656323552 -0.26314675435424 -0.0051107519539073 0.32535269949585 + 1 0.53513512391921 -0.075851064948902 -0.41958659837593 0 0.050519626587629 0 -0.013995666056871 0.11584085226059 0 0 0 0 0.012078051455319 0 0 0 -0.0077023864723742 0 0 0 0.0036129031796008 0.11790645401925 -0.02732365578413 -0.18784674629569 -0.0058107521617785 0.11255268845707 + 1 0.54594593473002 -0.058320020390831 -0.4121114241513 0 0.14021460711956 0 -0.011749600991607 0.058148983865976 0 0 0 0 -0.0076598017476499 0 0 0 -0.0040079848840833 0 0.0030658126343042 0 -0.016887097619474 -0.08299354929477 -0.00062365643680096 0.10565324500203 0.0095892482204363 -0.24984732177109 + 1 0.55675674554083 -0.040438354941598 -0.40367914965621 0 0.092748634517193 0 -0.0071360059082508 0.014122685417533 0 0 0 0 -0.012477427721024 0 0 0 -0.0017329071415588 0 0.12636105716228 0 -0.0057870969176292 -0.050393548794091 -0.0076236561872065 0.075053248554468 0.0042892479104921 -0.18254731502384 + 1 0.56756755635164 -0.022206068601203 -0.39427082241004 0 0.031126981601119 0 -0.0034730304032564 -0.0054265889339149 0 0 0.030862841755152 0 -0.010122697800398 0 0 0 0 0 0.16548693180084 0 -0.0066870963200927 -0.099193547852337 0.0012763440608978 0.084453243762255 -0.010610751924105 -0.032047308050096 + 1 0.57837836716245 -0.0036231613696475 -0.3838674899322 0 -0.00027817318914458 0 0 -0.010852329432964 0 0 0.16621923446655 0 -0.0060191727243364 0 0 0 0 0 0.083069980144501 0 0.018612903542817 -0.030793548561633 0.0016763433814049 -0.032246753573418 -0.0034107520477846 0.16925269458443 + 1 0.58918917797326 0.01531036675307 -0.37245019974209 0 -0.011387062259018 0.00035563000710681 0 -0.0092751104384661 0 0 0.13810387253761 0 -0.0028834280092269 0 0 0 0 0 0.020175265148282 0 -0.0045870970934629 -0.039693546481431 0.0030763437971473 0.017853248864412 0.016789247165434 0.058652688749135 + 1 0.59999998878407 0.034594515766949 -0.35999999935909 0 -0.011802065186203 0.10081872344017 0 -0.0056944275274873 0 0 0.054610330611467 0 0 0 0 0 0 0 -0.0077522699721158 0 0.0062129032448865 -0.0081935478374362 0.0058763436973095 -0.051746753160842 0.0091892479686067 0.24165268335491 + 1 0.61081079959488 0.054229285671989 -0.34649793630261 0 -0.008052596822381 0.17276559770107 0 -0.0027938217390329 0 0 0.0064733815379441 0 0 0.0016005024081096 0 0 0 0 -0.015503327362239 0 -0.0093870973214507 -0.08979354519397 0.0080763436853886 0.088053245097399 -0.018010751460679 -0.10724730696529 + 1 0.62162161040569 0.07421467646819 -0.33192505809204 0 -0.0042649595998228 0.097324542701244 0 0 0 0 -0.012389867566526 0 0 0.096228934824467 0 0 0 0 -0.013250158168375 0 0.0053129033185542 -0.0081935478374362 0.014976343140006 -0.0060467533767223 -0.015910751302727 0.14865268860012 + 1 0.6324324212165 0.094550688155554 -0.31626241224678 0.028872592374682 -0.0018696727929637 0.027823185548186 0 0 0 0 -0.015387481078506 0 0 0.13414172828197 0 0 0 0 -0.0081348968669772 0 0.0047129031736404 -0.052293551154435 0.021276343613863 0.0077532455325127 0.011589247616939 0.18645268771797 + 1 0.64324323202732 0.11523732073408 -0.29949104628622 0.1349770128727 0 -0.0048416242934763 0 0 0 0 -0.01138152834028 0 0 0.069246374070644 0 0 0 0 -0.0039911740459502 0 0.0067129032686353 -0.016593548469245 0.027076344937086 0.018253248184919 0.024089247803204 0.1892526904121 + 1 0.65405404283813 0.13627457420376 -0.28159200772977 0.10760726034641 0 -0.015136853791773 0 0 0 0 -0.0063730031251907 0 0 0.017592553049326 0 0.053776569664478 0 0 0 0 0.0062129032448865 -0.032093548215926 0.020576342940331 -0.028046753257513 0.0091892479686067 0.028452690690756 + 1 0.66486485364894 0.15766244856461 -0.26254634409682 0.041445430368185 0 -0.01398154720664 0.0027592312544584 0 0 0 -0.0029166976455599 0 0 -0.0056622386910021 0 0.17381598055363 0 0 0 0 -0.001187096349895 -0.050693546421826 0.021176343783736 0.041453246027231 0.020289248670451 -0.12694731261581 + 1 0.67567566445975 0.17940094381662 -0.24233510290676 0.0041748615913093 0 -0.0089788129553199 0.11372494697571 0 0 0 0 0 0 -0.012351076118648 0 0.12343798577785 0 0 0 0 0.017612903378904 0.042106452398002 0.018076343461871 -0.12294675037265 0.017289248178713 0.13255269173533 + 1 0.68648647527056 0.20149005995979 -0.22093933167899 -0.010208387859166 0 -0.0045533217489719 0.14893823862076 0 0 0 0 0 0 -0.010752606205642 0 0.043845307081938 0 0 0 0 0.041512903757393 0.049206453375518 0.027976345270872 -0.12854675576091 0.038189248065464 0.040852691046894 + 1 0.69729728608137 0.22392979699412 -0.19834007793292 -0.012246385216713 0 -0.0019292180659249 0.074762977659702 0 0 0 0 0 0.020822903141379 -0.0066744363866746 0 0.0017421913798898 0 0 0 0 0.027312903665006 -0.001593547873199 0.015076342970133 -0.037746753543615 0.0091892479686067 -0.22444730903953 + 1 0.70810809689218 0.24672015491961 -0.17451838918792 -0.0089307744055986 0 0 0.018157737329602 0 0 0 0 0 0.13064929842949 -0.0033013850916177 0 -0.013717637397349 0 0 0 0 0.039112904109061 0.054306454025209 0.013676343485713 -0.081246752291918 0.0090892481384799 -0.077847308479249 + 1 0.71891890770299 0.26986113373627 -0.14945531296342 -0.0049531273543835 0.054176468402147 0 -0.0069770426489413 0 0 0 0 0 0.11330310255289 -0.0013714701635763 0 -0.015004185028374 0 0 0 0 0.048112903721631 0.041506451554596 0.025376342236996 -0.12344675138593 0.0063892480684444 0.25445269141346 + 1 0.7297297185138 0.29335273344409 -0.12313189677879 -0.0022502727806568 0.15725728869438 0 -0.013952994719148 0 0 0 0 0 0.045990746468306 0 0 -0.010505232028663 0 0 0 0 0.07791290152818 -0.0022935476154089 0.018676344305277 -0.024246752262115 0.04248924634885 0.085852690972388 + 1 0.74054052932461 0.31719495404306 -0.095529188153436 0 0.10772325843573 0 -0.011925142258406 0 0 0 0 0 0.0062225582078099 0 0 -0.005665572360158 0.072235301136971 0 0 0 0.067712903954089 -0.037293546833098 0.020676344633102 0.018553245812654 0.011789248208515 -0.20184731390327 + 1 0.75135134013542 0.3413877955332 -0.066628234606755 0 0.037206649780273 0 -0.0073214070871472 0 0 0 0 0 -0.0095938388258219 0 0 -0.0025188846047968 0.209676399827 0 0 0 0.099112902767956 0.036506452597678 0.025876343250275 -0.070646753534675 0.028789247269742 -0.1198473116383 + 1 0.76216215094623 0.3659312579145 -0.036410083658144 0 0.00060790922725573 0 0.028887817636132 0 0 0 0 0 -0.012364141643047 0 0 0 0.1436310261488 0 0 0 0.088712905533612 0.01690645236522 0.023276343941689 -0.088646754622459 0.010689248214476 0.071252689696848 + 1 0.77297296175705 0.39082534118696 -0.0048557828269987 0 -0.012588676065207 0 0.15184837579727 0 0 0 0 0 -0.0092787202447653 0 2.1845621631655e-06 0 0.049608871340752 0 0 0 0.085712906904519 -0.034393546171486 0.020676344633102 -0.018446754664183 0.009689248050563 -0.024347308091819 + 1 0.78378377256786 0.41607004535059 0.028053620367284 0 -0.013394667766988 0 0.1210593432188 0 0 0 0 0 -0.0052461246959865 0 0.07354100048542 0 0.00081054569454864 0 0 0 0.13121290225536 0.022306452505291 0.01967634446919 -0.16344675049186 0.0023892478784546 0.16675269696862 + 1 0.79459458337867 0.44166537040537 0.062337078405308 0 -0.0092568807303905 0 0.046627011150122 0 0 0 0 0 -0.002418847521767 0 0.17544116079807 0 -0.016784902662039 0 0 0 0.15361290145665 0.026106451638043 0.037276342511177 -0.11474675312638 0.014089248026721 0.012452690396458 + 1 0.80540539418948 0.46761131635132 0.098013543767675 0.02917392924428 -0.004947098903358 0 0.0046971309930086 0 0 0 0 0 0 0 0.11217899620533 0 -0.017859559506178 0 0 0 -0.02118709590286 -0.047993549145758 0.013076344504952 0.07745324447751 0.0021892479853705 -0.17064730729908 + 1 0.81621620500029 0.49390788318842 0.13510196893499 0.11957256495953 -0.0021839591208845 0 -0.011484319344163 0 0 0 0 0 0 0 0.036549493670464 0 -0.012342507950962 0 0 0 -0.0039870971813798 0.018306451849639 0.019076343625784 -0.05524675315246 0.010389247792773 -0.03394731041044 + 1 0.8270270158111 0.52055507091669 0.17362130638786 0.091601468622684 0 0 -0.013777210377157 0 0 0 0 0 0 0 -0.0013280296698213 0 -0.0065961321815848 0 0 0 0.0037129032425582 0.036206453107297 0.028176344931126 -0.061146752908826 0.025189247797243 0.092052691616118 + 1 0.83783782662191 0.54755287953612 0.21359050860688 0.034355282783508 0 0 -0.010047196410596 0 0 0 0 0 0 0 -0.01445743534714 0 -0.0029119455721229 0.020822903141379 0 0 -0.0069870967417955 -0.029893548227847 0.016676343977451 0.052853245288134 0.021489248494618 -0.052347308956087 + 1 0.84864863743272 0.57490130904672 0.25502852807265 0.002809077501297 0 2.1826426745974e-06 -0.0055723269470036 0 0 0 0 0 0 0 -0.014613589271903 0 0 0.13064929842949 0 0 -0.016887097619474 -0.011393547989428 0.014476343989372 0.037353243678808 0.001989247975871 -0.094247310422361 + 1 0.85945944824353 0.60260035944847 0.29795431726579 -0.009173322468996 0 0.073538526892662 -0.002531590173021 0 0 0 0 0 0 0 -0.0098465224727988 0 0 0.11330310255289 0 0 -0.0071870964020491 0.041306451894343 0.024676345288754 -0.050646753166802 -0.012310751830228 0.016052690334618 + 1 0.87027025905434 0.63065003074138 0.34238682866689 -0.010652085766196 0 0.17544116079807 0 0 0 0 0 0 0 0.0040210401639342 -0.0051689259707928 0 0 0.045990746468306 0 0 -0.0098870964720845 0.0033064521849155 0.026976343244314 0.055753249675035 -0.014910753001459 -0.020947310142219 + 1 0.88108106986515 0.65905032292546 0.38834501475656 -0.0076612252742052 0 0.11218037456274 0 0 0 0 0 0 0 0.11895248293877 -0.0022502795327455 0 0 0.0062225582078099 0 0 0.0030129032675177 0.061606450937688 0.023776344954967 -0.057646753266454 -0.0056107520358637 0.17195269558579 + 1 0.89189188067596 0.6878012360007 0.4358478280154 0.015245664864779 0 0.036550357937813 0 0 0 0 0 0 0 0.14677180349827 0 0 0 -0.0095938388258219 0 0 0.014212903100997 0.0087064522085711 0.037576343864202 -0.044646752998233 -0.0071107522817329 0.09555269125849 + 1 0.90270269148678 0.71690276996709 0.48491422092401 0.14210297167301 0 -0.0013276820536703 0 0 0 0 0 0 0 0.071675792336464 0 0 0 -0.012364141643047 0 0 0.029112902469933 -0.037493546493351 0.033676344901323 -0.028546752408147 -0.00081075204070657 0.06235269177705 + 1 0.91351350229759 0.74635492482465 0.535563145963 0.13056182861328 0 -0.014457356184721 0 0 0 0 0 0 0 0.016579894348979 0 0.00069556123344228 0 -0.0092787202447653 0 0 0.017512903548777 -0.012193548493087 0.027576342225075 -0.073646754026413 -0.0079107518540695 0.090652690269053 + 1 0.9243243131084 0.77615770057338 0.58781355561298 0.054395545274019 0 -0.014613640494645 0 0 0 0 0 0 0 -0.0075534516945481 0 0.10747737437487 0 -0.0052461246959865 0 0 -0.028887095861137 -0.040393547154963 0.02277634292841 0.032053243368864 -0.030210751225241 -0.11324730422348 + 1 0.93513512391921 0.80631109721326 0.64168440235453 0.0082204462960362 0 -0.0098466016352177 0 0 0 0 0 0 0 -0.013995666056871 0 0.17133408784866 0 -0.002418847521767 0 0 0.0011129034683108 -0.024293546564877 0.026476342231035 -0.008346751332283 0.0063892480684444 -0.13364730682224 + 1 0.94594593473002 0.8368151147443 0.69719463866827 -0.01041049323976 0 -0.0051689869724214 0.042828563600779 0 0 0 0 0 0 -0.011749600991607 0 0.093689449131489 0 0 0 0 -0.030687096528709 0.0040064523927867 0.022076342254877 -0.0096467547118664 -0.012210752000101 -0.096747308038175 + 1 0.95675674554083 0.86766975316651 0.75436321703481 -0.013959442265332 0 -0.0022503104992211 0.15526303648949 0 0 0 0 0 0 -0.0071360059082508 0 0.025812968611717 0 0 0 0 -0.034287097863853 -0.044993546791375 0.019276343286037 0.092153239995241 -0.0098107523517683 -0.099347307346761 + 1 0.96756755635164 0.89887501247988 0.81320908993473 -0.01063232216984 0 0 0.11444798856974 0 0 0 0 0 0 -0.0034730304032564 0.037509337067604 -0.0056235245428979 0 0 0 0 -0.016187096945941 0.00020645186305046 0.022976342588663 0.016353245824575 -0.015210752491839 0.12425269279629 + 1 0.97837836716245 0.93043089268441 0.87375120984866 -0.006070701405406 0 0 0.041782386600971 0 0 0 0 0 0 0 0.15373615920544 -0.015256246551871 0 0 0 0 -0.013587097637355 -0.029593546874821 0.029876343905926 0.02615324780345 0.0034892478724942 0.088752687908709 + 1 0.98918917797326 0.9623373937801 0.93600852925718 -0.0028200859669596 0 0 0.0025689851026982 0 0.028872592374682 0 0 0 0 0 0.11777331680059 -0.013806855306029 0 0 0 0 -0.0050870971754193 -0.018593546934426 0.036676343530416 -0.0050467513501644 0.0057892481563613 0.12315268907696 + 1 0.99999998878407 0.99459451576695 1.0000000006409 0 0 0 -0.01208124961704 0 0.1349770128727 0 0 0 0 0 0.044171079993248 -0.0087651275098324 0 0 0 0 0.0079129033256322 -0.18649354297668 0.025376342236996 0.10375324264169 0.0030892478534952 -0.1448473026976 +# + diff --git a/docs/examples/download_data.sh b/docs/examples/download_data.sh new file mode 100644 index 00000000..b7f6496a --- /dev/null +++ b/docs/examples/download_data.sh @@ -0,0 +1,2 @@ +#!/bin/bash +find . -mindepth 1 -type d -name 'download_data.sh' -execdir bash download_data.sh \; diff --git a/docs/examples/eventseg/Event_Segmentation.ipynb b/docs/examples/eventseg/Event_Segmentation.ipynb new file mode 100644 index 00000000..d4b0cbc6 --- /dev/null +++ b/docs/examples/eventseg/Event_Segmentation.ipynb @@ -0,0 +1,686 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Event segmentation and alignment in fMRI data\n", + "\n", + "Author: Christopher Baldassano ([c.baldassano@columbia.edu](mailto:c.baldassano@columbia.edu))\n", + "\n", + "## Overview\n", + "Humans tend to segment continuous perceptual experiences into discrete events. We have devised this notebook to capture the neural representations of this \"chunking\" process using a Hidden Markov Models (HMM). The notebook uses real data from naturalistic movie viewing and recall, suggesting ways to align derived neural event states with subjective annotations of event boundaries and with the recall time series.\n", + "\n", + "## Annotated Bibliography\n", + "1. Baldassano, C., Chen, J., Zadbood, A., Pillow, J. W., Hasson, U., & Norman, K. A. (2017). Discovering event structure in continuous narrative perception and memory. *Neuron*, 95(3), 709–721.e5. [`link`](https://doi.org/10.1016/j.neuron.2017.06.041) *Describes and validates the event segmentation method, and applies it to perception and recall data from multiple experiments.*\n", + "\n", + "2. Baldassano, C., Hasson, U., & Norman, K. A. (2018). Representation of real-world event schemas during narrative perception. *Journal of Neuroscience*, 38(45), 9689–9699. [`link`](https://doi.org/10.1523/JNEUROSCI.0251-18.2018) *Uses the event segmentation model to find common event structure among narratives with a shared schematic script.*\n", + "\n", + "3. Ben-Yakov, A., & Henson, R. N. (2018). The hippocampal film editor: sensitivity and specificity to event boundaries in continuous experience. *Journal of Neuroscience*, 38(47), 10057–10068. [`link`](https://doi.org/10.1523/JNEUROSCI.0524-18.2018) *Further studies the relationship between the event boundaries produced by the event segmentation model, human-annotated boundaries, and hippocampal responses.*\n", + "\n", + "4. Silva, M., Baldassano, C., & Fuentemilla, L. (2019). Rapid memory reactivation at movie event boundaries promotes episodic encoding. *Journal of Neuroscience*, 39(43), 8538–8548. [`link`](https://doi.org/10.1523/JNEUROSCI.0360-19.2019) *Applies the event segmentation model to EEG signals collected while subjects were watching a movie.*\n", + "\n", + "5. Antony, J. W., Hartshorne, T. H., Pomeroy, K., Gureckis, T. M., Hasson, U., McDougle, S. D., & Norman, K. A. (2020). Behavioral, physiological, and neural signatures of surprise during naturalistic sports viewing. *Neuron*. [`link`](https://doi.org/10.1016/j.neuron.2020.10.029) *Uses the event segmentation model to relate the number and timing of event boundaries in neural signals to the degree of surprise elicited in basketball games.*\n", + "\n", + "## Table of Contents\n", + "* [Loading data](#data)\n", + "* [Finding event boundaries during perception](#perception)\n", + "* [Comparing model and human-labeled boundaries](#comparing)\n", + "* [Aligning movie and recall data](#aligning)\n", + "* [Summary](#summary)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-04T01:07:31.270889Z", + "start_time": "2020-07-04T01:07:31.176652Z" + } + }, + "outputs": [], + "source": [ + "import warnings\n", + "import sys \n", + "import os \n", + "import glob\n", + "from functools import reduce\n", + "import numpy as np\n", + "from brainiak.eventseg.event import EventSegment\n", + "from scipy.stats import norm\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.patches as patches\n", + "%matplotlib inline\n", + "\n", + "smallsize=14; mediumsize=16; largesize=18\n", + "plt.rc('xtick', labelsize=smallsize); plt.rc('ytick', labelsize=smallsize); plt.rc('legend', fontsize=mediumsize)\n", + "plt.rc('figure', titlesize=largesize); plt.rc('axes', labelsize=mediumsize); plt.rc('axes', titlesize=mediumsize)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading data\n", + "This tutorial will use data from the first run of the Sherlock dataset [(Chen et al. 2017)](https://doi.org/10.1038/nn.4450), masked to only include the Angular Gyrus." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2020-11-10 13:56:28-- https://ndownloader.figshare.com/files/22927253\n", + "Resolving ndownloader.figshare.com (ndownloader.figshare.com)... 54.246.227.97, 52.17.195.112, 52.212.255.91, ...\n", + "Connecting to ndownloader.figshare.com (ndownloader.figshare.com)|54.246.227.97|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/22927253/Sherlock_AG_movie.npy [following]\n", + "--2020-11-10 13:56:29-- https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/22927253/Sherlock_AG_movie.npy\n", + "Resolving s3-eu-west-1.amazonaws.com (s3-eu-west-1.amazonaws.com)... 52.218.112.91\n", + "Connecting to s3-eu-west-1.amazonaws.com (s3-eu-west-1.amazonaws.com)|52.218.112.91|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 256101248 (244M) [application/octet-stream]\n", + "Saving to: ‘Sherlock_AG_movie.npy’\n", + "\n", + "Sherlock_AG_movie.n 100%[===================>] 244.24M 9.00MB/s in 36s \n", + "\n", + "2020-11-10 13:57:05 (6.83 MB/s) - ‘Sherlock_AG_movie.npy’ saved [256101248/256101248]\n", + "\n", + "--2020-11-10 13:57:05-- https://ndownloader.figshare.com/files/22927256\n", + "Resolving ndownloader.figshare.com (ndownloader.figshare.com)... 34.250.14.20, 52.17.195.112, 52.212.255.91, ...\n", + "Connecting to ndownloader.figshare.com (ndownloader.figshare.com)|34.250.14.20|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/22927256/Sherlock_AG_recall.npy [following]\n", + "--2020-11-10 13:57:06-- https://s3-eu-west-1.amazonaws.com/pfigshare-u-files/22927256/Sherlock_AG_recall.npy\n", + "Resolving s3-eu-west-1.amazonaws.com (s3-eu-west-1.amazonaws.com)... 52.218.24.75\n", + "Connecting to s3-eu-west-1.amazonaws.com (s3-eu-west-1.amazonaws.com)|52.218.24.75|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 8240168 (7.9M) [application/octet-stream]\n", + "Saving to: ‘Sherlock_AG_recall.npy’\n", + "\n", + "Sherlock_AG_recall. 100%[===================>] 7.86M 6.44MB/s in 1.2s \n", + "\n", + "2020-11-10 13:57:07 (6.44 MB/s) - ‘Sherlock_AG_recall.npy’ saved [8240168/8240168]\n", + "\n" + ] + } + ], + "source": [ + "if not os.path.exists('Sherlock_AG_movie.npy'):\n", + " !wget https://ndownloader.figshare.com/files/22927253 -O Sherlock_AG_movie.npy\n", + "if not os.path.exists('Sherlock_AG_recall.npy'):\n", + " !wget https://ndownloader.figshare.com/files/22927256 -O Sherlock_AG_recall.npy\n", + "\n", + "movie = np.load('Sherlock_AG_movie.npy')\n", + "recall = np.load('Sherlock_AG_recall.npy')\n", + "movie_group = np.mean(movie, axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finding event boundaries during perception" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Warm-up: Event structure in activity patterns\n", + "\n", + "Before applying any model, a good first step is to plot the correlation between activity patterns for each pair of timepoints during the movie. In this dataset, this shows blocks along the diagonal, which indicates that activity patterns are remaining stable for periods of tens of timepoints. This is the kind of structure that the HMM will be looking for." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,8))\n", + "plt.imshow(np.corrcoef(movie_group))\n", + "plt.xlabel('Timepoint')\n", + "plt.ylabel('Timepoint')\n", + "plt.colorbar()\n", + "plt.title('Spatial pattern correlation');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fitting the HMM\n", + "\n", + "To use an HMM to find both the event timings and the patterns corresponding to each event, we can use the EventSegment class from the brainiak toolbox. We need to specify the number of events, which here we set to 29 (corresponding to the number of boundaries typically annotated by human subjects)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "movie_HMM = EventSegment(n_events = 29)\n", + "movie_HMM.fit(movie_group);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This fit produces:\n", + "* The log-likelihood (measuring overall model fit) over training. (Note that the log-likelihood on held-out test data is often a better measure of model quality - see below).\n", + "* The mean voxel pattern for each event. Here we show only 1% of the voxels since the ROI is large.\n", + "* A matrix showing the probability of being in each event at each timepoint. We can use this to derive the most likely timepoints where boundaries occur, and plot these on top of the timepoint similarity matrix for comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Model fitting steps')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the log-likelihood (measuring overall model fit)\n", + "plt.figure(figsize = (12, 4))\n", + "plt.plot(movie_HMM.ll_)\n", + "plt.title('Log likelihood during training')\n", + "plt.xlabel('Model fitting steps')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Voxels')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting mean activity in each event for some example voxels\n", + "plt.figure(figsize = (12, 4))\n", + "example_vox = np.arange(0,movie_HMM.event_pat_.shape[0],100)\n", + "plt.imshow(movie_HMM.event_pat_[example_vox,:], aspect='auto')\n", + "plt.xlabel('Event number')\n", + "plt.ylabel('Voxels')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.05, 'Event probability')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot probability of being in each event at each timepoint\n", + "plt.figure(figsize = (12, 6))\n", + "plt.matshow(movie_HMM.segments_[0].T, aspect='auto')\n", + "plt.gca().xaxis.tick_bottom()\n", + "plt.colorbar()\n", + "plt.title('Event probability')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Identify event boundaries as timepoints when max probability switches events\n", + "event_bounds = np.where(np.diff(np.argmax(movie_HMM.segments_[0], axis = 1)))[0]\n", + "nTRs = movie_group.shape[0]\n", + "\n", + "\n", + "# Plot boundaries as boxes on top of timepoint correlation matrix\n", + "def plot_tt_similarity_matrix(ax, data_matrix, bounds, n_TRs, title_text):\n", + " \n", + " ax.imshow(np.corrcoef(data_matrix), cmap = 'viridis')\n", + " ax.set_title(title_text)\n", + " ax.set_xlabel('TR')\n", + " ax.set_ylabel('TR')\n", + " \n", + " # plot the boundaries \n", + " bounds_aug = np.concatenate(([0], bounds, [n_TRs]))\n", + " \n", + " for i in range(len(bounds_aug) - 1):\n", + " rect = patches.Rectangle(\n", + " (bounds_aug[i], bounds_aug[i]),\n", + " bounds_aug[i+1] - bounds_aug[i],\n", + " bounds_aug[i+1] - bounds_aug[i],\n", + " linewidth = 2, edgecolor = 'w',facecolor = 'none'\n", + " )\n", + " ax.add_patch(rect)\n", + "\n", + "\n", + "f, ax = plt.subplots(1,1, figsize = (10,8))\n", + "title_text = '''\n", + "Overlay the HMM-predicted event boundaries\n", + "on top of the TR-TR correlation matrix\n", + "'''\n", + "plot_tt_similarity_matrix(ax, movie_group, event_bounds, nTRs, title_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Determining the number of events with the HMM\n", + "\n", + "What if we don't want to prespecify the number of events, but instead want to determine the number of events from the data? One way to determine the best number of events is to fit the model on a training set and then test the model fit on independent subjects." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trying 20 events\n", + " Fitting model on training subjects...\n", + " Testing model fit on held-out subjects...\n", + "Trying 30 events\n", + " Fitting model on training subjects...\n", + " Testing model fit on held-out subjects...\n", + "Trying 40 events\n", + " Fitting model on training subjects...\n", + " Testing model fit on held-out subjects...\n", + "Trying 50 events\n", + " Fitting model on training subjects...\n", + " Testing model fit on held-out subjects...\n", + "Trying 60 events\n", + " Fitting model on training subjects...\n", + " Testing model fit on held-out subjects...\n" + ] + } + ], + "source": [ + "k_array = np.arange(20, 61, 10)\n", + "test_ll = np.zeros(len(k_array))\n", + "\n", + "for i, k in enumerate(k_array):\n", + " print('Trying %d events' % k)\n", + " \n", + " print(' Fitting model on training subjects...')\n", + " movie_train = np.mean(movie[:8], axis = 0)\n", + " movie_HMM = EventSegment(k)\n", + " movie_HMM.fit(movie_train)\n", + " \n", + " print(' Testing model fit on held-out subjects...')\n", + " movie_test = np.mean(movie[8:], axis = 0)\n", + " _, test_ll[i] = movie_HMM.find_events(movie_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Average event length (sec)')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(k_array, test_ll)\n", + "plt.xlabel('Number of events')\n", + "plt.ylabel('Log-likelihood')\n", + "\n", + "movie_dur = nTRs * 1.5 # Data acquired every 1.5 seconds\n", + "secax = plt.gca().secondary_xaxis('top',\n", + " functions=(lambda x: movie_dur / (x + sys.float_info.epsilon),\n", + " lambda x: movie_dur / (x + sys.float_info.epsilon)))\n", + "secax.set_xlabel('Average event length (sec)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optimal segmentation with the HMM\n", + "Since 40 events maximized the test log-likelihood, we'll generate two versions of HMM boundaries using 40 events. In addition to the \"vanilla\" HMM, we'll run an HMM with more flexibility during fitting (allowing for split-merge operations). This is slower (and so should usually only be used for generating a final segmentation), but can produce better fits if events are very uneven in duration. We will use these segmentations below for comparison with human labeled event boundaries." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting HMM with 40 events...\n", + "Fitting split-merge HMM with 40 events...\n" + ] + } + ], + "source": [ + "print('Fitting HMM with 40 events...')\n", + "HMM40 = EventSegment(n_events = 40)\n", + "HMM40.fit(movie_group)\n", + "HMM40_bounds = np.where(np.diff(np.argmax(HMM40.segments_[0], axis = 1)))[0]\n", + "\n", + "print('Fitting split-merge HMM with 40 events...')\n", + "HMM40_SM = EventSegment(n_events = 40, split_merge = True)\n", + "HMM40_SM.fit(movie_group)\n", + "HMM40_SM_bounds = np.where(np.diff(np.argmax(HMM40_SM.segments_[0], axis = 1)))[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparing model and human-labeled boundaries\n", + "\n", + "We can also quantitatively compare the event boundaries between different models, or between a model and human-labeled event boundaries. Because there is some ambiguity in both the stimulus and the model about exactly which timepoint the transition occurs at, we will count two boundaries as being a \"match\" if they are within 3 TRs (4.5 seconds) of each other.\n", + "\n", + "To determine whether the match is statistically significant, we generate permuted versions of the boundaries as a null model for comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Timepoints of event boundaries annotated by human raters\n", + "human_bounds = [\n", + " 26, 35, 56, 72, 86, 108, 131, 143, 157, 173, 192, 204, \n", + " 226, 313, 362, 398, 505, 526, 533, 568, 616, 634, 678,\n", + " 696, 747, 780, 870, 890\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HMM40: z = 2.989227, p = 0.001398\n", + "HMM_SM40: z = 3.454808, p = 0.000275\n" + ] + } + ], + "source": [ + "# Computes fraction of ground truth bounds that are covered by a set of proposed bounds\n", + "# Returns z score relative to a null distribution via permutation\n", + "def match_z(proposed_bounds, gt_bounds, num_TRs):\n", + " nPerm = 1000\n", + " threshold = 3\n", + " np.random.seed(0)\n", + "\n", + " gt_lengths = np.diff(np.concatenate(([0],gt_bounds,[num_TRs])))\n", + " match = np.zeros(nPerm + 1)\n", + " for p in range(nPerm + 1):\n", + " gt_bounds = np.cumsum(gt_lengths)[:-1]\n", + " for b in gt_bounds:\n", + " if np.any(np.abs(proposed_bounds - b) <= threshold):\n", + " match[p] += 1\n", + " match[p] /= len(gt_bounds)\n", + " gt_lengths = np.random.permutation(gt_lengths)\n", + " \n", + " return (match[0]-np.mean(match[1:]))/np.std(match[1:])\n", + "\n", + "z = [match_z(HMM40_bounds, human_bounds, nTRs),\n", + " match_z(HMM40_SM_bounds, human_bounds, nTRs)]\n", + "\n", + "print('HMM40: z = %f, p = %f' % (z[0], norm.sf(z[0])))\n", + "print('HMM_SM40: z = %f, p = %f' % (z[1], norm.sf(z[1])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aligning movie and recall data\n", + "\n", + "A simple model of free recall is that a subject will revisit the same sequence of events experienced during perception, but the lengths of the events will not be identical between perception and recall. We use the same fit function as for a single dataset, but now we pass in both the movie and recall datasets in a list. We assume the two datasets have shared event transitions." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "movie_recall_HMM = EventSegment(40)\n", + "movie_recall_HMM.fit([movie_group, recall]);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(movie_recall_HMM.segments_[0] @ movie_recall_HMM.segments_[1].T)\n", + "plt.xlabel('Timepoints during recall')\n", + "plt.ylabel('Timepoints during movie')\n", + "plt.colorbar()\n", + "plt.title('Prob of being in the same event');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "Using the HMM, we first captured neural states corresponding with the naturalistic segmentation of events. Then, to verify that these states aligned with subjective event perception, we aligned their boundaries with event boundary annotations from an independent group of subjects. Finally, we showed that processes such as free recall, which feature similar transition structures but may be compressed or expanded in time, can be aligned to this perceptual HMM \"template\", broadening the scope of future research questions that can be addressed with this technique." + ] + }, + { + "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.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/eventseg/download_data.sh b/docs/examples/eventseg/download_data.sh new file mode 100644 index 00000000..2c7bd530 --- /dev/null +++ b/docs/examples/eventseg/download_data.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +wget -nc https://ndownloader.figshare.com/files/22927253 -O Sherlock_AG_movie.npy +wget -nc https://ndownloader.figshare.com/files/22927256 -O Sherlock_AG_recall.npy diff --git a/docs/examples/fcma/FCMA_demo.ipynb b/docs/examples/fcma/FCMA_demo.ipynb new file mode 100644 index 00000000..d929bff6 --- /dev/null +++ b/docs/examples/fcma/FCMA_demo.ipynb @@ -0,0 +1,1023 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Full Correlation Matrix Analysis (FCMA) demo \n", + "By Peeta Li ([peetal@uoregon.edu](mailto:peetal@uoregon.edu)), Yida Wang ([yidawa@gmail.com](mailto:yidawa@gmail.com)) and Ben Hutchinson ([bhutch@uoregon.edu](mailto:bhutch@uoregon.edu))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "- Given an experimental deisgn that consists of two conditions (A and B), we can ask whether the functional connectivity (FC) between brain regions differs across conditions. Traditional FC analyses employ a seed based approach, which can be biased in terms of the regions or networks it discovers (seeds are arbitrarily chosen) and miss potentially important regions which are meaningfully involved, but not systematically connected with the seed region (e.g., [Wang et al., 2015](http://ntblab.yale.edu/wp-content/uploads/2015/06/Wang_JNM_2015.pdf)). In order to perform whole-brain FC analyses in a manner which considers all pairwise correlations in the brain, FCMA was developed.\n", + "\n", + "\n", + "- Using FCMA, we can answer the following questions: \n", + " 1. Do functional connectivity patterns differ between condition A and B? \n", + " 2. If so, which brain regions are driving the difference?\n", + "\n", + "\n", + "- This jupyter notebook uses simulated data to demonstrate how the above two questions could be answered with FCMA. Look here to see [the important details of simulated data](#dat)\n", + "\n", + "\n", + "- Brainiak also includes a tutorial for FCMA, which could be found [here](https://brainiak.org/notebooks/tutorials/html/09-fcma.html).\n", + "\n", + "- Annotated Bibliography:\n", + " 1. Shirer, W. R., Ryali, S., Rykhlevskaia, E., Menon, V., & Greicius, M. D. (2012). Decoding subject-driven cognitive states with whole-brain connectivity patterns. *Cerebral Cortex*, 22(1), 158–165. [`link`](https://doi.org/10.1093/cercor/bhr099) *Describes successful decoding of cognitive tasks using the pattern of correlation between 90 functional regions of interest across the brain.*\n", + " 2. Turk-Browne, N. B. (2013). Functional interactions as big data in the human brain. *Science*, 342(6158), 580–584. [`link`](https://doi.org/10.1126/science.1238409) *Describes how complex biological systems, including neural processes, can be understood through the interactions of their component variables, such as the full correlation matrix in fMRI data.*\n", + " 3. Wang, Y., Anderson, M. J., Cohen, J. D., Heinecke, A., Li, K., Satish, N., Sundaram, N., Turk-Browne, N. B., & Willke, T. L. (2015). Full correlation matrix analysis of fMRI data on Intel® Xeon Phi™ coprocessors. SC ’15: *Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis*, 1–12. [`link`](https://doi.org/10.1145/2807591.2807631) *Describes optimizations made for Intel Xeon Phi Coprocessors to greatly enhance FCMA performance in cluster-based computing environments.*\n", + " 4. Wang, Y., Cohen, J. D., Li, K., & Turk-Browne, N. B. (2015). Full correlation matrix analysis (FCMA): An unbiased method for task-related functional connectivity. *Journal of Neuroscience Methods*, 251, 108–119. [`link`](https://doi.org/10.1016/j.jneumeth.2015.05.012) *Describes how FCMA can be used to discover regions that are involved in cognitive tasks by way of their functional connectivity.*\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "\n", + "[1. FCMA Step1: Feature (voxel) selection](#fcma_voxselect)\n", + ">[1.1 The goal](#goal) \n", + ">[1.2 Data preprocessing](#preprocess) \n", + ">[1.3 Understanding preprocessed data](#understand_preprocess) \n", + ">[1.4 Feature selection with simplified implementation](#simplified_fs) \n", + ">[1.5 Understading the outputs of feature selection](#understand_simplified_fs) \n", + ">[1.6 Perform feature selection with actual FCMA implementation](#actual_fs) \n", + ">[1.7 Select n top performed features](#select_top_n) \n", + "\n", + "[2. FCMA Step 2: Classification using the selected features (voxels)](#classification)\n", + ">[2.1 The goal](#goal2) \n", + ">[2.2 Classification steps](#clf_steps) \n", + ">[2.3 Understanding the outputs of classification](#understand_clf) \n", + ">[2.4 Perform classification for all outer loop folds using FCMA script](#actual_clf) \n", + "\n", + "[3. Results visualizations](#visualization)\n", + ">[3.1 Examine classification accuracy for different top-n-mask](#line) \n", + ">[3.2 Visualize voxels in top-n-masks](#niview) \n", + ">[3.3 Visualize functional connectivity pattern with circos plot](#circos) \n", + "\n", + "[4. Summary](#sum)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Important details of simulated data \n", + "\n", + "- The simulated data consists of 8 subjects. The experiment consists of a **block design** and two conditions (A and B). **Each condition has 10 blocks (or epochs) for a total of 20 epochs** for each subject. The order of the epochs were randomized across the 8 subjects. Each **epoch lasts for 15 time points** followed by **5 time points of inter-block interval**. The total experiment lasts 400 time points in total. Here, time points are arbitrary and are meant to correspond to single TRs in an actual study. \n", + "\n", + "\n", + "- To reduce computational demands, we cherry picked 432 voxels from vmPFC and Precueneus as the brain mask (a 6 x 6 x 6 cube for each region). The choice for the two brain regions is arbitrary and the purpose of constraining the voxels in two brain regions is for visulization. Thus the simulated data uses only **432 brain voxels**, and each voxel has 400 time points. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from brainiak.fcma.preprocessing import prepare_fcma_data,RandomType\n", + "from brainiak.fcma.classifier import Classifier\n", + "from brainiak.fcma.util import compute_correlation\n", + "from brainiak import io\n", + "from sklearn.svm import SVC\n", + "from sklearn.model_selection import KFold\n", + "from mpi4py import MPI\n", + "from nxviz.plots import CircosPlot\n", + "from itertools import product\n", + "from nilearn import image, plotting, datasets\n", + "import sys\n", + "import logging\n", + "import numpy as np\n", + "import pandas as pd\n", + "import nibabel as nib\n", + "import os, glob, subprocess\n", + "import seaborn as sns\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. FCMA Step1: Feature (voxel) selection \n", + "### 1.1 The goal \n", + "- Given the default specification of \"left_out_subj\", we can devide the 8-subjects data into a training set (7 subjects) and a testing set (1 subject). This is referred to as the \"outer loop leave-one-out cross validation\". The goal here is to perform feature selection on the traning set and use the selected features (7 subjects) to build a model and test using the left out test set (1 subject). This will ultimately be done 8 times to provide a complete assessment of all 8 subjects. \n", + "\n", + "### 1.2 Data preprocessing " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Load in the volumes, mask, and labels\n", + "Parse the epoch data for useful dimensions\n", + "Preprocess the data and prepare for FCMA\n", + "Enforce leave one out\n", + "Take out the idxs corresponding to all participants but this one\n" + ] + } + ], + "source": [ + "# --------------------\n", + "# Set up directories\n", + "# --------------------\n", + "\n", + "cur_dir = os.getcwd()\n", + "data_dir = os.path.join(cur_dir, 'simulated_data') # What is the directory containing data?\n", + "suffix = '.nii.gz' # What is the extension of the data you're loading\n", + "mask_file = os.path.join(cur_dir, 'sim_info', 'full_mask.nii.gz') # What is the path to the whole brain mask\n", + "epoch_file = os.path.join(cur_dir, 'simulated_data', 'sim_epoch_file.npy') # What is the path to the epoch file\n", + "left_out_subj = 0 # Which participant (as an integer) are you leaving out for this cv, for the current demo, set it to 0\n", + "output_dir = os.path.join(cur_dir, 'FCMA_result') # What is the path to the folder you want to save this data in\n", + "\n", + "if not os.path.exists(output_dir):\n", + " os.makedirs(output_dir)\n", + " \n", + "# ----------------------------\n", + "# Load and Preprocess the data\n", + "# ----------------------------\n", + "\n", + "print(\"Load in the volumes, mask, and labels\")\n", + "images = io.load_images_from_dir(data_dir, suffix=suffix)\n", + "mask = io.load_boolean_mask(mask_file)\n", + "epoch_list = io.load_labels(epoch_file)\n", + "\n", + "print(\"Parse the epoch data for useful dimensions\")\n", + "epochs_per_subj = epoch_list[0].shape[1]\n", + "num_subjs = len(epoch_list)\n", + "\n", + "print(\"Preprocess the data and prepare for FCMA\")\n", + "raw_data, _, labels = prepare_fcma_data(images, epoch_list, mask)\n", + "\n", + "# ----------------------------------\n", + "# Outer loop - take out traning set \n", + "# for feature selection\n", + "# ----------------------------------\n", + "\n", + "print(\"Enforce leave one out\")\n", + "start_idx = int(int(left_out_subj) * epochs_per_subj)\n", + "end_idx = int(start_idx + epochs_per_subj)\n", + "\n", + "print(\"Take out the idxs corresponding to all participants but this one\")\n", + "subsampled_idx = list(set(range(len(labels))) - set(range(start_idx, end_idx)))\n", + "labels_subsampled = [labels[i] for i in subsampled_idx]\n", + "raw_data_subsampled = [raw_data[i] for i in subsampled_idx]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.3 Understanding preprocessed data \n", + "- Up to this point, we have our training set ready, which includes all epochs and labels for all subjects except subject-0. Now let's look at our training set in more detail. \n", + "- Remember that each subject has 20 epochs, evenly divided into two conditions. Given that we have 7 subjects' data in our outer-loop traning set, we have in total 7 x 20 = 140 epochs, thus 140 labels. \n", + "- Each epoch is stored as a two-dimensional array of time point by voxel. In the simulated data, each epoch lasts 15 time points and the cherry-picked brain has in total 432 voxels. Thus, each epoch array has the shape of 15 by 432. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Label count: 140\n", + "Epoch (block) count: 140\n", + "Shape of each epoch (block): (15, 432)\n" + ] + } + ], + "source": [ + "print(f\"Label count: {len(labels_subsampled)}\")\n", + "print(f\"Epoch (block) count: {len(raw_data_subsampled)}\")\n", + "print(f\"Shape of each epoch (block): {raw_data_subsampled[0].shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.4 Feature selection with simplified implementation \n", + "- Please note that the following code is a simplified approximation of feature selection in the FCMA toolbox and is not practical for real data due to computation constraints. Actual implementation of FCMA uses the message passing interface (MPI) which requests at least 2 processors for a job (one master coordinating tasks and collecting data, and one worker doing the computation), however, Jupyter notebook typically allows only 1 processor. The implementation used here is designed to conceptually replicate the feature selection step for FCMA and can be used to understand what exactly happens under the hood.\n", + "\n", + "#### Steps:\n", + "\n", + "1. First, we enlarge the feature space by computing the correlation matrix of all voxels in the brain. Because the simulated brain only has 432 voxels, this yields a 432 x 432 correlation matrix. Each row/column is the functional connectivity between a given voxel and all other voxels in the brain. \n", + "\n", + "\n", + "2. For each voxel, we want to know how well its functional connectivity with every other brain voxel differentiates the task conditions. Thus, for each brain voxel, we can \n", + " - A) Extract the corresponding row from each subject's correlation matrix, resulting a single array for each subject. \n", + " - B) Perform an _inner loop_ leave-one-out cross validation. That is, for each fold, one subject will be left out and so 7-1 = 6 arrays (one for each subject) will be used as the training set and the left out array will be used as the validation set. The classification algorithm used here is SVM with linear kernel. Other binary classification algorithms can be applied as well.\n", + " - C) A prediction accuracy value for this selected voxel could be computed for each fold. \n", + " - D) Final prediction accuracy for this voxel could can be averaged across the 7 folds. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# -----------------------------\n", + "# Enlarging the feature space \n", + "# -----------------------------\n", + "raw_data_subsampled_mat = [np.corrcoef(sample.T) for sample in raw_data_subsampled]\n", + "\n", + "\n", + "# ------------------------------------------\n", + "# Inner loop leave one out cross validation\n", + "# ------------------------------------------\n", + "vox_score = []\n", + "# for every voxel in the brain\n", + "for i in range(raw_data_subsampled_mat[0].shape[0]):\n", + " \n", + " # A) extract the corresponding row from each subjects' correlation matrix \n", + " raw_data_sub_selected_vox = [sample[i,] for sample in raw_data_subsampled_mat]\n", + "\n", + " # B) Perform the inner loop leave-one-out cross validation\n", + " kf = KFold(n_splits = num_subjs - 1)\n", + " score = []\n", + " for train_ind, test_ind in kf.split(labels_subsampled):\n", + "\n", + " # For each fold, get training and validation set \n", + " vox_train, vox_test = [raw_data_sub_selected_vox[ind] for ind in train_ind], [raw_data_sub_selected_vox[ind] for ind in test_ind]\n", + " lab_train, lab_test = [labels_subsampled[ind] for ind in train_ind], [labels_subsampled[ind] for ind in test_ind]\n", + "\n", + " # set up the model\n", + " svm_clf = SVC(kernel='linear', shrinking=False, C=1)\n", + "\n", + " # train the model\n", + " svm_clf.fit(vox_train, lab_train)\n", + "\n", + " # test the model\n", + " predict = svm_clf.predict(vox_test)\n", + " \n", + " # C) A prediction accuracy value for this selected voxel could be computed for each fold\n", + " score.append(svm_clf.score(vox_test, lab_test))\n", + " \n", + " # D) Final prediction accuracy for this voxel\n", + " vox_score.append(np.mean(score))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.5 Understanding the outputs of feature selection \n", + "- For each inner loop fold, we end up getting a list of prediction accuracy, one for each voxel in the brain. Thus the length of this list equals the total number of voxels in the brain (i.e., 432). \n", + "- We can then rank these voxels based on their classification accuracy. Thus each voxel, in addition to have a prediction accuracy value, will also have a rank value. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The length of the prediction accuracy list is 432\n", + "The top ranked 10 voxel IDs are [234, 324, 382, 10, 8, 291, 17, 39, 78, 252]\n" + ] + } + ], + "source": [ + "# rank all voxels based on their prediction accuracies, the higher the acc, the lower the rank \n", + "vox_dic = {vid:score for vid, score in zip(range(len(vox_score)), vox_score)}\n", + "vox_rank = sorted(vox_dic, key=vox_dic.get, reverse=True)\n", + "\n", + "print(f\"The length of the prediction accuracy list is {len(vox_score)}\")\n", + "print(f\"The top ranked 10 voxel IDs are {vox_rank[0:10]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.6 Perform feature selection with actual FCMA implementation \n", + "- After understanding what the feature selection step does, let's now run the actual FCMA feature selection code. This actual code will go through everything we have done up to this point, but 1) with a much finer and efficient implementation and 2) repeating it 8 times, with each time leaving out a different subject (the example code only is only one fold of the outer loop, leaving out subject-0). \n", + "- If you run this locally, expect it to take a couple minutes. You can monitor your terminal for progress. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subject 0 done\n", + "Subject 1 done\n", + "Subject 2 done\n", + "Subject 3 done\n", + "Subject 4 done\n", + "Subject 5 done\n", + "Subject 6 done\n", + "Subject 7 done\n" + ] + } + ], + "source": [ + "# Use subprocess to run a python script with MPI. This should work on a cluster or local computer. \n", + "for left_sid in range(num_subjs):\n", + " subprocess.run(f\"mpirun -np 2 python3 ./FCMA_script/fcma_voxel_selection_cv.py {data_dir} {suffix} {mask_file} {epoch_file} {left_sid} {output_dir}\", shell = True)\n", + " print(f\"Subject {left_sid} done\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Now let's look at its outputs, and let's focus on those from the first fold that left out subject-0. \n", + " - The '*.txt' is basically our 'vox_dic' in the demo code, but in a ranked manner. \n", + " - Each brain voxel in the '*score.nii.gz' file was assigned with its prediction accuracy. \n", + " - Each brain voxel in the '*seq.nii.gz' file was assigned with its prediction accuracy rank (rank = 0 means the highest acc). Using this file, we could select the top-performing brain voxels to form a 'top_n_mask', with n being the number of the top-performing voxels selected." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['fc_no0_result_seq.nii.gz',\n", + " 'fc_no0_result_score.nii.gz',\n", + " 'fc_no0_result_list.txt']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[os.path.basename(x) for x in glob.glob(os.path.join(output_dir, 'fc_no0*'))]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- The top 10 ranked voxel IDs from the FCMA output. Notice that they are mostly the same as those identified using the primitive code above (8 out of 10 are the same). The differences in numeric value could be due to the much finer implementation of FCMA. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['234', '252', '278', '17', '382', '39', '291', '314', '119', '10']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(output_dir + '/fc_no0_result_list.txt', 'r') as f:\n", + " line = f.readlines()\n", + "[l.split(' ')[0] for l in line[0:10]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.7 Select n top-performing features \n", + "- Remember that so far we have got 8 '*seq.nii.gz' files, one for each left out subject. Now we are going to select the N top-performing voxels to form brain masks for each left out subject. \n", + "- The value N could be arbitrarily decided. Here we show N = 10, 20, 30. Small numbers were used to reduce computation demands. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# make top n masks\n", + "for n in [10,20,30]:\n", + " top_n = 'top_' + str(n)\n", + " #subprocess.run(\"module load fsl\", shell = True)\n", + " subprocess.run(f\"bash ./FCMA_script/make_top_voxel_mask.sh {output_dir} {n} {os.path.join(output_dir, top_n)}\", shell = True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. FCMA Step 2: Classification using the selected features (voxels) \n", + "\n", + "#### 2.1 The goal \n", + "- We have selected top N features (voxels) from the original brain mask. Now we can ask if we only consider the connectivity pattern within these selected voxels, how well can a classifier do in terms of differentiating two conditions? The rationale is that if a classifier trained on the FC pattern of the selected features is enough to differentiate the two task conditions, then we could say that the selected voxels are the brain regions among which the FC changes characterize certain task differences. \n", + "\n", + "- For the demo, we will still focus on Subject-0. During the feature selection step, we have selected top N features (voxels) using the traning set (the data of the rest 7 subjects). Now we are going to use these features to build a predictive model and use subject-0 as a testing data to finish the first fold of our outer loop cross validation. \n", + "\n", + "#### 2.2 Classification steps \n", + "\n", + "1. Preprocess all 8 subjects' data as we have discussed above, yielding a list of labels of the length equals 20 (epochs/subject) * 8 (subjects) = 160, and a list of epoch data of the same length. Within each epoch (i.e., each entry in the variable \"int_data\" in the code below), there is a 2d array of [timepoint, nVoxel]. Note that nVoxel depends on the size of the top n masks we are using.\n", + "\n", + "2. Divide the data into training and testing set. This is exactly the same as the feature selection step except that now we have already selected meaningful voxels from the training set. In this demo, the training set is subject 1 - 7 and the testing set is subject-0. \n", + "\n", + "3. Train a model using the FC pattern within the top voxels. Just like the voxel selection, here we use SVM classifer with precomputed kernel. Other classifiers can be used here, too.\n", + "\n", + "4. Test the model using the left out subject. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--TOP 10 Voxels RESULTS--\n", + "Top feature size: TOP 10 Voxels\n", + "[ 0.38126299 -2.41850781 0.45284516 -1.80357795 0.17842044 -0.77340787\n", + " 1.75422849 1.86623616 3.07343915 -3.13254844 -1.45388323 -0.41695132\n", + " 0.44155523 0.22353497 -0.83062927 0.7705409 0.99191314 -0.12486879\n", + " -1.44480709 -0.06320189]\n", + "[1 0 1 0 1 0 1 1 1 0 0 0 1 1 0 1 1 0 0 0]\n", + "When leaving subject 0 out for testing using the /Users/peetal/Documents/GitHub/brainiak-aperture/notebooks/fcma/FCMA_result/top_10/fc_no0_result_seq_top10.nii.gz mask for an intrinsic correlation, the accuracy is 8 / 20 = 0.40\n", + "---------------------------------------------------------------------------------------------------\n", + "--TOP 20 Voxels RESULTS--\n", + "Top feature size: TOP 20 Voxels\n", + "[-8.86536867e-01 1.07148090e-01 -8.85313201e-01 -6.78471999e-01\n", + " 2.52912073e-01 -1.22895096e+00 -1.69236952e-04 -1.41433092e-01\n", + " 3.92896756e-02 -1.17931980e+00 5.94036382e-02 1.80326335e+00\n", + " 3.25205485e-01 4.20668033e-01 -2.49353493e-01 9.49864680e-01\n", + " -8.31116802e-02 -5.89936394e-01 1.70349872e+00 1.34718994e-01]\n", + "[0 1 0 0 1 0 0 0 1 0 1 1 1 1 0 1 0 0 1 1]\n", + "When leaving subject 0 out for testing using the /Users/peetal/Documents/GitHub/brainiak-aperture/notebooks/fcma/FCMA_result/top_20/fc_no0_result_seq_top20.nii.gz mask for an intrinsic correlation, the accuracy is 14 / 20 = 0.70\n", + "---------------------------------------------------------------------------------------------------\n", + "--TOP 30 Voxels RESULTS--\n", + "Top feature size: TOP 30 Voxels\n", + "[-1.65670387e-01 -3.42620453e-01 -6.07346123e-01 -1.22227886e-01\n", + " 7.48107093e-02 -8.58807325e-01 -5.63491134e-01 -1.22717309e-01\n", + " -6.08503929e-01 -3.74452274e-01 3.77464014e-01 5.14801342e-01\n", + " 9.31709915e-01 4.56100009e-01 -8.34279388e-01 9.91251666e-01\n", + " -3.33540780e-01 -1.08481783e-03 1.46670936e+00 -6.37847517e-02]\n", + "[0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 0 0 1 0]\n", + "When leaving subject 0 out for testing using the /Users/peetal/Documents/GitHub/brainiak-aperture/notebooks/fcma/FCMA_result/top_30/fc_no0_result_seq_top30.nii.gz mask for an intrinsic correlation, the accuracy is 15 / 20 = 0.75\n", + "---------------------------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# ------------------------------------------\n", + "# top n feature mask from the training set \n", + "# ------------------------------------------\n", + "# path to 3 top feature masks \n", + "top_n_mask_files = {os.path.join(output_dir, \"top_10/fc_no0_result_seq_top10.nii.gz\") : 'TOP 10 Voxels',\n", + " os.path.join(output_dir, \"top_20/fc_no0_result_seq_top20.nii.gz\") : 'TOP 20 Voxels',\n", + " os.path.join(output_dir, \"top_30/fc_no0_result_seq_top30.nii.gz\") : 'TOP 30 Voxels'}\n", + "\n", + "# for each top feature mask: \n", + "for top_n_mask_path in top_n_mask_files.keys():\n", + " \n", + " # ----------------\n", + " # preprocess data \n", + " # ----------------\n", + " # Load in the volumes, mask and labels\n", + " images = io.load_images_from_dir(data_dir, suffix=suffix)\n", + " top_n_mask = io.load_boolean_mask(top_n_mask_path)\n", + " epoch_list = io.load_labels(epoch_file)\n", + "\n", + " # Parse the epoch data for useful dimensions\n", + " epochs_per_subj = epochs_per_subj = epoch_list[0].shape[1]\n", + " num_subjs = len(epoch_list)\n", + "\n", + " # Prepare the data\n", + " int_data, _, labels = prepare_fcma_data(images, epoch_list, top_n_mask)\n", + "\n", + " # -------------------\n", + " # Outer loop testing\n", + " # -------------------\n", + "\n", + " # What indexes pick out the left out participant?\n", + " start_idx = int(int(left_out_subj) * epochs_per_subj)\n", + " end_idx = int(start_idx + epochs_per_subj)\n", + "\n", + " # Take out the idxs corresponding to all participants but this one\n", + " training_idx = list(set(range(len(labels))) - set(range(start_idx, end_idx)))\n", + " testing_idx = list(range(start_idx, end_idx))\n", + "\n", + " # Pull out the data\n", + " int_data_training = [int_data[i] for i in training_idx]\n", + " int_data_testing = [int_data[i] for i in testing_idx]\n", + "\n", + " # Pull out the labels\n", + " labels_training = [labels[i] for i in training_idx]\n", + " labels_testing = [labels[i] for i in testing_idx]\n", + "\n", + " # Prepare the data to be processed efficiently (albeit in a less easy to follow way)\n", + " rearranged_int_data = int_data_training + int_data_testing\n", + " rearranged_labels = labels_training + labels_testing\n", + " num_training_samples = epochs_per_subj * (num_subjs - 1)\n", + "\n", + " # Set up data so that the internal mask is correlated with the internal mask\n", + " corr_obj = list(zip(rearranged_int_data, rearranged_int_data))\n", + "\n", + " # no shrinking, set C=1\n", + " svm_clf = SVC(kernel='precomputed', shrinking=False, C=1)\n", + "\n", + " clf = Classifier(svm_clf, epochs_per_subj=epochs_per_subj)\n", + "\n", + " # Train the model on the training data\n", + " clf.fit(corr_obj, rearranged_labels, num_training_samples)\n", + "\n", + " # Test on the testing data\n", + " predict = clf.predict()\n", + "\n", + " # ---------------------\n", + " # Print out the results\n", + " # ---------------------\n", + " \n", + " print(f'--{top_n_mask_files[top_n_mask_path]} RESULTS--')\n", + " print(f\"Top feature size: {top_n_mask_files[top_n_mask_path]}\")\n", + " print(clf.decision_function())\n", + " print(clf.predict())\n", + "\n", + " # How often does the prediction match the target\n", + " num_correct = (np.asanyarray(predict) == np.asanyarray(labels_testing)).sum()\n", + "\n", + "\n", + " # Report accuracy\n", + " print( 'When leaving subject %d out for testing using the %s mask for an intrinsic correlation, the accuracy is %d / %d = %.2f' %\n", + " (int(left_out_subj), top_n_mask_path, num_correct, epochs_per_subj, num_correct / epochs_per_subj))\n", + " print('---------------------------------------------------------------------------------------------------')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Understanding the outputs of classification \n", + "1. **Decision function outputs**: a list of values that have the length equal to the number of epochs (in the case of a two way classification, one-versus-one). Each value indicates an epoch's location relative to the hyperplane defined in SVM. The sign of the output indicates the class of the epoch and the absolute value indicates the confidence of the classification of this epoch. \n", + "2. **Class prediction**: a list of values that has the length equal to the number of epochs (in the case of a two way classification). Each value indicates the guessed class of the epoch (which condition). \n", + "3. **Classification accuracy**: correctly classified epochs / total epochs.\n", + "\n", + "### 2.4 Perform classification for all outer loop folds using FCMA script \n", + "- The outer loop has 8 folds (8 subjects) and each subject has 3 top n masks. Thus in total 24 classifications would be performed. \n", + "- The whole process should take around 15 minutes depends on your laptop. You **DO NOT** have to run this as the outputs are already included in the folder. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Left out subject 0, Top 10 voxel mask, Classification done\n", + "Left out subject 1, Top 10 voxel mask, Classification done\n", + "Left out subject 2, Top 10 voxel mask, Classification done\n", + "Left out subject 3, Top 10 voxel mask, Classification done\n", + "Left out subject 4, Top 10 voxel mask, Classification done\n", + "Left out subject 5, Top 10 voxel mask, Classification done\n", + "Left out subject 6, Top 10 voxel mask, Classification done\n", + "Left out subject 7, Top 10 voxel mask, Classification done\n", + "Left out subject 0, Top 20 voxel mask, Classification done\n", + "Left out subject 1, Top 20 voxel mask, Classification done\n", + "Left out subject 2, Top 20 voxel mask, Classification done\n", + "Left out subject 3, Top 20 voxel mask, Classification done\n", + "Left out subject 4, Top 20 voxel mask, Classification done\n", + "Left out subject 5, Top 20 voxel mask, Classification done\n", + "Left out subject 6, Top 20 voxel mask, Classification done\n", + "Left out subject 7, Top 20 voxel mask, Classification done\n", + "Left out subject 0, Top 30 voxel mask, Classification done\n", + "Left out subject 1, Top 30 voxel mask, Classification done\n", + "Left out subject 2, Top 30 voxel mask, Classification done\n", + "Left out subject 3, Top 30 voxel mask, Classification done\n", + "Left out subject 4, Top 30 voxel mask, Classification done\n", + "Left out subject 5, Top 30 voxel mask, Classification done\n", + "Left out subject 6, Top 30 voxel mask, Classification done\n", + "Left out subject 7, Top 30 voxel mask, Classification done\n" + ] + } + ], + "source": [ + "# run classification for each left out subject for each top-n-mask size\n", + "for n, left_sid in product([10,20,30],range(8)):\n", + " \n", + " top_n_mask_file_path = os.path.join(output_dir, f'top_{n}', f'fc_no{left_sid}_result_seq_top{n}.nii.gz')\n", + " results_path = os.path.join(output_dir, f'top_{n}')\n", + " \n", + " subprocess.run(f\"mpirun -np 2 python3 ./FCMA_script/fcma_classify.py {data_dir} {suffix} {top_n_mask_file_path} {epoch_file} {left_sid} {results_path}\", shell = True) \n", + " \n", + " print(f\"Left out subject {left_sid}, Top {n} voxel mask, Classification done\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3 Results Visualizations \n", + "### 3.1 Examine classification accuracy for different top-n-mask " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The FCMA classification accuracy when using the functional connectivity pattern of \n", + " voxels within each subject's top n mask to predict the current task condition (A or B) \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# write a function to extract left-out subject id and the classification acc. \n", + "def extract_clf_acc(base_dir, top_num, num_subjs):\n", + " \n", + " import os\n", + " import numpy as np\n", + " import pandas as pd\n", + " path = os.path.join(base_dir, top_num, 'classify_result.txt')\n", + "\n", + " # read each line, from which extract the left out subject id and the clf acc\n", + " with open(path, \"r\") as file:\n", + " lines = file.readlines()\n", + " loo_id = []\n", + " acc = []\n", + " for line in lines: \n", + " id_start_index = line.index('_no') + len('_no')\n", + " id_end_index = line.index('_result_seq')\n", + " id = int(line[id_start_index:id_end_index])\n", + " loo_id.append(id)\n", + "\n", + " acc_start_index = line.index(': ') + 2\n", + " acc_end_index = line.index('\\n')\n", + " score = float(line[acc_start_index:acc_end_index])\n", + " acc.append(score)\n", + "\n", + " # write a dataframe \n", + " colnames = ['loo_id','clf_acc','top_num']\n", + " df = pd.DataFrame(index=range(len(loo_id)), columns=colnames)\n", + " df['loo_id'] = loo_id \n", + " df['clf_acc'] = acc\n", + " df['top_num'] = np.repeat(top_num, len(loo_id)).tolist()\n", + " \n", + " return df\n", + "\n", + "# generate df and concatenate them together\n", + "df_list = [extract_clf_acc(output_dir,'top_10', num_subjs),\n", + " extract_clf_acc(output_dir,'top_20', num_subjs),\n", + " extract_clf_acc(output_dir,'top_30', num_subjs)]\n", + "final_df = pd.concat(df_list).reset_index(drop=True)\n", + "\n", + "# a quick look at the df \n", + "ax = sns.pointplot(x=\"top_num\", y=\"clf_acc\", data=final_df)\n", + "ax.set_title('Classification accuracy for each top-n-mask')\n", + "ax.set_ylabel('Classification accuracy')\n", + "ax.set_xlabel('Top n mask')\n", + "print(\"The FCMA classification accuracy when using the functional connectivity pattern of \\n voxels within each subject's top n mask to predict the current task condition (A or B) \")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Visualize voxels in top-n-masks \n", + "- Let's take the top 30 voxel results as an example. Remember that the top 30 voxels for each training sets may be different given that we have 8 training sets (one for each left out subject). Thus a given voxel may appear 0 - 8 times in these 8 top-30-feature masks. This can be converted into proportions (what proportion of folds does each voxel end up in the top 30 voxels), resulting a voxelwise map. (i.e., 'prop_top30.nii.gz')\n", + "- Let's look at our cherry picked brain again, which consists of 432 voxels in total. The 432 voxels are evenly divided into two 6x6x6 cubes located at vmPFC and precuenus as shown below. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The cherry-picked 432 voxel brain that consists of two brain regions\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"The cherry-picked 432 voxel brain that consists of two brain regions\")\n", + "plotting.view_img(os.path.join(cur_dir, 'sim_info', 'full_mask.nii.gz'), title = \"The brain mask\", colorbar = False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Then we can look at the top 30 voxels. The color bar indicates the proportion of folds a voxel appears in the 8 top-30-masks (one for each subject). \n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The top 30 voxels proportion map\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"The top 30 voxels proportion map\")\n", + "plotting.view_img(os.path.join(output_dir, 'top_30','prop_top30.nii.gz'), title = \"Top 30 voxels\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.3 Visualize functional connectivity pattern with circos plot \n", + "- For a given epoch, we can use circos plot to understand the functional connectivity pattern between our top N voxels. Note that for plotting the circos plot, one would usually be dealing with thousands of voxels, thus knowing how to group voxels beforehand is important. Here for the simulated data, we have two arbitrarily chosen ROIs, and the top n voxels were grouped into one of these two ROIs." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The figure plots all 432 voxels across two ROIs; \n", + "and highlighted how the top 30 voxels are functionally connected, both within and across ROIs.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load in the data \n", + "epoch_data = raw_data[0] # Just load a single subject and a single epoch\n", + "mask_top_n_file = os.path.join(output_dir, 'top_30/fc_no0_result_seq_top30.nii.gz')\n", + "mask_top_n_nii = nib.load(mask_top_n_file) # Load the mask that leaves that participant out\n", + "mask_top_n = mask_top_n_nii.get_fdata()\n", + "\n", + "# Convert the top n mask into a vector with the same number of elements as the whole brain\n", + "mask_vec = mask.reshape(np.prod(mask.shape))\n", + "mask_top_vec = mask_top_n.reshape(np.prod(mask_top_n.shape))[mask_vec]\n", + "\n", + "# Modify the epoch data, for visulization purpose\n", + "epoch_data[:,np.where(mask_top_vec==0)] = 1\n", + "\n", + "# Make the data c continguous \n", + "epoch_data_masked = np.ascontiguousarray(epoch_data.T, dtype=np.float32)\n", + "\n", + "# Create the internal correlation\n", + "epoch_corr = compute_correlation(epoch_data_masked, epoch_data_masked)\n", + "\n", + "# Load the two simulated ROIs\n", + "roiA = nib.load(os.path.join(cur_dir, 'sim_info/ROI_A_mpfc.nii.gz')).get_fdata()\n", + "roiB = nib.load(os.path.join(cur_dir, 'sim_info/ROI_B_precuenus.nii.gz')).get_fdata()\n", + "\n", + "# Pull out the coordinates of the mask (in numpy space)\n", + "coord_x, coord_y, coord_z = np.where(mask == 1)\n", + "\n", + "# %matplotlib inline\n", + "\n", + "# What is the (absolute) correlation threshold\n", + "threshold = 0.8\n", + "\n", + "# Preset the graph\n", + "G = nx.Graph()\n", + "\n", + "# Create the edge list\n", + "nodelist = []\n", + "edgelist = []\n", + "for row_counter in range(epoch_corr.shape[0]):\n", + " nodelist.append(str(row_counter)) # Set up the node names\n", + " \n", + " for col_counter in range(epoch_corr.shape[1]):\n", + " \n", + " # Determine whether to include the edge based on whether it exceeds the threshold\n", + " if (abs(epoch_corr[row_counter, col_counter]) > threshold) and (abs(epoch_corr[row_counter, col_counter]) < 1):\n", + " # Add a tuple specifying the voxel pairs being compared and the weight of the edge\n", + " edgelist.append((str(row_counter), str(col_counter), {'weight': epoch_corr[row_counter, col_counter]}))\n", + " \n", + "# Create the nodes in the graph\n", + "G.add_nodes_from(nodelist)\n", + "\n", + "# Add the edges\n", + "G.add_edges_from(edgelist)\n", + "\n", + "for n, d in G.nodes(data=True):\n", + " \n", + " # Is the voxel in roiA or B\n", + " if roiA[coord_x[int(n)],coord_y[int(n)],coord_z[int(n)]] == 1:\n", + " G.nodes[n]['grouping'] = 'roiA (mPFC)'\n", + "\n", + " elif roiB[coord_x[int(n)],coord_y[int(n)],coord_z[int(n)]] == 1:\n", + " G.nodes[n]['grouping'] = 'roiB (Precuneus)'\n", + "\n", + "\n", + "c = CircosPlot(graph=G, node_grouping='grouping', node_color='grouping', group_label_position='middle',figsize=(10,6))\n", + "c.draw()\n", + "plt.title('Circos plot of an epoch data')\n", + "print(\"The figure plots all 432 voxels across two ROIs; \\nand highlighted how the top 30 voxels are functionally connected, both within and across ROIs.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Summary \n", + "- In the notebook, we have shown how to use FCMA to perform non-seed based, whole brain functional connectivity analyses. Going back to our two initial questions, we asked:\n", + " 1. Do functional connectivity patterns differ between condition A and B? \n", + " 2. If so, which brain regions are driving the difference?\n", + "- Answering Q1: \n", + " - Based on the plot in 3.1 above, we can argue the functional connectivity pattern within the top 20 and 30 selected voxels can be used to differentiate whether a subject is doing condition A or B with relatively high accuracy. Thus, the answer to question 1 is yes! The FC patterns do differ across condition A and B.\n", + "- Answering Q2:\n", + " - The plot in 3.2 shows where those top n voxels are located and the plot in 3.3 shows how the top n voxels are functionally connected. \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/fcma/FCMA_script/fcma_classify.py b/docs/examples/fcma/FCMA_script/fcma_classify.py new file mode 100644 index 00000000..66220ae7 --- /dev/null +++ b/docs/examples/fcma/FCMA_script/fcma_classify.py @@ -0,0 +1,178 @@ +# Copyright 2016 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from brainiak.fcma.classifier import Classifier +from brainiak.fcma.preprocessing import prepare_fcma_data +from brainiak import io + +from sklearn.svm import SVC +import sys +import logging +import numpy as np +from sklearn import model_selection +from mpi4py import MPI +import os + + +format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' +# if want to output log to a file instead of outputting log to the console, +# replace "stream=sys.stdout" with "filename='fcma.log'" +logging.basicConfig(level=logging.INFO, format=format, stream=sys.stdout) +logger = logging.getLogger(__name__) + +data_dir = sys.argv[1] +suffix = sys.argv[2] +top_n_mask_file = sys.argv[3] # This is not the whole brain mask! This is the voxel selection mask +epoch_file = sys.argv[4] +left_out_subj = sys.argv[5] +results_path = sys.argv[6] +if len(sys.argv)==8: + second_mask = sys.argv[7] # Do you want to supply a second mask (for extrinsic analysis) +else: + second_mask = "None" + +if not os.path.exists(results_path): + os.makedirs(results_path) + +# Where do you want to output the classification results? +output_file = results_path + '/classify_result.txt' + +# Do you want to compute this in an easily understood way (0) or a memory efficient way (1)? +is_memory_efficient = 1 + +# If a second mask was supplied then this is an extrinsic analysis and treat it as such +if second_mask == "None": + is_extrinsic = 0 +else: + is_extrinsic = 1 + +if __name__ == '__main__': + + # Send a message on the first node + if MPI.COMM_WORLD.Get_rank()==0: + logger.info( + 'Testing for participant %d.\nProgramming starts in %d process(es)' % + (int(left_out_subj), MPI.COMM_WORLD.Get_size()) + ) + + # Load in the volumes, mask and labels + images = io.load_images_from_dir(data_dir, suffix=suffix) + top_n_mask = io.load_boolean_mask(top_n_mask_file) + epoch_list = io.load_labels(epoch_file) + + # Parse the epoch data for useful dimensions + epochs_per_subj = epochs_per_subj = epoch_list[0].shape[1] + num_subjs = len(epoch_list) + + # Prepare the data + int_data, _, labels = prepare_fcma_data(images, epoch_list, top_n_mask) + + # What indexes pick out the left out participant? + start_idx = int(int(left_out_subj) * epochs_per_subj) + end_idx = int(start_idx + epochs_per_subj) + + # Take out the idxs corresponding to all participants but this one + training_idx = list(set(range(len(labels))) - set(range(start_idx, end_idx))) + testing_idx = list(range(start_idx, end_idx)) + + # Pull out the data + int_data_training = [int_data[i] for i in training_idx] + int_data_testing = [int_data[i] for i in testing_idx] + + # Pull out the labels + labels_training = [labels[i] for i in training_idx] + labels_testing = [labels[i] for i in testing_idx] + + # Prepare the data to be processed efficiently (albeit in a less easy to follow way) + if is_memory_efficient == 1: + rearranged_int_data = int_data_training + int_data_testing + rearranged_labels = labels_training + labels_testing + num_training_samples = epochs_per_subj * (num_subjs - 1) + + # Do you want to perform an intrinsic vs extrinsic analysis + if is_extrinsic > 0 and is_memory_efficient == 1: + + # This needs to be reloaded every time you call prepare_fcma_data + images = io.load_images_from_dir(data_dir, suffix=suffix) + + # Multiply the inverse of the top n mask by the whole brain mask to bound it + second_mask = io.load_boolean_mask(second_mask) + extrinsic_mask = ((top_n_mask == 0) * second_mask)==1 + + # Prepare the data using the extrinsic data + ext_data, _, _ = prepare_fcma_data(images, epoch_list, extrinsic_mask) + + # Pull out the appropriate extrinsic data + ext_data_training = [ext_data[i] for i in training_idx] + ext_data_testing = [ext_data[i] for i in testing_idx] + + # Set up data so that the internal mask is correlated with the extrinsic mask + rearranged_ext_data = ext_data_training + ext_data_testing + corr_obj = list(zip(rearranged_ext_data, rearranged_int_data)) + else: + + # Set up data so that the internal mask is correlated with the internal mask + if is_memory_efficient == 1: + corr_obj = list(zip(rearranged_int_data, rearranged_int_data)) + else: + training_obj = list(zip(int_data_training, int_data_training)) + testing_obj = list(zip(int_data_testing, int_data_testing)) + + # no shrinking, set C=1 + svm_clf = SVC(kernel='precomputed', shrinking=False, C=1) + + clf = Classifier(svm_clf, epochs_per_subj=epochs_per_subj) + + # Train the model on the training data + if is_memory_efficient == 1: + clf.fit(corr_obj, rearranged_labels, num_training_samples) + else: + clf.fit(training_obj, labels_training) + + # What is the cv accuracy? + if is_memory_efficient == 0: + cv_prediction = clf.predict(training_obj) + + # Test on the testing data + if is_memory_efficient == 1: + predict = clf.predict() + else: + predict = clf.predict(testing_obj) + + # Report results on the first rank core + if MPI.COMM_WORLD.Get_rank()==0: + print('--RESULTS--') + print(clf.decision_function()) + print(clf.predict()) + + # How often does the prediction match the target + num_correct = (np.asanyarray(predict) == np.asanyarray(labels_testing)).sum() + + # Print the CV accuracy + if is_memory_efficient == 0: + cv_accuracy = (np.asanyarray(cv_prediction) == np.asanyarray(labels_training)).sum() / len(labels_training) + print('CV accuracy: %0.5f' % (cv_accuracy)) + + intrinsic_vs_extrinsic = ['intrinsic', 'extrinsic'] + + # Report accuracy + logger.info( + 'When leaving subject %d out for testing using the %s mask for an %s correlation, the accuracy is %d / %d = %.2f' % + (int(left_out_subj), top_n_mask_file, intrinsic_vs_extrinsic[int(is_extrinsic)], num_correct, epochs_per_subj, num_correct / epochs_per_subj) + ) + + # Append this accuracy on to a score sheet + file_name = top_n_mask_file.split('/')[-1] + with open(output_file, 'a') as fp: + fp.write(file_name + ': ' + str(num_correct / epochs_per_subj) + '\n') diff --git a/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py b/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py new file mode 100644 index 00000000..09ae0e2b --- /dev/null +++ b/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py @@ -0,0 +1,117 @@ +# Copyright 2016 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from brainiak.fcma.voxelselector import VoxelSelector +from brainiak.fcma.preprocessing import prepare_fcma_data +from brainiak.fcma.preprocessing import RandomType +from brainiak import io +from sklearn.svm import SVC +import sys +from mpi4py import MPI +import logging +import numpy as np +import nibabel as nib +import os + +format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' +# if want to output log to a file instead of outputting log to the console, +# replace "stream=sys.stdout" with "filename='fcma.log'" +logging.basicConfig(level=logging.INFO, format=format, stream=sys.stdout) +logger = logging.getLogger(__name__) + +""" +Perform leave one participant out voxel selection with FCMA +""" + +data_dir = sys.argv[1] # What is the directory containing data? +suffix = sys.argv[2] # What is the extension of the data you're loading +mask_file = sys.argv[3] # What is the path to the whole brain mask +epoch_file = sys.argv[4] # What is the path to the epoch file +left_out_subj = sys.argv[5] # Which participant (as an integer) are you leaving out for this cv? +output_dir = sys.argv[6] # What is the path to the folder you want to save this data in + +# Only run the following from the controller core +if __name__ == '__main__': + if MPI.COMM_WORLD.Get_rank()==0: + logger.info( + 'Testing for participant %d.\nProgramming starts in %d process(es)' % + (int(left_out_subj), MPI.COMM_WORLD.Get_size()) + ) + # create output_dir + if not os.path.exists(output_dir): + os.makedirs(output_dir) + + # Load in the volumes, mask and labels + images = io.load_images_from_dir(data_dir, suffix=suffix) + mask = io.load_boolean_mask(mask_file) + epoch_list = io.load_labels(epoch_file) + + # Parse the epoch data for useful dimensions + epochs_per_subj = epoch_list[0].shape[1] + num_subjs = len(epoch_list) + + # Preprocess the data and prepare for FCMA + raw_data, _, labels = prepare_fcma_data(images, epoch_list, mask) + + # enforce left one out + file_str = output_dir + '/fc_no' + str(left_out_subj) + '_' + start_idx = int(int(left_out_subj) * epochs_per_subj) + end_idx = int(start_idx + epochs_per_subj) + + # Take out the idxs corresponding to all participants but this one + subsampled_idx = list(set(range(len(labels))) - set(range(start_idx, end_idx))) + labels_subsampled = [labels[i] for i in subsampled_idx] + raw_data_subsampled = [raw_data[i] for i in subsampled_idx] + + # Set up the voxel selection object for fcma + vs = VoxelSelector(labels_subsampled, epochs_per_subj, num_subjs - 1, raw_data_subsampled) + + # for cross validation, use SVM with precomputed kernel + clf = SVC(kernel='precomputed', shrinking=False, C=1) + results = vs.run(clf) + + # this output is just for result checking + if MPI.COMM_WORLD.Get_rank()==0: + logger.info( + 'correlation-based voxel selection is done' + ) + + # Load in the mask with nibabel + mask_img = nib.load(mask_file) + mask = mask_img.get_data().astype(np.bool) + + # Preset the volumes + score_volume = np.zeros(mask.shape, dtype=np.float32) + score = np.zeros(len(results), dtype=np.float32) + seq_volume = np.zeros(mask.shape, dtype=np.int) + seq = np.zeros(len(results), dtype=np.int) + + # Write a text document of the voxel selection results + with open(file_str + 'result_list.txt', 'w') as fp: + for idx, tuple in enumerate(results): + fp.write(str(tuple[0]) + ' ' + str(tuple[1]) + '\n') + + # Store the score for each voxel + score[tuple[0]] = tuple[1] + seq[tuple[0]] = idx + + # Convert the list into a volume + score_volume[mask] = score + seq_volume[mask] = seq + + # Save volume + io.save_as_nifti_file(score_volume, mask_img.affine, + file_str + 'result_score.nii.gz') + io.save_as_nifti_file(seq_volume, mask_img.affine, + file_str + 'result_seq.nii.gz') diff --git a/docs/examples/fcma/FCMA_script/make_top_voxel_mask.sh b/docs/examples/fcma/FCMA_script/make_top_voxel_mask.sh new file mode 100644 index 00000000..916102e9 --- /dev/null +++ b/docs/examples/fcma/FCMA_script/make_top_voxel_mask.sh @@ -0,0 +1,35 @@ +#!/bin/bash -i +# +# Takes in a results directory from fcma analysis and a certain number of voxels to threshold for a mask as input + +#You will need to load fsl module/conda for your cluster +#source ../setup_environment.sh + + +# Take inputs +input_dir=$1 # What is the path to thedata? +voxel_number=$2 # What voxel threshold would you like to set +output_dir=$3 # Where do you want to put the data + +# Create output_dir +if [ ! -d ${output_dir} ]; then + mkdir ${output_dir} +fi + +# Iterate through each volume in the fcma directory +for file in ${input_dir}/*_seq.nii.gz +do + # Preprocess the file name + fbase=$(basename "$file") + pref="${fbase%%.*}" + + # Create the voxel mask + fslmaths $file -uthr $voxel_number -bin ${output_dir}/${pref}_top${voxel_number}.nii.gz + +done + +# Concatenate all of the masks from each volume +fslmerge -t ${output_dir}/all_top${voxel_number} ${output_dir}/fc_no*top${voxel_number}.nii.gz + +# Create a probability map of each voxel being included across participants +fslmaths ${output_dir}/all_top${voxel_number} -Tmean ${output_dir}/prop_top${voxel_number} -odt float diff --git a/docs/examples/fcma/sim_info/simualte_FCMA_dat.py b/docs/examples/fcma/sim_info/simualte_FCMA_dat.py new file mode 100755 index 00000000..e641008a --- /dev/null +++ b/docs/examples/fcma/sim_info/simualte_FCMA_dat.py @@ -0,0 +1,221 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Sep 30 11:41:27 2020 + +@author: Peeta Li +@contact: peetal@uoregon.edu +@modulated from https://brainiak.org/tutorials/13-real-time/ +""" + +# Check pick ~400 brain voxels, from two regions of interest (two cubes). +# Not choose voxels randomly due to visualization purpose. +""" +# -------------------------------------------------- +# Cherry pick brain voxels for the simulation data +# -------------------------------------------------- +# mPFC MNI cooridnates: (0,54,-6) +# precuneus MNI coordinates: (0,-60,33) + +# given MNI coordination, return voxel coordination given a mask dimenison. +def _MNI_to_voxel_coord(x,y,z,affine): + import numpy as np + mni = np.asmatrix([[x],[y],[z],[1]]) + # pusedoinversed affine matrix %*% mni is the voxel coordinate + voxel = np.asarray(np.asmatrix(np.linalg.pinv(affine.affine)) * mni) + # transpose the result matrix, choose the first index, round, retrun a list + center_voxel = [int(c) for c in np.transpose(voxel[0:3])[0].tolist()] + + return center_voxel[0], center_voxel[1], center_voxel[2] + +# given center voxel coordination, mask and radius, output a roi mask +def _generate_roi_cube(x,y,z,brain_mask,radius): + # empty the mask + empty_mask = np.zeros(brain_mask.shape) + # + empty_mask[x-radius:x+radius, y-radius:y+radius, z-radius:z+radius] = 1 + + return empty_mask + +# load in the mask, can be generated of different sizes. +dat_dir = '/path/to/FCMA_demo/sim_info' +mask_nii = image.load_img(os.path.join(dat_dir, 'brain_mask.nii.gz')) +mask = mask_nii.get_fdata() + +# roi_A (mPFC) +x1, y1, z1 = _MNI_to_voxel_coord(0,54,-6,mask_nii) +roi_A_mask = _generate_roi_cube(x1,y1,z1,mask,3) +roi_A_mask_nii = image.new_img_like(mask_nii, roi_A_mask, mask_nii.affine) + +# roi_B (precuneus) +x2, y2, z2 = _MNI_to_voxel_coord(0,-60,33,mask_nii) +roi_B_mask = _generate_roi_cube(x2,y2,z2,mask,3) +roi_B_mask_nii = image.new_img_like(mask_nii, roi_B_mask, mask_nii.affine) + +# full mask +full_mask = np.zeros(mask.shape) +full_mask[np.where(roi_A_mask == 1)] = 1 +full_mask[np.where(roi_B_mask == 1)] = 1 +full_mask_nii = image.new_img_like(mask_nii, full_mask, mask_nii.affine) + +# write out all the nifts: +roi_A_mask_nii.to_filename(os.path.join(dat_dir, 'ROI_A_mpfc.nii.gz')) +roi_B_mask_nii.to_filename(os.path.join(dat_dir, 'ROI_B_precuenus.nii.gz')) +full_mask_nii.to_filename(os.path.join(dat_dir, 'full_mask.nii.gz')) +""" + +# simulate 10 subjects' fMRI data over 9 small features (ROI) for FCMA demo + +import os, random +from nilearn import image, plotting +import numpy as np +from brainiak.utils import fmrisim as sim + +# specify directory +dat_dir = '/path/to/FCMA_demo/sim_info' + +# Specify the volume parameters +trDuration = 1 # seconds +numTRs = 400 # How many TRs will you generate? + +# Set up stimulus event time course parameters +event_duration = 15 # How long is each event +isi = 5 # What is the time between each event + +# Specify signal magnitude parameters +signal_change = 10 # How much change is there in intensity for the max of the patterns across participants +multivariate_pattern = 1 # Do you want the signal to be a z scored pattern across voxels (1) or a univariate increase (0) + +print('Load template of average voxel value') +sub_template_nii = image.load_img(os.path.join(dat_dir, 'brain_template.nii.gz')) +sub_template = sub_template_nii.get_fdata() +dimensions = np.array(sub_template.shape[0:3]) + +print('Create binary mask and normalize the template range') +mask, template = sim.mask_brain(volume = sub_template, mask_self = True) +mask_cherry = image.load_img(os.path.join(dat_dir, 'full_mask.nii.gz')).get_fdata() + +# Load the noise dictionary +print('Loading noise parameters') +with open(os.path.join(dat_dir, 'sub_noise_dict.txt'), 'r') as f: + noise_dict = f.read() +noise_dict = eval(noise_dict) +noise_dict['matched'] = 0 + + +# stimfunction across two conditions for each subject +stimfunc_all = [] +for sid in range(8): # sid = 0 + # Create the stimulus time course of the conditions + total_time = int(numTRs * trDuration) + events = int(total_time / (event_duration + isi)) + onsets_A = [] + onsets_B = [] + randoized_label = np.repeat([1,2],int(events/2)).tolist() + random.shuffle(randoized_label) + for event_counter, cond in enumerate(randoized_label): + + # Flip a coin for each epoch to determine whether it is A or B + if cond == 1: + onsets_A.append(event_counter * (event_duration + isi)) + elif cond == 2: + onsets_B.append(event_counter * (event_duration + isi)) + + temporal_res = 1 # How many timepoints per second of the stim function are to be generated? + + # Create a time course of events + stimfunc_A = sim.generate_stimfunction(onsets=onsets_A, + event_durations=[event_duration], + total_time=total_time, + temporal_resolution=temporal_res, + ) + + stimfunc_B = sim.generate_stimfunction(onsets=onsets_B, + event_durations=[event_duration], + total_time=total_time, + temporal_resolution=temporal_res, + ) + # stimfunc per subject + stimfunc_ppt = np.concatenate((stimfunc_A, stimfunc_B), axis = 1) + + stimfunc_all.append(stimfunc_ppt) + + print('Load ROIs') + nii_A = image.load_img(os.path.join(dat_dir, 'ROI_A_mpfc.nii.gz')) + nii_B = image.load_img(os.path.join(dat_dir, 'ROI_B_precuenus.nii.gz')) + ROI_A = nii_A.get_fdata() + ROI_B = nii_B.get_fdata() + + # How many voxels per ROI + voxels_A = int(ROI_A.sum()) + voxels_B = int(ROI_B.sum()) + + # Create a pattern of activity across the two voxels + print('Creating signal pattern') + + pattern_A = np.random.rand(voxels_A).reshape((voxels_A, 1)) + pattern_B = np.random.rand(voxels_B).reshape((voxels_B, 1)) + + # Multiply each pattern by each voxel time course + # Noise was added to the design matrix, to make the correlation pattern noise, so FCMA could be challenging. + # use normal distributed noise instead of unifrom distributed to make the data noisier + weights_A = np.tile(stimfunc_A, voxels_A) * pattern_A.T + np.random.normal(0,1.5, size = np.tile(stimfunc_A, voxels_A).shape) + weights_B = np.tile(stimfunc_B, voxels_B) * pattern_B.T + np.random.normal(0,1.5, size = np.tile(stimfunc_B, voxels_B).shape) + + # Convolve the onsets with the HRF + # TR less than feature is not good, but b/c this is simulated data, can ignore this concer. + print('Creating signal time course') + signal_func_A = sim.convolve_hrf(stimfunction=weights_A, + tr_duration=trDuration, + temporal_resolution=temporal_res, + scale_function=1, + ) + + signal_func_B = sim.convolve_hrf(stimfunction=weights_B, + tr_duration=trDuration, + temporal_resolution=temporal_res, + scale_function=1, + ) + + + # Multiply the signal by the signal change + signal_func_A = signal_func_A * signal_change #+ signal_func_B * signal_change + signal_func_B = signal_func_B * signal_change #+ signal_func_A * signal_change + + # Combine the signal time course with the signal volume + print('Creating signal volumes') + signal_A = sim.apply_signal(signal_func_A, + ROI_A) + + signal_B = sim.apply_signal(signal_func_B, + ROI_B) + + # Combine the two signal timecourses + signal = signal_A + signal_B + + # spare the true noise. + #print('Generating noise') + #noise = sim.generate_noise(dimensions=dimensions, + # stimfunction_tr=np.zeros((numTRs, 1)), + # tr_duration=int(trDuration), + # template=template, + # mask=mask_cherry, + # noise_dict=noise_dict, + # temporal_proportion = 0.5) + + + + brain = signal #+ noise + brain_nii = image.new_img_like(template_nii, brain, template_nii.affine) + out_path = os.path.join(dat_dir, '../simulated_data') + if os.path.isdir(out_path) is False: + os.makedirs(out_path, exist_ok=True) + brain_nii.to_filename(os.path.join(out_path, f"sub_{sid}_sim_dat.nii.gz")) + + +# write out the simulated epoch file +sim.export_epoch_file(stimfunction = stimfunc_all, + filename = os.path.join(dat_dir, '../simulated_data/sim_epoch_file.npy'), + tr_duration = 1.0, + temporal_resolution = 1.0,) + diff --git a/docs/examples/fmrisim/download_data.sh b/docs/examples/fmrisim/download_data.sh new file mode 100644 index 00000000..a06b0962 --- /dev/null +++ b/docs/examples/fmrisim/download_data.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +# Download the archive containing the example data if we don't have it already +wget -nc https://dataspace.princeton.edu/bitstream/88435/dsp01dn39x4181/2/Corr_MVPA_archive.tar.gz + +# If the file doesn't exist, we need to extract it. +test ! -e Corr_MVPA && tar xzkvf Corr_MVPA_archive.tar.gz Corr_MVPA_Data_dataspace/Participant_01_rest_run01.nii && mv Corr_MVPA_Data_dataspace Corr_MVPA + diff --git a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb new file mode 100644 index 00000000..d8060e8c --- /dev/null +++ b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb @@ -0,0 +1,9047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# fmrisim demo script\n", + "\n", + "Authors: Cameron T Ellis ([cameron.ellis@yale.edu](mailto:cameron.ellis@yale.edu)), Christopher Baldassano ([c.baldassano@columbia.edu](mailto:c.baldassano@columbia.edu)), Anna C Schapiro ([aschapir@sas.upenn.edu](mailto:aschapir@sas.upenn.edu)), Ming Bo Cai ([mingbo.cai@ircn.jp](mailto:mingbo.cai@ircn.jp)), Jonathan D Cohen ([jdc@princeton.edu](jdc@princeton.edu)) \n", + "\n", + "## Overview\n", + "\n", + "Example script to demonstrate fmrisim functionality. This generates data for a two condition, event-related design in which each condition evokes different activity within the same voxels. It then runs simple univariate and multivariate analyses on the data. \n", + "\n", + "If you would like a script that can be executed from the command line and scaffolds the simulation process, refer to the `fmrisim_real_time_generator.py` script in the `brainiak/utils` folder. \n", + "\n", + "\n", + "## Annotated bibliography\n", + "\n", + "1. Ellis, C. T., Baldassano, C., Schapiro, A. C., Cai, M. B., Cohen, J. D. (2020). Facilitating open-science with realistic fMRI simulation: validation and application. *PeerJ* 8:e8564 [`link`](https://peerj.com/articles/8564/)\n", + "*Describes and validates the fmrisim method. Applies it to a dataset to test alternative design parameters and evaluate how these parameters influence the effect size* \n", + "\n", + "2. Ellis, C. T., Lesnick, M., Henselman-Petrusek, G., Keller, B., & Cohen, J. D. (2019). Feasibility of topological data analysis for event-related fMRI, Network Neuroscience, 1-12 [`link`](https://www.mitpressjournals.org/doi/full/10.1162/netn_a_00095?mobileUi=0)\n", + "*Example of using fmrisim to evaluate the plausibility of an analysis procedure under different signal parameters and design constraints* \n", + "\n", + "3. Kumar, S., Ellis, C., O'Connell, T. P., Chun, M. M., & Turk-Browne, N. B. (in press). Searching through functional space reveals distributed visual, auditory, and semantic coding in the human brain. *PLoS Computational Biology* [`link`](https://www.biorxiv.org/content/10.1101/2020.04.20.052175v1)\n", + "*Example of using fmrisim to test different possible neural bases for an observed effect in real data* \n", + "\n", + "4. Welvaert, M., et al. (2011) neuRosim: An R package for generating fMRI data. *Journal of Statistical Software* 44, 1-18 [`link`](https://www.jstatsoft.org/article/view/v044i10)\n", + "*A package in R for simulating fMRI data that was an inspiration for fmrisim*\n", + "\n", + "\n", + "## Table of Contents\n", + "[1. Set parameters](#set_parameters) \n", + "- [1.1 Import necessary Python packages](#import_packages) \n", + "- [1.2 Load participant data](#load_ppt) \n", + "- [1.3 Specify participant dimensions and resolution](#specify_dim) \n", + "- [1.4 Generate an activity template and a mask](#generate_template) \n", + "- [1.5 Determine noise parameters](#noise_parameters) \n", + "\n", + "[2. Generate noise](#generate_noise) \n", + "- [2.1 Create temporal noise](#temporal_noise) \n", + "- [2.2 Create system noise](#system_noise) \n", + "- [2.3 Combine noise and template](#template_noise) \n", + "- [2.4 Fit the data to the noise parameters](#fit_noise) \n", + "\n", + "[3. Generate signal](#generate_signal) \n", + "- [3.1 Specify which voxels in the brain contain signal](#specify_signal) \n", + "- [3.2 Characterize signal for voxels](#characterize_signal) \n", + "- [3.3 Generate event time course](#generate_time_course) \n", + "- [3.4 Export stimulus time course for analysis](#export_time_course) \n", + "- [3.5 Estimate the voxel weight for each event](#weight_signal) \n", + "- [3.6 Convolve each voxel’s time course with the Hemodynamic Response Function](#convolve_HRF) \n", + "- [3.7 Establish signal magnitude](#compute_signal) \n", + "- [3.8 Multiply the convolved response with the signal voxels](#multiply_signal) \n", + "- [3.9 Combine signal and noise](#combine_signal) \n", + "\n", + "[4. Analyse data](#analyse_data) \n", + "- [4.1 Pull out data for each trial](#pull_data) \n", + "- [4.2 Represent the data](#represent_data) \n", + "- [4.3 Test for univariate effect](#test_univariate) \n", + "- [4.4 Test for a multivariate effect](#test_multivariate) \n", + "\n", + "[Summary](#summary)\n", + "\n", + "[References](#references)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **1.\tSet parameters.** \n", + "\n", + "It is necessary to set various parameters that describe how the signal and the noise will be generated." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*1.1 Import necessary Python packages* " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "\n", + "from pathlib import Path\n", + "from brainiak.utils import fmrisim\n", + "import nibabel\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.ndimage as ndimage\n", + "import scipy.spatial.distance as sp_distance\n", + "import sklearn.manifold as manifold\n", + "import scipy.stats as stats\n", + "import sklearn.model_selection\n", + "import sklearn.svm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*1.2 Load participant data*\n", + "\n", + "Any 4 dimensional fMRI data that is readible by nibabel can be used as input to this pipeline. For this example, data is taken from the open access repository DataSpace: http://arks.princeton.edu/ark:/88435/dsp01dn39x4181. This file is unzipped and placed same directory as this notebook with the name Corr_MVPA " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "nii = nibabel.load('Corr_MVPA/Participant_01_rest_run01.nii')\n", + "volume = nii.get_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*1.3\tSpecify participant dimensions and resolution*\n", + "\n", + "The size of the volume and the resolution of the voxels must be specified (or extracted from the real data as is the case below)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Volume dimensions: (64, 64, 27, 294)\n", + "TR duration: 1.50s\n" + ] + } + ], + "source": [ + "dim = volume.shape # What is the size of the volume\n", + "dimsize = nii.header.get_zooms() # Get voxel dimensions from the nifti header\n", + "tr = dimsize[3]\n", + "if tr > 100: # If high then these values are likely in ms and so fix it\n", + " tr /= 1000\n", + "print('Volume dimensions:', dim)\n", + "print('TR duration: %0.2fs' % tr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*1.4 Generate an activity template and a mask*\n", + "\n", + "Functions in fmrisim require a continuous map that describes the appropriate average MR value for each voxel in the brain and a mask which specifies voxels in the brain versus voxels outside of the brain. One way to generate both of these volumes is the mask_brain function. At a minimum, this takes as an input the fMRI volume to be simulated. To create the template this volume is averaged over time and bounded to a range from 0 to 1. In other words, voxels with a high value in the template have high activity over time. To create a mask, the template is thresholded. This threshold can be set manually or instead an appropriate value can be determined by looking for the minima between the two first peaks in the histogram of voxel values. If you would prefer, you could use the [compute_epi_mask](http://nilearn.github.io/modules/generated/nilearn.masking.compute_epi_mask.html) function in nilearn which uses a similar method." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "mask, template = fmrisim.mask_brain(volume=volume, \n", + " mask_self=True,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*1.5 Determine noise parameters*\n", + "\n", + "A critical step in the fmrisim toolbox is determining the noise parameters of the volume to be created. Many noise parameters are available for specification and if any are not set then they will default to reasonable values. As mentioned before, it is instead possible to provide raw fMRI data that will be used to estimate these noise parameters. The goal of the noise estimation is to calculate general descriptive statistics about the noise in the brain that are thought to be important. The simulations are then useful for understanding how signals will survive analyses when embedded in realistic neural noise. \n", + "\n", + "Now the disclaimers: the values here are only an estimate and will depend on noise properties combining in the ways assumed. In addition, because of the non-linearity and stochasticity of this simulation, this estimation is not fully invertible: if you generate a dataset with a set of noise parameters it will have similar but not the same noise parameters as a result. Moreover, complex interactions between brain regions that likely better describe brain noise are not modelled here: this toolbox pays no attention to regions of the brain or their interactions. Finally, for best results use raw fMRI because if the data has been preprocessed then assumptions this algorithm makes are likely to be erroneous. For instance, if the brain has been masked then this will eliminate variance in non-brain voxels which will mean that calculations of noise dependent on those voxels as a reference will fail.\n", + "\n", + "To ameliorate some of these concerns, it is possible to fit the spatial and temporal noise properties of the data. This iterates over the noise generation process and tunes parameters in order to match those that are provided. This is time consuming (especially for fitting the temporal noise) but is helpful in matching the specified noise properties. \n", + "\n", + "This toolbox separates noise in two: spatial noise and temporal noise. To estimate spatial noise both the smoothness and the amount of non-brain noise of the data must be quantified. For smoothness, the Full Width Half Max (FWHM) of the volume is averaged for the X, Y and Z dimension and then averaged across a sample of time points. To calculate the Signal to Noise Ratio (SNR) the mean activity in brain voxels for the middle time point is divided by the standard deviation in activity across non-brain voxels for that time point. For temporal noise an auto-regressive and moving average (ARMA) process is estimated, along with the overall size of temporal variability. A sample of brain voxels is used to estimate the first AR component and the first MA component of each voxel's activity over time using the statsmodels package. The Signal to Fluctuation Noise Ratio (SFNR) is calculated by dividing the average activity of voxels in the brain with that voxel’s noise (Friedman & Glover, 2006). That noise is calculated by taking the standard deviation of that voxel over time after it has been detrended with a second order polynomial. The SFNR then controls the amount of functional variability. Other types of noise can be generated, such as physiological noise, but are not estimated by this function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Calculate the noise parameters from the data. Set it up to be matched.\n", + "noise_dict = {'voxel_size': [dimsize[0], dimsize[1], dimsize[2]], 'matched': 1}\n", + "noise_dict = fmrisim.calc_noise(volume=volume,\n", + " mask=mask,\n", + " template=template,\n", + " noise_dict=noise_dict,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Noise parameters of the data were estimated as follows:\n", + "SNR: 23.175648200023815\n", + "SFNR: 70.7171164884859\n", + "FWHM: 5.661164924881941\n" + ] + } + ], + "source": [ + "print('Noise parameters of the data were estimated as follows:')\n", + "print('SNR: ' + str(noise_dict['snr']))\n", + "print('SFNR: ' + str(noise_dict['sfnr']))\n", + "print('FWHM: ' + str(noise_dict['fwhm']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **2. Generate noise**\n", + "fmrisim can generate realistic fMRI noise when supplied with the appropriate inputs. A single function receives these inputs and deals with generating the noise. The necessary code to run this is in the next cell. For clarity, we walk through the steps of how this simulation is performed. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/cellis/anaconda/envs/brainiak_test/lib/python3.6/site-packages/scipy/stats/stats.py:2279: RuntimeWarning: divide by zero encountered in true_divide\n", + " np.expand_dims(sstd, axis=axis))\n", + "/Users/cellis/anaconda/envs/brainiak_test/lib/python3.6/site-packages/scipy/stats/stats.py:2279: RuntimeWarning: invalid value encountered in true_divide\n", + " np.expand_dims(sstd, axis=axis))\n" + ] + } + ], + "source": [ + "# Calculate the noise given the parameters\n", + "noise = fmrisim.generate_noise(dimensions=dim[0:3],\n", + " tr_duration=int(tr),\n", + " stimfunction_tr=[0] * dim[3], \n", + " mask=mask,\n", + " template=template,\n", + " noise_dict=noise_dict,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot spatial noise\n", + "low_spatial = fmrisim._generate_noise_spatial(dim[0:3],\n", + " fwhm=4.0,\n", + " )\n", + "\n", + "high_spatial = fmrisim._generate_noise_spatial(dim[0:3],\n", + " fwhm=1.0,\n", + " )\n", + "plt.figure()\n", + "plt.subplot(1,2,1)\n", + "plt.title('FWHM = 4.0')\n", + "plt.imshow(low_spatial[:, :, 12])\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.title('FWHM = 1.0')\n", + "plt.imshow(high_spatial[:, :, 12])\n", + "plt.axis('off')\n", + "\n", + "txt=\"Slices through the volume for different amounts of spatial noise. FWHM stands for full width half maximum, referencing the width of the Gaussian distribution used to simulate the data\"\n", + "plt.figtext(0.5, 0.01, txt, wrap=True, horizontalalignment='center', fontsize=12);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create the different types of noise\n", + "total_time = 500\n", + "timepoints = list(range(0, total_time, int(tr)))\n", + "\n", + "drift = fmrisim._generate_noise_temporal_drift(total_time,\n", + " int(tr),\n", + " )\n", + "\n", + "mini_dim = np.array([2, 2, 2])\n", + "autoreg = fmrisim._generate_noise_temporal_autoregression(timepoints,\n", + " noise_dict,\n", + " mini_dim,\n", + " np.ones(mini_dim),\n", + " )\n", + " \n", + "phys = fmrisim._generate_noise_temporal_phys(timepoints,\n", + " )\n", + "\n", + "stimfunc = np.zeros((int(total_time / tr), 1))\n", + "stimfunc[np.random.randint(0, int(total_time / tr), 50)] = 1\n", + "task = fmrisim._generate_noise_temporal_task(stimfunc,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Dilate the mask so as to only take voxels far from the brain (performed in calc_noise)\n", + "mask_dilated = ndimage.morphology.binary_dilation(mask, iterations=10)\n", + "\n", + "# Remove all non brain voxels\n", + "system_all = volume[mask_dilated == 0] # Pull out all the non brain voxels in the first TR\n", + "system_baseline = volume - (template.reshape(dim[0], dim[1], dim[2], 1) * noise_dict['max_activity']) # Subtract the baseline before masking\n", + "system_baseline = system_baseline[mask_dilated == 0]\n", + "\n", + "# Plot the distribution of voxels\n", + "plt.figure(figsize=(10,8))\n", + "plt.subplot(1, 3, 1)\n", + "plt.hist(system_all[:,0].flatten(),100)\n", + "plt.title('Non-brain distribution')\n", + "plt.xlabel('Activity')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Identify a subset of voxels to plot\n", + "idxs = list(range(system_all.shape[0]))\n", + "np.random.shuffle(idxs)\n", + "\n", + "temporal = system_all[idxs[:100], :100]\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(temporal)\n", + "plt.xticks([], [])\n", + "plt.yticks([], [])\n", + "plt.ylabel('voxel ID')\n", + "plt.xlabel('time')\n", + "plt.title('Voxel x time')\n", + "\n", + "# Plot the difference\n", + "ax=plt.subplot(1, 3, 3)\n", + "plt.hist(system_baseline[:,0].flatten(),100)\n", + "ax.yaxis.tick_right()\n", + "ax.yaxis.set_label_position(\"right\")\n", + "plt.title('Demeaned non-brain distribution')\n", + "plt.xlabel('Activity difference')\n", + "\n", + "txt=\"Histogram of non-brain voxel intensity. Left shows the raw intensity histogram, middle shows the voxel by time matrix (showing that there is variance in mean but not much in time) and then right shows the demeaned voxel intensity for the first time point.\"\n", + "plt.figtext(0.5, 0.01, txt, wrap=True, horizontalalignment='center', fontsize=10);\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*2.3 Combine noise and template*\n", + " \n", + "The template volume is used to estimate the appropriate baseline distribution of MR values. This estimate is then combined with the temporal noise and the system noise to make an estimate of the noise. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*2.4 Fit the data to the noise parameters*\n", + "\n", + "The generate_noise function does its best to estimate the appropriate noise parameters using assumptions about noise sources; however, because of the complexity of these different noise types, it is often wrong. To compensate, fitting is performed in which parameters involved in the noise generation process are changed and the noise metrics are recalculated to see whether those changes helped the fit. Due to their importance, the parameters that can be fit are SNR, SFNR and AR.\n", + "\n", + "The fitting of SNR/SFNR involves reweighting spatial and temporal metrics of noise. This analysis is relatively quick because this reweighting does not require that any timecourses are recreated, only that they are reweighted. At least 10 iterations are recommended because the initial guesses tend to underestimate SFNR and SNR (although the size of this error depends on the data). In the case of fitting the AR, the MA rho is adjusted until the AR is appropriate and in doing so the timecourse needs to be recreated for each iteration. In the noise_dict, one of the keys is 'matched' which is a binary value determining whether any fitting will be done\n", + "\n", + "In terms of timing, for a medium size dataset (64x64x27x300 voxels) it takes approximately 2 minutes to generate the data when fitting on a Mac 2014 laptop. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Compute the noise parameters for the simulated noise\n", + "noise_dict_sim = {'voxel_size': [dimsize[0], dimsize[1], dimsize[2]], 'matched': 1}\n", + "noise_dict_sim = fmrisim.calc_noise(volume=noise,\n", + " mask=mask,\n", + " template=template,\n", + " noise_dict=noise_dict_sim,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compare noise parameters for the real and simulated noise:\n", + "SNR: 23.18 vs 22.53\n", + "SFNR: 70.72 vs 69.19\n", + "FWHM: 5.66 vs 5.69\n", + "AR: 0.86 vs 0.84\n" + ] + } + ], + "source": [ + "print('Compare noise parameters for the real and simulated noise:')\n", + "print('SNR: %0.2f vs %0.2f' % (noise_dict['snr'], noise_dict_sim['snr']))\n", + "print('SFNR: %0.2f vs %0.2f' % (noise_dict['sfnr'], noise_dict_sim['sfnr']))\n", + "print('FWHM: %0.2f vs %0.2f' % (noise_dict['fwhm'], noise_dict_sim['fwhm']))\n", + "print('AR: %0.2f vs %0.2f' % (noise_dict['auto_reg_rho'][0], noise_dict_sim['auto_reg_rho'][0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **3. Generate signal**\n", + "\n", + "fmrisim can be used to generate signal in a number of different ways depending on the type of effect being simulated. Several tools are supplied to help with different types of signal that may be required; however, custom scripts may be necessary for unique effects. Below an experiment will be simulated in which two conditions, A and B, evoke different patterns of activity in the same set of voxels in the brain. This pattern does not manifest as a uniform change in activity across voxels but instead each condition evokes a consistent pattern across voxels. These conditions are randomly intermixed trial by trial. This code could be easily changed to instead compare univariate changes evoked by stimuli in different brain regions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.1 Specify which voxels in the brain contain signal*\n", + "\n", + "fmrisim provides tools to specify certain voxels in the brain that contain signal. The generate_signal function can produce regions of activity in a brain of different shapes, such as cubes, loops and spheres. Alternatively a volume could be loaded in that specifies the signal voxels (e.g. for ROIs from nilearn). The value of each voxel can be specified here, or set to be a random value." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create the region of activity where signal will appear\n", + "coordinates = np.array([[21, 21, 21]]) # Where in the brain is the signal\n", + "feature_size = 3 # How big, in voxels, is the size of the ROI\n", + "signal_volume = fmrisim.generate_signal(dimensions=dim[0:3],\n", + " feature_type=['cube'],\n", + " feature_coordinates=coordinates,\n", + " feature_size=[feature_size],\n", + " signal_magnitude=[1],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot pattern of activity for each condition\n", + "plt.figure()\n", + "plt.subplot(1,2,1)\n", + "plt.imshow(pattern_A)\n", + "plt.ylabel('Voxels')\n", + "plt.tick_params(which='both', left='off', labelleft='off', bottom='off', labelbottom='off')\n", + "plt.xticks([])\n", + "plt.xlabel('Condition A')\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.imshow(pattern_B)\n", + "plt.tick_params(which='both', left='off', labelleft='off', bottom='off', labelbottom='off')\n", + "plt.xticks([])\n", + "plt.xlabel('Condition B')\n", + "\n", + "txt=\"Randomly generated pattern that is used for simulating the response evoked by two different events\"\n", + "plt.figtext(0.5, 0.01, txt, wrap=True, horizontalalignment='center', fontsize=12);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.3 Generate event time course*\n", + "\n", + "generate_stimfunction can be used to specify the time points at which task stimulus events occur. The timing of events can be specified by describing the onset and duration of each event. Alternatively, it is possible to provide a path to a 3 column timing file, used by fMRI software packages like FSL, which specifies event onset, duration and weight. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set up stimulus event time course parameters\n", + "event_duration = 2 # How long is each event\n", + "isi = 7 # What is the time between each event\n", + "burn_in = 1 # How long before the first event\n", + "\n", + "total_time = int(dim[3] * tr) + burn_in # How long is the total event time course\n", + "events = int((total_time - ((event_duration + isi) * 2)) / ((event_duration + isi) * 2)) * 2 # How many events are there?\n", + "onsets_all = np.linspace(burn_in, events * (event_duration + isi), events) # Space the events out\n", + "np.random.shuffle(onsets_all) # Shuffle their order\n", + "onsets_A = onsets_all[:int(events / 2)] # Assign the first half of shuffled events to condition A\n", + "onsets_B = onsets_all[int(events / 2):] # Assign the second half of shuffled events to condition B\n", + "temporal_res = 10.0 # How many timepoints per second of the stim function are to be generated?" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a time course of events \n", + "stimfunc_A = fmrisim.generate_stimfunction(onsets=onsets_A,\n", + " event_durations=[event_duration],\n", + " total_time=total_time,\n", + " temporal_resolution=temporal_res,\n", + " )\n", + "\n", + "stimfunc_B = fmrisim.generate_stimfunction(onsets=onsets_B,\n", + " event_durations=[event_duration],\n", + " total_time=total_time,\n", + " temporal_resolution=temporal_res,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.4 Export stimulus time course for analysis*\n", + "\n", + "If a time course of events is generated, as is the case here, it may be useful to store this in a certain format for future analyses. The `export_3_column` function can be used to export the time course to be a three column (event onset, duration and weight) timing file that might readable to FSL. Alternatively, the export_epoch_file function can be used to export numpy files that are necessary inputs for MVPA and FCMA in BrainIAK.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fmrisim.export_epoch_file(stimfunction=[np.hstack((stimfunc_A, stimfunc_B))],\n", + " filename='epoch_file.npy',\n", + " tr_duration=tr,\n", + " temporal_resolution=temporal_res,\n", + " )\n", + "\n", + "fmrisim.export_3_column(stimfunction=stimfunc_A,\n", + " filename='Condition_A.txt',\n", + " temporal_resolution=temporal_res,\n", + " )\n", + "\n", + "fmrisim.export_3_column(stimfunction=stimfunc_B,\n", + " filename='Condition_B.txt',\n", + " temporal_resolution=temporal_res,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.5 Estimate the voxel weight for each event*\n", + "\n", + "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel’s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel’s response to signal over time." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Multiply each pattern by each voxel time course\n", + "weights_A = np.matlib.repmat(stimfunc_A, 1, voxels).transpose() * pattern_A\n", + "weights_B = np.matlib.repmat(stimfunc_B, 1, voxels).transpose() * pattern_B\n", + "\n", + "# Sum these time courses together\n", + "stimfunc_weighted = weights_A + weights_B\n", + "stimfunc_weighted = stimfunc_weighted.transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Prepare the data to be plotted\n", + "response = signal_func[0:100,0] * 2\n", + "downsample_A = stimfunc_A[0:int(100*temporal_res * tr):int(temporal_res * tr), 0]\n", + "downsample_B = stimfunc_B[0:int(100*temporal_res * tr):int(temporal_res * tr), 0]\n", + "\n", + "# Display signal\n", + "plt.figure(figsize=(5,6))\n", + "plt.title('Example event time course and voxel response')\n", + "Event_A = plt.plot(downsample_A, 'r', label='Event_A')\n", + "Event_B = plt.plot(downsample_B, 'g', label='Event_B')\n", + "Response = plt.plot(response, 'b', label='Response')\n", + "plt.legend(loc=1)\n", + "plt.yticks([],'')\n", + "plt.xlabel('nth TR')\n", + "\n", + "txt=\"A signal voxel's response convolved with a double-gamma HRF. Event types are also shown.\"\n", + "plt.figtext(0.5, 0.01, txt, wrap=True, horizontalalignment='center', fontsize=8);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.7 Establish signal magnitude*\n", + "\n", + "When specifying the signal we must determine the amount of activity change each voxel undergoes. fmrisim contains a tool to allow you to choose between a variety of different metrics that you could use to scale the signal. For instance, we can calculate percent signal change (referred to as PSC) by taking the average activity of a voxel in the noise volume and multiplying the maximal activation of the signal by a percentage of this number. This metric doesn't take into account the variance in the noise but other metrics in this tool do. One metric that does take account of variance, and is used below, is the signal amplitude divided by the temporal variability. The choices that are available for computing the signal scale are based on Welvaert and Rosseel (2013)." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Specify the parameters for signal\n", + "signal_method = 'CNR_Amp/Noise-SD'\n", + "signal_magnitude = [0.5]\n", + "\n", + "# Where in the brain are there stimulus evoked voxels\n", + "signal_idxs = np.where(signal_volume == 1)\n", + "\n", + "# Pull out the voxels corresponding to the noise volume\n", + "noise_func = noise[signal_idxs[0], signal_idxs[1], signal_idxs[2], :].T" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Compute the signal appropriate scaled\n", + "signal_func_scaled = fmrisim.compute_signal_change(signal_func,\n", + " noise_func,\n", + " noise_dict,\n", + " magnitude=signal_magnitude,\n", + " method=signal_method,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.8 Multiply the convolved response with the signal voxels*\n", + "\n", + "If you have a time course of simulated response for one or more voxels and a three dimensional volume representing voxels that ought to respond to these events then apply_signal will combine these appropriately. This function multiplies each signal voxel in the brain by the convolved event time course. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "signal = fmrisim.apply_signal(signal_func_scaled,\n", + " signal_volume,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*3.9 Combine signal and noise*\n", + "\n", + "Since the brain signal is expected to be small and sparse relative to the noise, it is assumed sufficient to simply add the volume containing signal with the volume modeling noise to make the simulated brain. " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "brain = signal + noise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **4. Analyse data**\n", + "\n", + "Several tools are available for multivariate analysis in BrainIAK. These greatly speed up computation and are critical in some cases, such as a whole brain searchlight. However, for this example data we will only look at data in the ROI that we know contains signal and so do not need these advanced tools optimized for whole-brain analyses." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*4.1 Pull out data for each trial*\n", + "\n", + "Identify which voxels are in the signal ROI by using the coordinates provided earlier. To identify the relevant timepoints, assume that the peak of the neural response occurs 4 - 6s after each event onset. Take the TR corresponding to this peak response as the TR for that trial. In longer event/block designs you might instead average over each event." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "hrf_lag = 4 # Assumed time from stimulus onset to HRF peak\n", + "\n", + "# Get the lower and upper bounds of the ROI\n", + "lb = (coordinates - ((feature_size - 1) / 2)).astype('int')[0]\n", + "ub = (coordinates + ((feature_size - 1) / 2) + 1).astype('int')[0]\n", + "\n", + "# Pull out voxels in the ROI for the specified timepoints\n", + "trials_A = brain[lb[0]:ub[0], lb[1]:ub[1], lb[2]:ub[2], ((onsets_A + hrf_lag) / tr).astype('int')]\n", + "trials_B = brain[lb[0]:ub[0], lb[1]:ub[1], lb[2]:ub[2], ((onsets_B + hrf_lag) / tr).astype('int')]\n", + "\n", + "# Reshape data for easy handling\n", + "trials_A = trials_A.reshape((voxels, trials_A.shape[3]))\n", + "trials_B = trials_B.reshape((voxels, trials_B.shape[3]))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the distance matrix between trial types\n", + "distance_matrix = sp_distance.squareform(sp_distance.pdist(np.vstack([trials_A.transpose(), trials_B.transpose()])))\n", + "\n", + "mds = manifold.MDS(n_components=2, dissimilarity='precomputed') # Fit the mds object\n", + "coords = mds.fit(distance_matrix).embedding_ # Find the mds coordinates\n", + "\n", + "# Plot the data\n", + "plt.figure()\n", + "plt.scatter(coords[:, 0], coords[:, 1], c=['red'] * trials_A.shape[1] + ['green'] * trials_B.shape[1])\n", + "plt.axis('off')\n", + "plt.title('Low Dimensional Representation of conditions A and B')\n", + "\n", + "txt=\"Low dimensional representation of the two conditions. Different colors refer to different conditions\"\n", + "plt.figtext(0.5, 0.01, txt, wrap=True, horizontalalignment='center', fontsize=12);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*4.3 Test for univariate effect*\n", + "\n", + "Do a t test to compare the means of the voxels between these two conditions to determine if there is a difference" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean difference between condition A and B: 3.14\n", + "p value: 0.229\n" + ] + } + ], + "source": [ + "mean_difference = (np.mean(trials_A,0) - np.mean(trials_B,0))\n", + "ttest = stats.ttest_1samp(mean_difference, 0)\n", + "\n", + "print('Mean difference between condition A and B: %0.2f\\np value: %0.3f' % (mean_difference.mean(), ttest.pvalue))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*4.4 Test for a multivariate effect*\n", + "\n", + "Use SVM from scikit-learn to estimate the classification accuracy between the conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classification accuracy between condition A and B: 0.700\n" + ] + } + ], + "source": [ + "# Get the inputs to the SVM\n", + "input_mat = np.vstack([trials_A.transpose(), trials_B.transpose()])\n", + "input_labels = trials_A.shape[1] * [1] + trials_B.shape[1] * [0]\n", + "\n", + "# Set up the classifier\n", + "X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(\n", + " input_mat, input_labels, test_size=0.2, random_state=0)\n", + "\n", + "clf = sklearn.svm.SVC(kernel='linear', C=1, gamma='auto').fit(X_train, y_train)\n", + "\n", + "score = clf.score(X_test, y_test)\n", + "print('Classification accuracy between condition A and B: %0.3f' % score)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "Using fmrisim we were able to take in raw data and create a simulation with matched noise properties. This simulated data was used for designing an example experiment time course for a two condition event-related design, such as a localizer task.\n", + "\n", + "fmrisim can be used to optimize experimental design parameters (e.g., what is the best ISI given the time constraints of the experiment) and to pre-register an experiment preprocessing pipeline. \n", + "\n", + "More resources and examples of fmrisim usage can be found here: `brainiak/utils`, also please checkout thereferences below for published examples of fmrisim." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### **References**\n", + "\n", + "*References using fmrisim:*\n", + "\n", + "Ellis, C. T., Baldassano, C., Schapiro, A. C., Cai, M. B., Cohen, J. D. (2020). Facilitating open-science with realistic fMRI simulation: validation and application. PeerJ 8:e8564\n", + "\n", + "Ellis, C. T., Lesnick, M., Henselman-Petrusek, G., Keller, B., & Cohen, J. D. (2019). Feasibility of topological data analysis for event-related fMRI, Network Neuroscience, 1-12\n", + "\n", + "Kumar, S., Ellis, C., O'Connell, T. P., Chun, M. M., & Turk-Browne, N. B. (in press). Searching through functional space reveals distributed visual, auditory, and semantic coding in the human brain. PLoS Computational Biology\n", + "\n", + "\n", + "*References mentioned in this notebook:*\n", + "\n", + "Biswal, B., et al. (1996) Reduction of physiological fluctuations in fMRI using digital filters. Magnetic Resonance in Medicine 35, 107-113\n", + "\n", + "Friedman, L. and Glover, G.H. (2006) Report on a multicenter fMRI quality assurance protocol. Journal of Magnetic Resonance Imaging 23, 827-839\n", + "\n", + "Friston, K.J., et al. (1998) Event-related fMRI: characterizing differential responses. Neuroimage 7, 30-40\n", + "\n", + "Gudbjartsson, H. and Patz, S. (1995) The Rician distribution of noisy MRI data. Magnetic resonance in medicine 34, 910-914\n", + "\n", + "Welvaert, M., et al. (2011) neuRosim: An R package for generating fMRI data. Journal of Statistical Software 44, 1-18\n", + "\n", + "Welvaert, M., & Rosseel, Y. (2013). On the definition of signal-to-noise ratio and contrast-to-noise ratio for fMRI data. PloS one, 8(11), e77089.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.1" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/examples/htfa/Dockerfile b/docs/examples/htfa/Dockerfile new file mode 100644 index 00000000..ab1ae887 --- /dev/null +++ b/docs/examples/htfa/Dockerfile @@ -0,0 +1,53 @@ +FROM contextlab/cdl-jupyter:3.7 + +LABEL maintainer="Paxton Fitzpatrick " + +ARG PORT=8888 + +ENV NOTEBOOK_PORT $PORT + +RUN apt-get update --fix-missing \ + && eatmydata apt-get install -y --no-install-recommends \ + g++ \ + git \ + unzip \ + && apt-get clean \ + && rm -rf /var/lib/apt/lists/* \ + && conda install -Sy \ + bokeh=2.2.2 \ + ffmpeg=4.3.1 \ + h5py=2.10.0 \ + holoviews=1.13.4 \ + ipykernel=5.3.4 \ + mpi=1.0=mpich \ + mpi4py=3.0.3 \ + mpich=3.3.2 \ + nbclient=0.5.0 \ + nibabel=3.1.1 \ + nilearn=0.7.1 \ + notebook=6.1.6 \ + numpy=1.19.2 \ + pandas=1.1.3 \ + panel=0.9.7 \ + param=1.9.3 \ + pyviz_comms=0.7.6 \ + scikit-learn=0.21.3 \ + scipy=1.5.2 \ + seaborn=0.11.0 \ + tornado=6.0.4 \ + && conda clean -afy \ + && pip install \ + timecorr==0.1.5 \ + nltools==0.4.2 \ + git+https://github.com/ContextLab/hypertools.git@3f45375682a8f12a1278dd1720290d75a50062a9 \ + git+https://github.com/brainiak/brainiak.git@938151acff10cf49954f2c9933278de327b9da9d \ + && rm -rf ~/.cache/pip \ + && mkdir /data \ + && wget --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate -q \ + "https://docs.google.com/uc?export=download&id=1IBA39ZZjeGS1u_DvZdiw1AZZQMS3K5q0" -O- \ + | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p' > /tmp/confirm \ + && wget --load-cookies /tmp/cookies.txt --no-check-certificate -q \ + "https://docs.google.com/uc?export=download&confirm="$(cat /tmp/confirm)"&id=1IBA39ZZjeGS1u_DvZdiw1AZZQMS3K5q0" -O /data/pieman.zip \ + && rm /tmp/cookies.txt /tmp/confirm \ + && unzip /data/pieman.zip -d /data/ \ + && rm /data/pieman.zip diff --git a/docs/examples/htfa/download_data.sh b/docs/examples/htfa/download_data.sh new file mode 100644 index 00000000..e2748834 --- /dev/null +++ b/docs/examples/htfa/download_data.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +if [ -d "data/" ]; then + echo "Skipping download of data for HTFA notebook, already present" +else + mkdir data + wget --save-cookies cookies.txt --keep-session-cookies --no-check-certificate -q \ + "https://docs.google.com/uc?export=download&id=1IBA39ZZjeGS1u_DvZdiw1AZZQMS3K5q0" -O- \ + | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p' > confirm + wget --load-cookies cookies.txt --no-check-certificate -q \ + "https://docs.google.com/uc?export=download&confirm="$(cat confirm)"&id=1IBA39ZZjeGS1u_DvZdiw1AZZQMS3K5q0" -O data/pieman.zip + rm cookies.txt confirm + unzip data/pieman.zip -d data/ + rm data/pieman.zip +fi + diff --git a/docs/examples/htfa/helpers.py b/docs/examples/htfa/helpers.py new file mode 100644 index 00000000..87ab3ebf --- /dev/null +++ b/docs/examples/htfa/helpers.py @@ -0,0 +1,327 @@ +import numpy as np +import pandas as pd +import nibabel as nib +import nilearn as nl +from nilearn.input_data import NiftiMasker +import nilearn.plotting as niplot +import matplotlib as mlab +import matplotlib.pyplot as plt +import holoviews as hv +import timecorr as tc +import os +from brainiak.factoranalysis.htfa import HTFA +import warnings +import seaborn as sns + +hv.extension('bokeh') +hv.output(size=200) + +def opts(debug=False): + ''' + Return a dictionary of parameters to pass to + brainiak.factoranalysis.htfa.HTFA + + inputs: + debug: set to True (default) to generate a quick test fit and False to + generate a (slower) more accurate fit. + ''' + if debug: + return {'K': 10, + 'max_global_iter': 3, + 'max_local_iter': 3, + 'voxel_ratio': 0.1, + 'tr_ratio': 0.1, + 'max_voxel_scale': 0.1, + 'max_tr_scale': 0.1, + 'verbose': True} + else: + return {'K': 50, + 'max_global_iter': 10, + 'max_local_iter': 5, + 'voxel_ratio': 0.1, + 'tr_ratio': 0.1, + 'max_voxel_scale': 0.25, + 'max_tr_scale': 0.25, + 'verbose': True} + +def opts2str(params): + ''' + convert params to filename + ''' + return str(params).replace('{', '').replace('}', '').replace("'", '').replace(': ', '-').replace(', ', '_') + +def htfa2dict(htfa): + ''' + turn htfa object into a pickleable dictionary + ''' + return {'K': htfa.K, # init params + 'n_subj': htfa.n_subj, + 'max_global_iter': htfa.max_global_iter, + 'max_local_iter': htfa.max_local_iter, + 'threshold': htfa.threshold, + 'nlss_method': htfa.nlss_method, + 'nlss_loss': htfa.nlss_loss, + 'jac': htfa.jac, + 'x_scale': htfa.x_scale, + 'tr_solver': htfa.tr_solver, + 'weight_method': htfa.weight_method, + 'upper_ratio': htfa.upper_ratio, + 'lower_ratio': htfa.lower_ratio, + 'tr_ratio': htfa.tr_ratio, + 'voxel_ratio': htfa.voxel_ratio, + 'max_voxel': htfa.max_voxel, + 'max_tr': htfa.max_tr, + 'verbose': htfa.verbose, + 'prior_bcast_size': htfa.prior_bcast_size, + 'prior_size': htfa.prior_size, + 'local_posterior_': htfa.local_posterior_, # inferred params + 'local_weights_': htfa.local_weights_, + 'global_centers_cov_': htfa.global_centers_cov, + 'global_centers_cov_scaled': htfa.global_centers_cov_scaled, + 'global_posterior_': htfa.global_posterior_, + 'global_prior_': htfa.global_prior_, + 'global_widths_var': htfa.global_widths_var, + 'global_widths_var_scaled': htfa.global_widths_var_scaled, + 'map_offset': htfa.map_offset, + 'n_dim': htfa.n_dim + } + + +def dict2htfa(htfa_dict): + htfa = HTFA(K=htfa_dict['K'], + n_subj=htfa_dict['n_subj'], + max_voxel=htfa_dict['max_voxel'], + max_tr=htfa_dict['max_tr'], + verbose=False) + for k in htfa_dict.keys(): + setattr(htfa, k, htfa_dict[k]) + return htfa + +def global_params(htfa): + centers = htfa.get_centers(htfa.global_posterior_) + widths = htfa.get_widths(htfa.global_posterior_) + return centers, widths + +def local_params(htfa, n_timepoints): + centers = [htfa.get_centers(x) for x in np.array_split(htfa.local_posterior_, htfa.n_subj)] + widths = [htfa.get_widths(x) for x in np.array_split(htfa.local_posterior_, htfa.n_subj)] + + inds = np.hstack([0, np.cumsum(np.multiply(htfa.K, n_timepoints))]) + weights = [htfa.local_weights_[inds[i]:inds[i+1]].reshape([htfa.K, + n_timepoints[i]]).T for i in np.arange(htfa.n_subj)] + return centers, widths, weights + +def plot_nodes(htfa, n_timepoints, cmap='Spectral', global_scale=100, local_scale=25): + colors = np.repeat(np.vstack([[0, 0, 0], sns.color_palette(cmap, htfa.n_subj)]), htfa.K, axis=0) + colors = [colors[i, :] for i in range(colors.shape[0])] # make colors into a list + + global_centers, global_widths = global_params(htfa) + local_centers, local_widths, _ = local_params(htfa, n_timepoints) + + centers = np.vstack([global_centers, np.vstack(local_centers)]) + widths = np.vstack([global_widths, np.vstack(local_widths)]) + widths /= np.max(widths) + + scales = np.repeat(np.hstack([np.array(global_scale), np.array(htfa.n_subj*[local_scale])]), htfa.K) + sizes = widths.T * scales + return nl.plotting.plot_connectome(np.eye(htfa.K * (1 + htfa.n_subj)), centers, node_color=colors, node_size=sizes) + + +def nii2cmu(nifti_file, mask_file=None): + ''' + inputs: + nifti_file: a filename of a .nii or .nii.gz file to be converted into + CMU format + + mask_file: a filename of a .nii or .nii.gz file to be used as a mask; all + zero-valued voxels in the mask will be ignored in the CMU- + formatted output. If ignored or set to None, no voxels will + be masked out. + + outputs: + Y: a number-of-timepoints by number-of-voxels numpy array containing the + image data. Each row of Y is an fMRI volume in the original nifti + file. + + R: a number-of-voxels by 3 numpy array containing the voxel locations. + Row indices of R match the column indices in Y. + ''' + def fullfact(dims): + ''' + Replicates MATLAB's fullfact function (behaves the same way) + ''' + vals = np.asmatrix(range(1, dims[0] + 1)).T + if len(dims) == 1: + return vals + else: + aftervals = np.asmatrix(fullfact(dims[1:])) + inds = np.asmatrix(np.zeros((np.prod(dims), len(dims)))) + row = 0 + for i in range(aftervals.shape[0]): + inds[row:(row + len(vals)), 0] = vals + inds[row:(row + len(vals)), 1:] = np.tile(aftervals[i, :], (len(vals), 1)) + row += len(vals) + return inds + + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + + img = nib.load(nifti_file) + mask = NiftiMasker(mask_strategy='background') + if mask_file is None: + mask.fit(nifti_file) + else: + mask.fit(mask_file) + + hdr = img.header + S = img.get_sform() + vox_size = hdr.get_zooms() + im_size = img.shape + + if len(img.shape) > 3: + N = img.shape[3] + else: + N = 1 + + Y = np.float32(mask.transform(nifti_file)).copy() + vmask = np.nonzero(np.array(np.reshape(mask.mask_img_.dataobj, (1, np.prod(mask.mask_img_.shape)), order='C')))[1] + vox_coords = fullfact(img.shape[0:3])[vmask, ::-1]-1 + + R = np.array(np.dot(vox_coords, S[0:3, 0:3])) + S[:3, 3] + + return {'Y': Y, 'R': R} + +def cmu2nii(Y, R, template=None): + ''' + inputs: + Y: a number-of-timepoints by number-of-voxels numpy array containing the + image data. Each row of Y is an fMRI volume in the original nifti + file. + + R: a number-of-voxels by 3 numpy array containing the voxel locations. + Row indices of R match the column indices in Y. + + template: a filename of a .nii or .nii.gz file to be used as an image + template. Header information of the outputted nifti images will + be read from the header file. If this argument is ignored or + set to None, header information will be inferred based on the + R array. + + outputs: + nifti_file: a filename of a .nii or .nii.gz file to be converted into + CMU format + + mask_file: a filename for a .nii or .nii.gz file to be used as a mask; all + zero-valued voxels in the mask will be ignored in the CMU- + formatted output + + outputs: + img: a nibabel Nifti1Image object containing the fMRI data + ''' + Y = np.array(Y, ndmin=2) + img = nib.load(template) + S = img.affine + locs = np.array(np.dot(R - S[:3, 3], np.linalg.inv(S[0:3, 0:3])), dtype='int') + + data = np.zeros(tuple(list(img.shape)[0:3]+[Y.shape[0]])) + + # loop over data and locations to fill in activations + for i in range(Y.shape[0]): + for j in range(R.shape[0]): + data[locs[j, 0], locs[j, 1], locs[j, 2], i] = Y[i, j] + + return nib.Nifti1Image(data, affine=img.affine) + +def animate_connectome(nodes, connectomes, cthresh='75%', figdir='frames', force_refresh=False): #move to helpers + ''' + inputs: + nodes: a K by 3 array of node center locations + + connectomes: a T by [((K^2 - K)/2) + K] array of per-timepoint connectomes. + Each timepoint's connectime is represented in a vectorized + format *including the diagonal* (i.e., self connections). + + figdir: where to save temporary files and final output + + force_refresh: if True, overwrite existing temporary files. If False, + re-use existing temporary files and generate only the + temporary files that do not yet exist. + + outputs: + ani: a matplotlib FuncAnimation object + ''' + + if not os.path.exists(figdir): + os.makedirs(figdir) + + #save a jpg file for each frame (this takes a while, so don't re-do already made images) + def get_frame(t, fname): + if force_refresh or not os.path.exists(fname): + nl.plotting.plot_connectome(tc.vec2mat(connectomes[t, :]), + nodes, + node_color='k', + edge_threshold=cthresh, + output_file=fname) + + timepoints = np.arange(connectomes.shape[0]) + fnames = [os.path.join(figdir, str(t) + '.jpg') for t in timepoints] + tmp = [get_frame(t, f) for t, f in zip(timepoints, fnames)] + + #create a movie frame from each of the images we just made + fig = plt.figure() + + def get_im(fname): + #print(fname) + plt.axis('off') + return plt.imshow(plt.imread(fname), animated=True) + + ani = mlab.animation.FuncAnimation(fig, get_im, fnames, interval=50) + return ani + + +def mat2chord(connectome, cthresh=0.05): + ''' + inputs: + connectome: K by K connectivity matrix + + cthresh: only show connections in the top (cthresh*100)%; default = 0.25 + + outputs: + chord: a holoviews.Chord object displaying the connectome as a chord + diagram + ''' + + def mat2links(x, ids): + links = [] + for i in range(x.shape[0]): + for j in range(i): + links.append({'source': ids[i], 'target': ids[j], 'value': np.abs(x[i, j]), 'sign': np.sign(x[i, j])}) + return pd.DataFrame(links) + + K = connectome.shape[0] + nodes = pd.DataFrame({'ID': range(K), 'Name': [f'Node {i}' for i in range(K)]}) + + links = mat2links(connectome, nodes['ID']) + chord = hv.Chord((links, hv.Dataset(nodes, 'ID'))).select(value=(cthresh, None)) + chord.opts( + hv.opts.Chord(cmap='Category20', edge_cmap='Category20', edge_color=hv.dim('source').str(), labels='Name', node_color=hv.dim('ID').str()) + ) + return chord + +def animate_chord(x, cthresh=0.05): + ''' + inputs: + connectomes: a T by [((K^2 - K)/2) + K] array of per-timepoint connectomes. + Each timepoint's connectime is represented in a vectorized + format *including the diagonal* (i.e., self connections). + + cthresh: only show connections in the top (cthresh*100)%; default = 0.25 + + outputs: + hmap: a holoviews.HoloMap object containing an interactive animation + ''' + warnings.simplefilter('ignore') #suppress BokehUserWarning for node colors + + hv.output(max_frames=x.shape[0]) + renderer = hv.renderer('bokeh') + return hv.HoloMap({t: mat2chord(tc.vec2mat(x[t, :]), cthresh=cthresh) for t in range(x.shape[0])}, kdims='Time (TRs)') \ No newline at end of file diff --git a/docs/examples/htfa/htfa.ipynb b/docs/examples/htfa/htfa.ipynb new file mode 100644 index 00000000..c84c17bd --- /dev/null +++ b/docs/examples/htfa/htfa.ipynb @@ -0,0 +1,2772 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hierarchical Topographic Factor Analysis\n", + "By Jeremy R. Manning ([jeremy.r.manning@dartmouth.edu](mailto:jeremy.r.manning@dartmouth.edu)) and Paxton C. Fitzpatrick ([Paxton.C.Fitzpatrick@dartmouth.edu](mailto:Paxton.C.Fitzpatrick@dartmouth.edu))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "In this demonstration, we'll be using the [BrainIAK](https://brainiak.org/) Python toolbox to apply [Hierarchical Topographic Factor Analysis (HTFA)](https://www.sciencedirect.com/science/article/abs/pii/S1053811918300715) to an fMRI dataset.\n", + "\n", + "The demo will comprise three main steps:\n", + "1. Apply HTFA to the dataset to discover a basis set of network \"nodes\"\n", + "2. Apply a [dynamic correlation model](https://www.biorxiv.org/content/10.1101/763821v1.full.pdf) to the HTFA fits to characterize the network dynamics\n", + "3. Visualize the network dynamics in two ways:\n", + " - An animated [chord diagram](https://en.wikipedia.org/wiki/Chord_diagram)\n", + " - An animated brain plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Annotated bibliography\n", + "\n", + "1. Manning JR, Ranganath R, Norman KA, Blei DM (2014). Topographic Factor Analysis: a Bayesian model for inferring brain networks from neural data. *PLoS One*, 9(5): e94914. [link](https://doi.org/10.1371/journal.pone.0094914) *Describes a single-subject model (TFA) for inferring brain network hubs and applies it to a semantic decoding dataset.*\n", + "\n", + "2. Manning JR, Zhu X, Willke TL, Ranganath R, Stachenfeld K, Hasson U, Blei DM, Norman KA (2018). A probabilistic approach to discovering dynamic full-brain functional connectivity patterns. *NeuroImage*, 180: 243-252. [link](https://www.sciencedirect.com/science/article/abs/pii/S1053811918300715) *Describes a multi-subject (hierarchical) model (HTFA) for inferring shared brain network hubs and applies it to a story listening and movie viewing dataset.*\n", + "\n", + "3. Owen LLW, Chang TH, Manning JR (2020). High-level cognition during story listening is reflected in high-order dynamic correlations in neural activity patterns. *bioRxiv.* [link](https://www.biorxiv.org/content/10.1101/763821v2.full.pdf) *Describes a model for inferring network dynamics from timeseries data and applies it to HTFA fits to a story listening dataset.*\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of contents:\n", + "- [Overview](#Overview)\n", + "- [Getting started](#Getting-started)\n", + "- [Code](#Code)\n", + " - [Initialization](#Initialization)\n", + " - [Fit HTFA to data](#Fit-HTFA-to-data)\n", + " - [Plotting HTFA global and local node locations](#Plotting-HTFA-global-and-local-node-locations)\n", + " - [Compute dynamic correlations](#Compute-dynamic-correlations)\n", + " - [Generate animated chord diagrams](#Generate-animated-chord-diagrams)\n", + " - [Generate animated brain network plots](#Generate-animated-brain-network-plots)\n", + "- [Summary](#Summary)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting started\n", + "\n", + "The easiest way to run this notebook is to download and install [Docker](https://www.docker.com/) on your local machine, and then build the Docker image in this folder. That will install the necessary toolboxes and dependencies, and will also download the data you'll be analyzing. Follow the [instructions for your platform](https://www.docker.com/) to download and install Docker, and then start the Docker Desktop application.\n", + "\n", + "After you've installed Docker, to build the docker image, just navigate to this folder and run:\n", + "```\n", + "docker build --rm --force-rm -t htfa .\n", + "```\n", + "\n", + "To start the image for the first time, run:\n", + "```\n", + "docker run -it -p 8888:8888 --name htfa -v $PWD:/mnt htfa\n", + "```\n", + "and on subsequent times, run:\n", + "```\n", + "docker start htfa && docker attach htfa\n", + "```\n", + "\n", + "When the docker image is started, it will automatically start a Jupyter notebook server. Copy and paste the *third* link into a browser to interact with this notebook.\n", + "\n", + "To stop running the container, run:\n", + "```\n", + "docker stop htfa\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code\n", + "\n", + "Run the cells below (in sequence) to load in the example dataset, fit HTFA to the data, and visualize the resulting network dynamics." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization\n", + "\n", + "Import libraries and helper functions and load the [dataset](https://drive.google.com/open?id=1IBA39ZZjeGS1u_DvZdiw1AZZQMS3K5q0). The dataset we'll be analyzing is a subset of the story listening dataset collected by [Simony et al. (2016)](https://www.nature.com/articles/ncomms12141)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + "\n", + " if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n", + " root._bokeh_onload_callbacks = [];\n", + " root._bokeh_is_loading = undefined;\n", + " }\n", + "\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls.length === 0 && js_modules.length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length;\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", + " \n", + " }\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " if (skip.indexOf(url) >= 0) { on_load(); continue; }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (var i = 0; i < js_modules.length; i++) {\n", + " var url = js_modules[i];\n", + " if (skip.indexOf(url) >= 0) { on_load(); continue; }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [];\n", + " var js_modules = [];\n", + " var css_urls = [];\n", + " var inline_js = [\n", + " function(Bokeh) {\n", + " inject_raw_css(\".bk.alert {\\n padding: 0.75rem 1.25rem;\\n border: 1px solid transparent;\\n border-radius: 0.25rem;\\n /* Don't set margin because that will not render correctly! */\\n /* margin-bottom: 1rem; */\\n margin-top: 15px;\\n margin-bottom: 15px;\\n}\\n.bk.alert a {\\n color: rgb(11, 46, 19); /* #002752; */\\n font-weight: 700;\\n text-decoration: rgb(11, 46, 19);\\n text-decoration-color: rgb(11, 46, 19);\\n text-decoration-line: none;\\n text-decoration-style: solid;\\n text-decoration-thickness: auto;\\n }\\n.bk.alert a:hover {\\n color: rgb(11, 46, 19);\\n font-weight: 700;\\n text-decoration: underline;\\n}\\n\\n.bk.alert-primary {\\n color: #004085;\\n background-color: #cce5ff;\\n border-color: #b8daff;\\n}\\n.bk.alert-primary hr {\\n border-top-color: #9fcdff;\\n}\\n\\n.bk.alert-secondary {\\n color: #383d41;\\n background-color: #e2e3e5;\\n border-color: #d6d8db;\\n }\\n.bk.alert-secondary hr {\\n border-top-color: #c8cbcf;\\n}\\n\\n.bk.alert-success {\\n color: #155724;\\n background-color: #d4edda;\\n border-color: #c3e6cb;\\n }\\n\\n.bk.alert-success hr {\\n border-top-color: #b1dfbb;\\n}\\n\\n.bk.alert-info {\\n color: #0c5460;\\n background-color: #d1ecf1;\\n border-color: #bee5eb;\\n }\\n.bk.alert-info hr {\\n border-top-color: #abdde5;\\n}\\n\\n.bk.alert-warning {\\n color: #856404;\\n background-color: #fff3cd;\\n border-color: #ffeeba;\\n }\\n\\n.bk.alert-warning hr {\\n border-top-color: #ffe8a1;\\n}\\n\\n.bk.alert-danger {\\n color: #721c24;\\n background-color: #f8d7da;\\n border-color: #f5c6cb;\\n}\\n.bk.alert-danger hr {\\n border-top-color: #f1b0b7;\\n}\\n\\n.bk.alert-light {\\n color: #818182;\\n background-color: #fefefe;\\n border-color: #fdfdfe;\\n }\\n.bk.alert-light hr {\\n border-top-color: #ececf6;\\n}\\n\\n.bk.alert-dark {\\n color: #1b1e21;\\n background-color: #d6d8d9;\\n border-color: #c6c8ca;\\n }\\n.bk.alert-dark hr {\\n border-top-color: #b9bbbe;\\n}\\n\\n\\n/* adjf\\u00e6l */\\n\\n.bk.alert-primary a {\\n color: #002752;\\n}\\n\\n.bk.alert-secondary a {\\n color: #202326;\\n}\\n\\n\\n.bk.alert-success a {\\n color: #0b2e13;\\n}\\n\\n\\n.bk.alert-info a {\\n color: #062c33;\\n}\\n\\n\\n.bk.alert-warning a {\\n color: #533f03;\\n}\\n\\n\\n.bk.alert-danger a {\\n color: #491217;\\n}\\n\\n.bk.alert-light a {\\n color: #686868;\\n}\\n\\n.bk.alert-dark a {\\n color: #040505;\\n}\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\".json-formatter-row {\\n font-family: monospace;\\n}\\n.json-formatter-row,\\n.json-formatter-row a,\\n.json-formatter-row a:hover {\\n color: black;\\n text-decoration: none;\\n}\\n.json-formatter-row .json-formatter-row {\\n margin-left: 1rem;\\n}\\n.json-formatter-row .json-formatter-children.json-formatter-empty {\\n opacity: 0.5;\\n margin-left: 1rem;\\n}\\n.json-formatter-row .json-formatter-children.json-formatter-empty:after {\\n display: none;\\n}\\n.json-formatter-row .json-formatter-children.json-formatter-empty.json-formatter-object:after {\\n content: \\\"No properties\\\";\\n}\\n.json-formatter-row .json-formatter-children.json-formatter-empty.json-formatter-array:after {\\n content: \\\"[]\\\";\\n}\\n.json-formatter-row .json-formatter-string,\\n.json-formatter-row .json-formatter-stringifiable {\\n color: green;\\n white-space: pre;\\n word-wrap: break-word;\\n}\\n.json-formatter-row .json-formatter-number {\\n color: blue;\\n}\\n.json-formatter-row .json-formatter-boolean {\\n color: red;\\n}\\n.json-formatter-row .json-formatter-null {\\n color: #855A00;\\n}\\n.json-formatter-row .json-formatter-undefined {\\n color: #ca0b69;\\n}\\n.json-formatter-row .json-formatter-function {\\n color: #FF20ED;\\n}\\n.json-formatter-row .json-formatter-date {\\n background-color: rgba(0, 0, 0, 0.05);\\n}\\n.json-formatter-row .json-formatter-url {\\n text-decoration: underline;\\n color: blue;\\n cursor: pointer;\\n}\\n.json-formatter-row .json-formatter-bracket {\\n color: blue;\\n}\\n.json-formatter-row .json-formatter-key {\\n color: #00008B;\\n padding-right: 0.2rem;\\n}\\n.json-formatter-row .json-formatter-toggler-link {\\n cursor: pointer;\\n}\\n.json-formatter-row .json-formatter-toggler {\\n line-height: 1.2rem;\\n font-size: 0.7rem;\\n vertical-align: middle;\\n opacity: 0.6;\\n cursor: pointer;\\n padding-right: 0.2rem;\\n}\\n.json-formatter-row .json-formatter-toggler:after {\\n display: inline-block;\\n transition: transform 100ms ease-in;\\n content: \\\"\\\\25BA\\\";\\n}\\n.json-formatter-row > a > .json-formatter-preview-text {\\n opacity: 0;\\n transition: opacity 0.15s ease-in;\\n font-style: italic;\\n}\\n.json-formatter-row:hover > a > .json-formatter-preview-text {\\n opacity: 0.6;\\n}\\n.json-formatter-row.json-formatter-open > .json-formatter-toggler-link .json-formatter-toggler:after {\\n transform: rotate(90deg);\\n}\\n.json-formatter-row.json-formatter-open > .json-formatter-children:after {\\n display: inline-block;\\n}\\n.json-formatter-row.json-formatter-open > a > .json-formatter-preview-text {\\n display: none;\\n}\\n.json-formatter-row.json-formatter-open.json-formatter-empty:after {\\n display: block;\\n}\\n.json-formatter-dark.json-formatter-row {\\n font-family: monospace;\\n}\\n.json-formatter-dark.json-formatter-row,\\n.json-formatter-dark.json-formatter-row a,\\n.json-formatter-dark.json-formatter-row a:hover {\\n color: white;\\n text-decoration: none;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-row {\\n margin-left: 1rem;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-children.json-formatter-empty {\\n opacity: 0.5;\\n margin-left: 1rem;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-children.json-formatter-empty:after {\\n display: none;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-children.json-formatter-empty.json-formatter-object:after {\\n content: \\\"No properties\\\";\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-children.json-formatter-empty.json-formatter-array:after {\\n content: \\\"[]\\\";\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-string,\\n.json-formatter-dark.json-formatter-row .json-formatter-stringifiable {\\n color: #31F031;\\n white-space: pre;\\n word-wrap: break-word;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-number {\\n color: #66C2FF;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-boolean {\\n color: #EC4242;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-null {\\n color: #EEC97D;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-undefined {\\n color: #ef8fbe;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-function {\\n color: #FD48CB;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-date {\\n background-color: rgba(255, 255, 255, 0.05);\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-url {\\n text-decoration: underline;\\n color: #027BFF;\\n cursor: pointer;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-bracket {\\n color: #9494FF;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-key {\\n color: #23A0DB;\\n padding-right: 0.2rem;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-toggler-link {\\n cursor: pointer;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-toggler {\\n line-height: 1.2rem;\\n font-size: 0.7rem;\\n vertical-align: middle;\\n opacity: 0.6;\\n cursor: pointer;\\n padding-right: 0.2rem;\\n}\\n.json-formatter-dark.json-formatter-row .json-formatter-toggler:after {\\n display: inline-block;\\n transition: transform 100ms ease-in;\\n content: \\\"\\\\25BA\\\";\\n}\\n.json-formatter-dark.json-formatter-row > a > .json-formatter-preview-text {\\n opacity: 0;\\n transition: opacity 0.15s ease-in;\\n font-style: italic;\\n}\\n.json-formatter-dark.json-formatter-row:hover > a > .json-formatter-preview-text {\\n opacity: 0.6;\\n}\\n.json-formatter-dark.json-formatter-row.json-formatter-open > .json-formatter-toggler-link .json-formatter-toggler:after {\\n transform: rotate(90deg);\\n}\\n.json-formatter-dark.json-formatter-row.json-formatter-open > .json-formatter-children:after {\\n display: inline-block;\\n}\\n.json-formatter-dark.json-formatter-row.json-formatter-open > a > .json-formatter-preview-text {\\n display: none;\\n}\\n.json-formatter-dark.json-formatter-row.json-formatter-open.json-formatter-empty:after {\\n display: block;\\n}\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\".bk.panel-widget-box {\\n min-height: 20px;\\n background-color: #f5f5f5;\\n border: 1px solid #e3e3e3;\\n border-radius: 4px;\\n -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.05);\\n box-shadow: inset 0 1px 1px rgba(0,0,0,.05);\\n overflow-x: hidden;\\n overflow-y: hidden;\\n}\\n\\n.scrollable {\\n overflow: scroll;\\n}\\n\\nprogress {\\n appearance: none;\\n -moz-appearance: none;\\n -webkit-appearance: none;\\n border: none;\\n height: 20px;\\n background-color: whiteSmoke;\\n border-radius: 3px;\\n box-shadow: 0 2px 3px rgba(0,0,0,.5) inset;\\n color: royalblue;\\n position: relative;\\n margin: 0 0 1.5em;\\n}\\n\\nprogress[value]::-webkit-progress-bar {\\n background-color: whiteSmoke;\\n border-radius: 3px;\\n box-shadow: 0 2px 3px rgba(0,0,0,.5) inset;\\n}\\n\\nprogress[value]::-webkit-progress-value {\\n position: relative;\\n background-size: 35px 20px, 100% 100%, 100% 100%;\\n border-radius:3px;\\n}\\n\\nprogress.active:not([value])::before {\\n background-position: 10%;\\n animation-name: stripes;\\n animation-duration: 3s;\\n animation-timing-function: linear;\\n animation-iteration-count: infinite;\\n}\\n\\nprogress[value]::-moz-progress-bar {\\n background-size: 35px 20px, 100% 100%, 100% 100%;\\n border-radius:3px;\\n}\\n\\nprogress:not([value])::-moz-progress-bar {\\n border-radius:3px;\\n background: linear-gradient(-45deg, transparent 33%, rgba(0, 0, 0, 0.2) 33%, rgba(0, 0, 0, 0.2) 66%, transparent 66%) left/2.5em 1.5em;\\n}\\n\\nprogress.active:not([value])::-moz-progress-bar {\\n background-position: 10%;\\n animation-name: stripes;\\n animation-duration: 3s;\\n animation-timing-function: linear;\\n animation-iteration-count: infinite;\\n}\\n\\nprogress.active:not([value])::-webkit-progress-bar {\\n background-position: 10%;\\n animation-name: stripes;\\n animation-duration: 3s;\\n animation-timing-function: linear;\\n animation-iteration-count: infinite;\\n}\\n\\nprogress.primary[value]::-webkit-progress-value { background-color: #007bff; }\\nprogress.primary:not([value])::before { background-color: #007bff; }\\nprogress.primary:not([value])::-webkit-progress-bar { background-color: #007bff; }\\nprogress.primary::-moz-progress-bar { background-color: #007bff; }\\n\\nprogress.secondary[value]::-webkit-progress-value { background-color: #6c757d; }\\nprogress.secondary:not([value])::before { background-color: #6c757d; }\\nprogress.secondary:not([value])::-webkit-progress-bar { background-color: #6c757d; }\\nprogress.secondary::-moz-progress-bar { background-color: #6c757d; }\\n\\nprogress.success[value]::-webkit-progress-value { background-color: #28a745; }\\nprogress.success:not([value])::before { background-color: #28a745; }\\nprogress.success:not([value])::-webkit-progress-bar { background-color: #28a745; }\\nprogress.success::-moz-progress-bar { background-color: #28a745; }\\n\\nprogress.danger[value]::-webkit-progress-value { background-color: #dc3545; }\\nprogress.danger:not([value])::before { background-color: #dc3545; }\\nprogress.danger:not([value])::-webkit-progress-bar { background-color: #dc3545; }\\nprogress.danger::-moz-progress-bar { background-color: #dc3545; }\\n\\nprogress.warning[value]::-webkit-progress-value { background-color: #ffc107; }\\nprogress.warning:not([value])::before { background-color: #ffc107; }\\nprogress.warning:not([value])::-webkit-progress-bar { background-color: #ffc107; }\\nprogress.warning::-moz-progress-bar { background-color: #ffc107; }\\n\\nprogress.info[value]::-webkit-progress-value { background-color: #17a2b8; }\\nprogress.info:not([value])::before { background-color: #17a2b8; }\\nprogress.info:not([value])::-webkit-progress-bar { background-color: #17a2b8; }\\nprogress.info::-moz-progress-bar { background-color: #17a2b8; }\\n\\nprogress.light[value]::-webkit-progress-value { background-color: #f8f9fa; }\\nprogress.light:not([value])::before { background-color: #f8f9fa; }\\nprogress.light:not([value])::-webkit-progress-bar { background-color: #f8f9fa; }\\nprogress.light::-moz-progress-bar { background-color: #f8f9fa; }\\n\\nprogress.dark[value]::-webkit-progress-value { background-color: #343a40; }\\nprogress.dark:not([value])::-webkit-progress-bar { background-color: #343a40; }\\nprogress.dark:not([value])::before { background-color: #343a40; }\\nprogress.dark::-moz-progress-bar { background-color: #343a40; }\\n\\nprogress:not([value])::-webkit-progress-bar {\\n border-radius: 3px;\\n background: linear-gradient(-45deg, transparent 33%, rgba(0, 0, 0, 0.2) 33%, rgba(0, 0, 0, 0.2) 66%, transparent 66%) left/2.5em 1.5em;\\n}\\nprogress:not([value])::before {\\n content:\\\" \\\";\\n position:absolute;\\n height: 20px;\\n top:0;\\n left:0;\\n right:0;\\n bottom:0;\\n border-radius: 3px;\\n background: linear-gradient(-45deg, transparent 33%, rgba(0, 0, 0, 0.2) 33%, rgba(0, 0, 0, 0.2) 66%, transparent 66%) left/2.5em 1.5em;\\n}\\n\\n@keyframes stripes {\\n from {background-position: 0%}\\n to {background-position: 100%}\\n}\\n\\n.bk-root .bk.loader {\\n overflow: hidden;\\n}\\n\\n.bk.loader::after {\\n content: \\\"\\\";\\n border-radius: 50%;\\n -webkit-mask-image: radial-gradient(transparent 50%, rgba(0, 0, 0, 1) 54%);\\n width: 100%;\\n height: 100%;\\n left: 0;\\n top: 0;\\n position: absolute;\\n}\\n\\n.bk-root .bk.loader.dark::after {\\n background: #0f0f0f;\\n}\\n\\n.bk-root .bk.loader.light::after {\\n background: #f0f0f0;\\n}\\n\\n.bk-root .bk.loader.spin::after {\\n animation: spin 2s linear infinite;\\n}\\n\\n.bk-root div.bk.loader.spin.primary-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #007bff 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.secondary-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #6c757d 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.success-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #28a745 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.danger-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #dc3545 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.warning-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #ffc107 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.info-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #17a2b8 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.light-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #f8f9fa 50%);\\n}\\n\\n.bk-root div.bk.loader.dark-light::after {\\n background: linear-gradient(135deg, #f0f0f0 50%, transparent 50%), linear-gradient(45deg, #f0f0f0 50%, #343a40 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.primary-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #007bff 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.secondary-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #6c757d 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.success-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #28a745 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.danger-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #dc3545 50%)\\n}\\n\\n.bk-root div.bk.loader.spin.warning-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #ffc107 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.info-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #17a2b8 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.light-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #f8f9fa 50%);\\n}\\n\\n.bk-root div.bk.loader.spin.dark-dark::after {\\n background: linear-gradient(135deg, #0f0f0f 50%, transparent 50%), linear-gradient(45deg, #0f0f0f 50%, #343a40 50%);\\n}\\n\\n/* Safari */\\n@-webkit-keyframes spin {\\n 0% { -webkit-transform: rotate(0deg); }\\n 100% { -webkit-transform: rotate(360deg); }\\n}\\n\\n@keyframes spin {\\n 0% { transform: rotate(0deg); }\\n 100% { transform: rotate(360deg); }\\n}\\n\\n.dot div {\\n height: 100%;\\n width: 100%;\\n border: 1px solid #000 !important;\\n background-color: #fff;\\n border-radius: 50%;\\n display: inline-block;\\n}\\n\\n.dot-filled div {\\n height: 100%;\\n width: 100%;\\n border: 1px solid #000 !important;\\n border-radius: 50%;\\n display: inline-block;\\n}\\n\\n.dot-filled.primary div {\\n background-color: #007bff;\\n}\\n\\n.dot-filled.secondary div {\\n background-color: #6c757d;\\n}\\n\\n.dot-filled.success div {\\n background-color: #28a745;\\n}\\n\\n.dot-filled.danger div {\\n background-color: #dc3545;\\n}\\n\\n.dot-filled.warning div {\\n background-color: #ffc107;\\n}\\n\\n.dot-filled.info div {\\n background-color: #17a2b8;\\n}\\n\\n.dot-filled.dark div {\\n background-color: #343a40;\\n}\\n\\n.dot-filled.light div {\\n background-color: #f8f9fa;\\n}\\n\\n/* Slider editor */\\n.slider-edit .bk-input-group .bk-input {\\n border: 0;\\n border-radius: 0;\\n min-height: 0;\\n padding-left: 0;\\n padding-right: 0;\\n font-weight: bold;\\n}\\n\\n.slider-edit .bk-input-group .bk-spin-wrapper {\\n display: contents;\\n}\\n\\n.slider-edit .bk-input-group .bk-spin-wrapper .bk.bk-spin-btn-up {\\n top: -6px;\\n}\\n\\n.slider-edit .bk-input-group .bk-spin-wrapper .bk.bk-spin-btn-down {\\n bottom: 3px;\\n}\\n\\n/* JSON Pane */\\n.bk-root .json-formatter-row .json-formatter-string, .bk-root .json-formatter-row .json-formatter-stringifiable {\\n white-space: pre-wrap;\\n}\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\"table.panel-df {\\n margin-left: auto;\\n margin-right: auto;\\n border: none;\\n border-collapse: collapse;\\n border-spacing: 0;\\n color: black;\\n font-size: 12px;\\n table-layout: fixed;\\n width: 100%;\\n}\\n\\n.panel-df tr, .panel-df th, .panel-df td {\\n text-align: right;\\n vertical-align: middle;\\n padding: 0.5em 0.5em !important;\\n line-height: normal;\\n white-space: normal;\\n max-width: none;\\n border: none;\\n}\\n\\n.panel-df tbody {\\n display: table-row-group;\\n vertical-align: middle;\\n border-color: inherit;\\n}\\n\\n.panel-df tbody tr:nth-child(odd) {\\n background: #f5f5f5;\\n}\\n\\n.panel-df thead {\\n border-bottom: 1px solid black;\\n vertical-align: bottom;\\n}\\n\\n.panel-df tr:hover {\\n background: lightblue !important;\\n cursor: pointer;\\n}\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\".bk.card {\\n border: 1px solid rgba(0,0,0,.125);\\n border-radius: 0.25rem;\\n}\\n.bk.accordion {\\n border: 1px solid rgba(0,0,0,.125);\\n}\\n.bk.card-header {\\n align-items: center;\\n background-color: rgba(0, 0, 0, 0.03);\\n border-radius: 0.25rem;\\n display: inline-flex;\\n justify-content: start;\\n width: 100%;\\n}\\n.bk.accordion-header {\\n align-items: center;\\n background-color: rgba(0, 0, 0, 0.03);\\n border-radius: 0;\\n display: flex;\\n justify-content: start;\\n width: 100%;\\n}\\n.bk.card-button {\\n background-color: transparent;\\n margin-left: 0.5em;\\n}\\n.bk.card-header-row {\\n position: relative !important;\\n}\\n.bk.card-title {\\n align-items: center;\\n font-size: 1.4em;\\n font-weight: bold;\\n overflow-wrap: break-word;\\n}\\n.bk.card-header-row > .bk {\\n padding-right: 1.5em !important;\\n overflow-wrap: break-word;\\n}\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\".bk.pn-loading:before {\\n position: absolute;\\n height: 100%;\\n width: 100%;\\n content: '';\\n z-index: 1000;\\n background-color: rgb(255,255,255,0.50);\\n border-color: lightgray;\\n background-repeat: no-repeat;\\n background-position: center;\\n background-size: auto 50%;\\n border-width: 1px;\\n cursor: progress;\\n}\\n.bk.pn-loading.arcs:hover:before {\\n cursor: progress;\\n}\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\".codehilite .hll { background-color: #ffffcc }\\n.codehilite { background: #f8f8f8; }\\n.codehilite .c { color: #408080; font-style: italic } /* Comment */\\n.codehilite .err { border: 1px solid #FF0000 } /* Error */\\n.codehilite .k { color: #008000; font-weight: bold } /* Keyword */\\n.codehilite .o { color: #666666 } /* Operator */\\n.codehilite .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\\n.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */\\n.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */\\n.codehilite .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\\n.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */\\n.codehilite .cs { color: #408080; font-style: italic } /* Comment.Special */\\n.codehilite .gd { color: #A00000 } /* Generic.Deleted */\\n.codehilite .ge { font-style: italic } /* Generic.Emph */\\n.codehilite .gr { color: #FF0000 } /* Generic.Error */\\n.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */\\n.codehilite .gi { color: #00A000 } /* Generic.Inserted */\\n.codehilite .go { color: #888888 } /* Generic.Output */\\n.codehilite .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\\n.codehilite .gs { font-weight: bold } /* Generic.Strong */\\n.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\\n.codehilite .gt { color: #0044DD } /* Generic.Traceback */\\n.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\\n.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\\n.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\\n.codehilite .kp { color: #008000 } /* Keyword.Pseudo */\\n.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\\n.codehilite .kt { color: #B00040 } /* Keyword.Type */\\n.codehilite .m { color: #666666 } /* Literal.Number */\\n.codehilite .s { color: #BA2121 } /* Literal.String */\\n.codehilite .na { color: #7D9029 } /* Name.Attribute */\\n.codehilite .nb { color: #008000 } /* Name.Builtin */\\n.codehilite .nc { color: #0000FF; font-weight: bold } /* Name.Class */\\n.codehilite .no { color: #880000 } /* Name.Constant */\\n.codehilite .nd { color: #AA22FF } /* Name.Decorator */\\n.codehilite .ni { color: #999999; font-weight: bold } /* Name.Entity */\\n.codehilite .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\\n.codehilite .nf { color: #0000FF } /* Name.Function */\\n.codehilite .nl { color: #A0A000 } /* Name.Label */\\n.codehilite .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\\n.codehilite .nt { color: #008000; font-weight: bold } /* Name.Tag */\\n.codehilite .nv { color: #19177C } /* Name.Variable */\\n.codehilite .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\\n.codehilite .w { color: #bbbbbb } /* Text.Whitespace */\\n.codehilite .mb { color: #666666 } /* Literal.Number.Bin */\\n.codehilite .mf { color: #666666 } /* Literal.Number.Float */\\n.codehilite .mh { color: #666666 } /* Literal.Number.Hex */\\n.codehilite .mi { color: #666666 } /* Literal.Number.Integer */\\n.codehilite .mo { color: #666666 } /* Literal.Number.Oct */\\n.codehilite .sa { color: #BA2121 } /* Literal.String.Affix */\\n.codehilite .sb { color: #BA2121 } /* Literal.String.Backtick */\\n.codehilite .sc { color: #BA2121 } /* Literal.String.Char */\\n.codehilite .dl { color: #BA2121 } /* Literal.String.Delimiter */\\n.codehilite .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\\n.codehilite .s2 { color: #BA2121 } /* Literal.String.Double */\\n.codehilite .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\\n.codehilite .sh { color: #BA2121 } /* Literal.String.Heredoc */\\n.codehilite .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\\n.codehilite .sx { color: #008000 } /* Literal.String.Other */\\n.codehilite .sr { color: #BB6688 } /* Literal.String.Regex */\\n.codehilite .s1 { color: #BA2121 } /* Literal.String.Single */\\n.codehilite .ss { color: #19177C } /* Literal.String.Symbol */\\n.codehilite .bp { color: #008000 } /* Name.Builtin.Pseudo */\\n.codehilite .fm { color: #0000FF } /* Name.Function.Magic */\\n.codehilite .vc { color: #19177C } /* Name.Variable.Class */\\n.codehilite .vg { color: #19177C } /* Name.Variable.Global */\\n.codehilite .vi { color: #19177C } /* Name.Variable.Instance */\\n.codehilite .vm { color: #19177C } /* Name.Variable.Magic */\\n.codehilite .il { color: #666666 } /* Literal.Number.Integer.Long */\\n\\n.markdown h1 { margin-block-start: 0.34em }\\n.markdown h2 { margin-block-start: 0.42em }\\n.markdown h3 { margin-block-start: 0.5em }\\n.markdown h4 { margin-block-start: 0.67em }\\n.markdown h5 { margin-block-start: 0.84em }\\n.markdown h6 { margin-block-start: 1.17em }\\n.markdown ul { padding-inline-start: 2em }\\n.markdown ol { padding-inline-start: 2em }\\n.markdown strong { font-weight: 600 }\\n.markdown a { color: -webkit-link }\\n.markdown a { color: -moz-hyperlinkText }\\n\");\n", + " },\n", + " function(Bokeh) {\n", + " inject_raw_css(\"\\n .bk.pn-loading.arcs:before {\\n background-image: url(\\\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiBzdHlsZT0ibWFyZ2luOiBhdXRvOyBiYWNrZ3JvdW5kOiBub25lOyBkaXNwbGF5OiBibG9jazsgc2hhcGUtcmVuZGVyaW5nOiBhdXRvOyIgdmlld0JveD0iMCAwIDEwMCAxMDAiIHByZXNlcnZlQXNwZWN0UmF0aW89InhNaWRZTWlkIj4gIDxjaXJjbGUgY3g9IjUwIiBjeT0iNTAiIHI9IjMyIiBzdHJva2Utd2lkdGg9IjgiIHN0cm9rZT0iI2MzYzNjMyIgc3Ryb2tlLWRhc2hhcnJheT0iNTAuMjY1NDgyNDU3NDM2NjkgNTAuMjY1NDgyNDU3NDM2NjkiIGZpbGw9Im5vbmUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCI+ICAgIDxhbmltYXRlVHJhbnNmb3JtIGF0dHJpYnV0ZU5hbWU9InRyYW5zZm9ybSIgdHlwZT0icm90YXRlIiByZXBlYXRDb3VudD0iaW5kZWZpbml0ZSIgZHVyPSIxcyIga2V5VGltZXM9IjA7MSIgdmFsdWVzPSIwIDUwIDUwOzM2MCA1MCA1MCI+PC9hbmltYXRlVHJhbnNmb3JtPiAgPC9jaXJjbGU+PC9zdmc+\\\")\\n }\\n \");\n", + " },\n", + " function(Bokeh) {\n", + " /* BEGIN bokeh.min.js */\n", + " /*!\n", + " * Copyright (c) 2012 - 2021, Anaconda, Inc., and Bokeh Contributors\n", + " * All rights reserved.\n", + " * \n", + " * Redistribution and use in source and binary forms, with or without modification,\n", + " * are permitted provided that the following conditions are met:\n", + " * \n", + " * Redistributions of source code must retain the above copyright notice,\n", + " * this list of conditions and the following disclaimer.\n", + " * \n", + " * Redistributions in binary form must reproduce the above copyright notice,\n", + " * this list of conditions and the following disclaimer in the documentation\n", + " * and/or other materials provided with the distribution.\n", + " * \n", + " * Neither the name of Anaconda nor the names of any contributors\n", + " * may be used to endorse or promote products derived from this software\n", + " * without specific prior written permission.\n", + " * \n", + " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n", + " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n", + " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n", + " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n", + " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n", + " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n", + " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n", + " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n", + " * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n", + " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n", + " * THE POSSIBILITY OF SUCH DAMAGE.\n", + " */\n", + " (function(root, factory) {\n", + " const bokeh = factory();\n", + " bokeh.__bokeh__ = true;\n", + " if (typeof root.Bokeh === \"undefined\" || typeof root.Bokeh.__bokeh__ === \"undefined\") {\n", + " root.Bokeh = bokeh;\n", + " }\n", + " const Bokeh = root.Bokeh;\n", + " Bokeh[bokeh.version] = bokeh;\n", + " })(this, function() {\n", + " var define;\n", + " var parent_require = typeof require === \"function\" && require\n", + " return (function(modules, entry, aliases, externals) {\n", + " if (aliases === undefined) aliases = {};\n", + " if (externals === undefined) externals = {};\n", + "\n", + " var cache = {};\n", + "\n", + " var normalize = function(name) {\n", + " if (typeof name === \"number\")\n", + " return name;\n", + "\n", + " if (name === \"bokehjs\")\n", + " return entry;\n", + "\n", + " if (!externals[name]) {\n", + " var prefix = \"@bokehjs/\"\n", + " if (name.slice(0, prefix.length) === prefix)\n", + " name = name.slice(prefix.length)\n", + " }\n", + "\n", + " var alias = aliases[name]\n", + " if (alias != null)\n", + " return alias;\n", + "\n", + " var trailing = name.length > 0 && name[name.lenght-1] === \"/\";\n", + " var index = aliases[name + (trailing ? \"\" : \"/\") + \"index\"];\n", + " if (index != null)\n", + " return index;\n", + "\n", + " return name;\n", + " }\n", + "\n", + " var require = function(name) {\n", + " var mod = cache[name];\n", + " if (!mod) {\n", + " var id = normalize(name);\n", + "\n", + " mod = cache[id];\n", + " if (!mod) {\n", + " if (!modules[id]) {\n", + " if (externals[id] === false || (externals[id] == true && parent_require)) {\n", + " try {\n", + " mod = {exports: externals[id] ? parent_require(id) : {}};\n", + " cache[id] = cache[name] = mod;\n", + " return mod.exports;\n", + " } catch (e) {}\n", + " }\n", + "\n", + " var err = new Error(\"Cannot find module '\" + name + \"'\");\n", + " err.code = 'MODULE_NOT_FOUND';\n", + " throw err;\n", + " }\n", + "\n", + " mod = {exports: {}};\n", + " cache[id] = cache[name] = mod;\n", + "\n", + " function __esModule() {\n", + " Object.defineProperty(mod.exports, \"__esModule\", {value: true});\n", + " }\n", + "\n", + " function __esExport(name, value) {\n", + " Object.defineProperty(mod.exports, name, {\n", + " enumerable: true, get: function () { return value; }\n", + " });\n", + " }\n", + "\n", + " modules[id].call(mod.exports, require, mod, mod.exports, __esModule, __esExport);\n", + " } else {\n", + " cache[name] = mod;\n", + " }\n", + " }\n", + "\n", + " return mod.exports;\n", + " }\n", + " require.resolve = function(name) {\n", + " return \"\"\n", + " }\n", + "\n", + " var main = require(entry);\n", + " main.require = require;\n", + "\n", + " if (typeof Proxy !== \"undefined\") {\n", + " // allow Bokeh.loader[\"@bokehjs/module/name\"] syntax\n", + " main.loader = new Proxy({}, {\n", + " get: function(_obj, module) {\n", + " return require(module);\n", + " }\n", + " });\n", + " }\n", + "\n", + " main.register_plugin = function(plugin_modules, plugin_entry, plugin_aliases, plugin_externals) {\n", + " if (plugin_aliases === undefined) plugin_aliases = {};\n", + " if (plugin_externals === undefined) plugin_externals = {};\n", + "\n", + " for (var name in plugin_modules) {\n", + " modules[name] = plugin_modules[name];\n", + " }\n", + "\n", + " for (var name in plugin_aliases) {\n", + " aliases[name] = plugin_aliases[name];\n", + " }\n", + "\n", + " for (var name in plugin_externals) {\n", + " externals[name] = plugin_externals[name];\n", + " }\n", + "\n", + " var plugin = require(plugin_entry);\n", + "\n", + " for (var name in plugin) {\n", + " main[name] = plugin[name];\n", + " }\n", + "\n", + " return plugin;\n", + " }\n", + "\n", + " return main;\n", + " })\n", + " ([\n", + " function _(t,_,n,o,r){o();t(1).__exportStar(t(2),n)},\n", + " function _(t,e,n,r,o){r();var a=function(t,e){return(a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=e[n])})(t,e)};n.__extends=function(t,e){function n(){this.constructor=t}a(t,e),t.prototype=null===e?Object.create(e):(n.prototype=e.prototype,new n)};function i(t){var e=\"function\"==typeof Symbol&&Symbol.iterator,n=e&&t[e],r=0;if(n)return n.call(t);if(t&&\"number\"==typeof t.length)return{next:function(){return t&&r>=t.length&&(t=void 0),{value:t&&t[r++],done:!t}}};throw new TypeError(e?\"Object is not iterable.\":\"Symbol.iterator is not defined.\")}function c(t,e){var n=\"function\"==typeof Symbol&&t[Symbol.iterator];if(!n)return t;var r,o,a=n.call(t),i=[];try{for(;(void 0===e||e-- >0)&&!(r=a.next()).done;)i.push(r.value)}catch(t){o={error:t}}finally{try{r&&!r.done&&(n=a.return)&&n.call(a)}finally{if(o)throw o.error}}return i}function u(t){return this instanceof u?(this.v=t,this):new u(t)}n.__assign=function(){return n.__assign=Object.assign||function(t){for(var e,n=1,r=arguments.length;n=0;c--)(o=t[c])&&(i=(a<3?o(i):a>3?o(e,n,i):o(e,n))||i);return a>3&&i&&Object.defineProperty(e,n,i),i},n.__param=function(t,e){return function(n,r){e(n,r,t)}},n.__metadata=function(t,e){if(\"object\"==typeof Reflect&&\"function\"==typeof Reflect.metadata)return Reflect.metadata(t,e)},n.__awaiter=function(t,e,n,r){return new(n||(n=Promise))((function(o,a){function i(t){try{u(r.next(t))}catch(t){a(t)}}function c(t){try{u(r.throw(t))}catch(t){a(t)}}function u(t){var e;t.done?o(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(i,c)}u((r=r.apply(t,e||[])).next())}))},n.__generator=function(t,e){var n,r,o,a,i={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return a={next:c(0),throw:c(1),return:c(2)},\"function\"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function c(a){return function(c){return function(a){if(n)throw new TypeError(\"Generator is already executing.\");for(;i;)try{if(n=1,r&&(o=2&a[0]?r.return:a[0]?r.throw||((o=r.return)&&o.call(r),0):r.next)&&!(o=o.call(r,a[1])).done)return o;switch(r=0,o&&(a=[2&a[0],o.value]),a[0]){case 0:case 1:o=a;break;case 4:return i.label++,{value:a[1],done:!1};case 5:i.label++,r=a[1],a=[0];continue;case 7:a=i.ops.pop(),i.trys.pop();continue;default:if(!(o=i.trys,(o=o.length>0&&o[o.length-1])||6!==a[0]&&2!==a[0])){i=0;continue}if(3===a[0]&&(!o||a[1]>o[0]&&a[1]1||c(t,e)}))})}function c(t,e){try{(n=o[t](e)).value instanceof u?Promise.resolve(n.value.v).then(f,l):s(a[0][2],n)}catch(t){s(a[0][3],t)}var n}function f(t){c(\"next\",t)}function l(t){c(\"throw\",t)}function s(t,e){t(e),a.shift(),a.length&&c(a[0][0],a[0][1])}},n.__asyncDelegator=function(t){var e,n;return e={},r(\"next\"),r(\"throw\",(function(t){throw t})),r(\"return\"),e[Symbol.iterator]=function(){return this},e;function r(r,o){e[r]=t[r]?function(e){return(n=!n)?{value:u(t[r](e)),done:\"return\"===r}:o?o(e):e}:o}},n.__asyncValues=function(t){if(!Symbol.asyncIterator)throw new TypeError(\"Symbol.asyncIterator is not defined.\");var e,n=t[Symbol.asyncIterator];return n?n.call(t):(t=i(t),e={},r(\"next\"),r(\"throw\"),r(\"return\"),e[Symbol.asyncIterator]=function(){return this},e);function r(n){e[n]=t[n]&&function(e){return new Promise((function(r,o){(function(t,e,n,r){Promise.resolve(r).then((function(e){t({value:e,done:n})}),e)})(r,o,(e=t[n](e)).done,e.value)}))}}},n.__makeTemplateObject=function(t,e){return Object.defineProperty?Object.defineProperty(t,\"raw\",{value:e}):t.raw=e,t};var f=Object.create?function(t,e){Object.defineProperty(t,\"default\",{enumerable:!0,value:e})}:function(t,e){t.default=e};n.__importStar=function(t){if(t&&t.__esModule)return t;var e={};if(null!=t)for(var r in t)\"default\"!==r&&Object.prototype.hasOwnProperty.call(t,r)&&n.__createBinding(e,t,r);return f(e,t),e},n.__importDefault=function(t){return t&&t.__esModule?t:{default:t}},n.__classPrivateFieldGet=function(t,e){if(!e.has(t))throw new TypeError(\"attempted to get private field on non-instance\");return e.get(t)},n.__classPrivateFieldSet=function(t,e,n){if(!e.has(t))throw new TypeError(\"attempted to set private field on non-instance\");return e.set(t,n),n}},\n", + " function _(e,t,o,s,l){s();const n=e(1);l(\"version\",e(3).version),l(\"index\",e(4).index),o.embed=n.__importStar(e(4)),o.protocol=n.__importStar(e(404)),o._testing=n.__importStar(e(405));var r=e(19);l(\"logger\",r.logger),l(\"set_log_level\",r.set_log_level),l(\"settings\",e(28).settings),l(\"Models\",e(7).Models),l(\"documents\",e(5).documents),l(\"safely\",e(406).safely)},\n", + " function _(n,i,o,c,e){c(),o.version=\"2.3.3\"},\n", + " function _(e,o,t,n,s){n();const d=e(5),r=e(19),_=e(34),c=e(13),i=e(8),a=e(16),u=e(395),l=e(397),m=e(396);var f=e(395);s(\"add_document_standalone\",f.add_document_standalone),s(\"index\",f.index),s(\"add_document_from_session\",e(397).add_document_from_session);var g=e(402);async function w(e,o,t,n){i.isString(e)&&(e=JSON.parse(_.unescape(e)));const s={};for(const[o,t]of c.entries(e))s[o]=d.Document.from_json(t);const a=[];for(const e of o){const o=m._resolve_element(e),d=m._resolve_root_elements(e);if(null!=e.docid)a.push(await u.add_document_standalone(s[e.docid],o,d,e.use_for_title));else{if(null==e.token)throw new Error(\"Error rendering Bokeh items: either 'docid' or 'token' was expected.\");{const s=l._get_ws_url(t,n);r.logger.debug(`embed: computed ws url: ${s}`);try{a.push(await l.add_document_from_session(s,e.token,o,d,e.use_for_title)),console.log(\"Bokeh items were rendered successfully\")}catch(e){console.log(\"Error rendering Bokeh items:\",e)}}}}return a}s(\"embed_items_notebook\",g.embed_items_notebook),s(\"kernels\",g.kernels),s(\"BOKEH_ROOT\",e(396).BOKEH_ROOT),t.embed_item=async function(e,o){const t={},n=_.uuid4();t[n]=e.doc,null==o&&(o=e.target_id);const s=document.getElementById(o);null!=s&&s.classList.add(m.BOKEH_ROOT);const d={roots:{[e.root_id]:o},root_ids:[e.root_id],docid:n};await a.defer();const[r]=await w(t,[d]);return r},t.embed_items=async function(e,o,t,n){return await a.defer(),w(e,o,t,n)}},\n", + " function _(t,_,o,r,n){r();const a=t(1);a.__exportStar(t(6),o),a.__exportStar(t(35),o)},\n", + " function _(e,t,s,o,n){o();const r=e(1),i=e(7),l=e(3),_=e(19),a=e(264),c=e(14),d=e(30),h=e(15),f=e(17),u=e(31),m=e(9),g=e(13),v=r.__importStar(e(132)),w=e(26),p=e(8),b=e(319),y=e(130),k=e(53),M=e(394),j=e(35);class S{constructor(e){this.document=e,this.session=null,this.subscribed_models=new Set}send_event(e){const t=new j.MessageSentEvent(this.document,\"bokeh_event\",e.to_json());this.document._trigger_on_change(t)}trigger(e){for(const t of this.subscribed_models)null!=e.origin&&e.origin!=t||t._process_event(e)}}s.EventManager=S,S.__name__=\"EventManager\",s.documents=[],s.DEFAULT_TITLE=\"Bokeh Application\";class E{constructor(e){var t;s.documents.push(this),this._init_timestamp=Date.now(),this._resolver=null!==(t=null==e?void 0:e.resolver)&&void 0!==t?t:new i.ModelResolver,this._title=s.DEFAULT_TITLE,this._roots=[],this._all_models=new Map,this._all_models_freeze_count=0,this._callbacks=new Map,this._message_callbacks=new Map,this.event_manager=new S(this),this.idle=new h.Signal0(this,\"idle\"),this._idle_roots=new WeakMap,this._interactive_timestamp=null,this._interactive_plot=null}get layoutables(){return this._roots.filter((e=>e instanceof b.LayoutDOM))}get is_idle(){for(const e of this.layoutables)if(!this._idle_roots.has(e))return!1;return!0}notify_idle(e){this._idle_roots.set(e,!0),this.is_idle&&(_.logger.info(`document idle at ${Date.now()-this._init_timestamp} ms`),this.event_manager.send_event(new a.DocumentReady),this.idle.emit())}clear(){this._push_all_models_freeze();try{for(;this._roots.length>0;)this.remove_root(this._roots[0])}finally{this._pop_all_models_freeze()}}interactive_start(e){null==this._interactive_plot&&(this._interactive_plot=e,this._interactive_plot.trigger_event(new a.LODStart)),this._interactive_timestamp=Date.now()}interactive_stop(){null!=this._interactive_plot&&this._interactive_plot.trigger_event(new a.LODEnd),this._interactive_plot=null,this._interactive_timestamp=null}interactive_duration(){return null==this._interactive_timestamp?-1:Date.now()-this._interactive_timestamp}destructively_move(e){if(e===this)throw new Error(\"Attempted to overwrite a document with itself\");e.clear();const t=m.copy(this._roots);this.clear();for(const e of t)if(null!=e.document)throw new Error(`Somehow we didn't detach ${e}`);if(0!=this._all_models.size)throw new Error(`this._all_models still had stuff in it: ${this._all_models}`);for(const s of t)e.add_root(s);e.set_title(this._title)}_push_all_models_freeze(){this._all_models_freeze_count+=1}_pop_all_models_freeze(){this._all_models_freeze_count-=1,0===this._all_models_freeze_count&&this._recompute_all_models()}_invalidate_all_models(){_.logger.debug(\"invalidating document models\"),0===this._all_models_freeze_count&&this._recompute_all_models()}_recompute_all_models(){let e=new Set;for(const t of this._roots)e=v.union(e,t.references());const t=new Set(this._all_models.values()),s=v.difference(t,e),o=v.difference(e,t),n=new Map;for(const t of e)n.set(t.id,t);for(const e of s)e.detach_document();for(const e of o)e.attach_document(this);this._all_models=n}roots(){return this._roots}add_root(e,t){if(_.logger.debug(`Adding root: ${e}`),!m.includes(this._roots,e)){this._push_all_models_freeze();try{this._roots.push(e)}finally{this._pop_all_models_freeze()}this._trigger_on_change(new j.RootAddedEvent(this,e,t))}}remove_root(e,t){const s=this._roots.indexOf(e);if(!(s<0)){this._push_all_models_freeze();try{this._roots.splice(s,1)}finally{this._pop_all_models_freeze()}this._trigger_on_change(new j.RootRemovedEvent(this,e,t))}}title(){return this._title}set_title(e,t){e!==this._title&&(this._title=e,this._trigger_on_change(new j.TitleChangedEvent(this,e,t)))}get_model_by_id(e){var t;return null!==(t=this._all_models.get(e))&&void 0!==t?t:null}get_model_by_name(e){const t=[];for(const s of this._all_models.values())s instanceof k.Model&&s.name==e&&t.push(s);switch(t.length){case 0:return null;case 1:return t[0];default:throw new Error(`Multiple models are named '${e}'`)}}on_message(e,t){const s=this._message_callbacks.get(e);null==s?this._message_callbacks.set(e,new Set([t])):s.add(t)}remove_on_message(e,t){var s;null===(s=this._message_callbacks.get(e))||void 0===s||s.delete(t)}_trigger_on_message(e,t){const s=this._message_callbacks.get(e);if(null!=s)for(const e of s)e(t)}on_change(e,t=!1){this._callbacks.has(e)||this._callbacks.set(e,t)}remove_on_change(e){this._callbacks.delete(e)}_trigger_on_change(e){for(const[t,s]of this._callbacks)if(!s&&e instanceof j.DocumentEventBatch)for(const s of e.events)t(s);else t(e)}_notify_change(e,t,s,o,n){this._trigger_on_change(new j.ModelChangedEvent(this,e,t,s,o,null==n?void 0:n.setter_id,null==n?void 0:n.hint))}static _instantiate_object(e,t,s,o){const n=Object.assign(Object.assign({},s),{id:e,__deferred__:!0});return new(o.get(t))(n)}static _instantiate_references_json(e,t,s){var o;const n=new Map;for(const r of e){const e=r.id,i=r.type,l=null!==(o=r.attributes)&&void 0!==o?o:{};let _=t.get(e);null==_&&(_=E._instantiate_object(e,i,l,s),null!=r.subtype&&_.set_subtype(r.subtype)),n.set(_.id,_)}return n}static _resolve_refs(e,t,s,o){function n(e){var r;if(f.is_ref(e)){const o=null!==(r=t.get(e.id))&&void 0!==r?r:s.get(e.id);if(null!=o)return o;throw new Error(`reference ${JSON.stringify(e)} isn't known (not in Document?)`)}return u.is_NDArray_ref(e)?u.decode_NDArray(e,o):p.isArray(e)?function(e){const t=[];for(const s of e)t.push(n(s));return t}(e):p.isPlainObject(e)?function(e){const t={};for(const[s,o]of g.entries(e))t[s]=n(o);return t}(e):e}return n(e)}static _initialize_references_json(e,t,s,o){const n=new Map;for(const{id:r,attributes:i}of e){const e=!t.has(r),l=e?s.get(r):t.get(r),_=E._resolve_refs(i,t,s,o);l.setv(_,{silent:!0}),n.set(r,{instance:l,is_new:e})}const r=[],i=new Set;function l(e){if(e instanceof c.HasProps){if(n.has(e.id)&&!i.has(e.id)){i.add(e.id);const{instance:t,is_new:s}=n.get(e.id),{attributes:o}=t;for(const e of g.values(o))l(e);s&&(t.finalize(),r.push(t))}}else if(p.isArray(e))for(const t of e)l(t);else if(p.isPlainObject(e))for(const t of g.values(e))l(t)}for(const e of n.values())l(e.instance);for(const e of r)e.connect_signals()}static _event_for_attribute_change(e,t,s,o,n){if(o.get_model_by_id(e.id).property(t).syncable){const r={kind:\"ModelChanged\",model:{id:e.id},attr:t,new:s};return c.HasProps._json_record_references(o,s,n,{recursive:!0}),r}return null}static _events_to_sync_objects(e,t,s,o){const n=Object.keys(e.attributes),r=Object.keys(t.attributes),i=m.difference(n,r),l=m.difference(r,n),a=m.intersection(n,r),c=[];for(const e of i)_.logger.warn(`Server sent key ${e} but we don't seem to have it in our JSON`);for(const n of l){const r=t.attributes[n];c.push(E._event_for_attribute_change(e,n,r,s,o))}for(const n of a){const r=e.attributes[n],i=t.attributes[n];null==r&&null==i||(null==r||null==i?c.push(E._event_for_attribute_change(e,n,i,s,o)):w.is_equal(r,i)||c.push(E._event_for_attribute_change(e,n,i,s,o)))}return c.filter((e=>null!=e))}static _compute_patch_since_json(e,t){const s=t.to_json(!1);function o(e){const t=new Map;for(const s of e.roots.references)t.set(s.id,s);return t}const n=o(e),r=new Map,i=[];for(const t of e.roots.root_ids)r.set(t,n.get(t)),i.push(t);const l=o(s),_=new Map,a=[];for(const e of s.roots.root_ids)_.set(e,l.get(e)),a.push(e);if(i.sort(),a.sort(),m.difference(i,a).length>0||m.difference(a,i).length>0)throw new Error(\"Not implemented: computing add/remove of document roots\");const c=new Set;let h=[];for(const e of t._all_models.keys())if(n.has(e)){const s=E._events_to_sync_objects(n.get(e),l.get(e),t,c);h=h.concat(s)}const f=new d.Serializer({include_defaults:!1});return f.to_serializable([...c]),{references:[...f.definitions],events:h}}to_json_string(e=!0){return JSON.stringify(this.to_json(e))}to_json(e=!0){const t=new d.Serializer({include_defaults:e}),s=t.to_serializable(this._roots);return{version:l.version,title:this._title,roots:{root_ids:s.map((e=>e.id)),references:[...t.definitions]}}}static from_json_string(e){const t=JSON.parse(e);return E.from_json(t)}static from_json(e){_.logger.debug(\"Creating Document from JSON\");const t=e.version,s=-1!==t.indexOf(\"+\")||-1!==t.indexOf(\"-\"),o=`Library versions: JS (${l.version}) / Python (${t})`;s||l.version.replace(/-(dev|rc)\\./,\"$1\")==t?_.logger.debug(o):(_.logger.warn(\"JS/Python version mismatch\"),_.logger.warn(o));const n=new i.ModelResolver;null!=e.defs&&M.resolve_defs(e.defs,n);const r=e.roots,a=r.root_ids,c=r.references,d=E._instantiate_references_json(c,new Map,n);E._initialize_references_json(c,new Map,d,new Map);const h=new E({resolver:n});for(const e of a){const t=d.get(e);null!=t&&h.add_root(t)}return h.set_title(e.title),h}replace_with_json(e){E.from_json(e).destructively_move(this)}create_json_patch_string(e){return JSON.stringify(this.create_json_patch(e))}create_json_patch(e){for(const t of e)if(t.document!=this)throw new Error(\"Cannot create a patch using events from a different document\");const t=new d.Serializer,s=t.to_serializable(e);for(const e of this._all_models.values())t.remove_def(e);return{events:s,references:[...t.definitions]}}apply_json_patch(e,t=new Map,s){const o=e.references,n=e.events,r=E._instantiate_references_json(o,this._all_models,this._resolver);t instanceof Map||(t=new Map(t));for(const e of n)switch(e.kind){case\"RootAdded\":case\"RootRemoved\":case\"ModelChanged\":{const t=e.model.id,s=this._all_models.get(t);if(null!=s)r.set(t,s);else if(!r.has(t))throw _.logger.warn(`Got an event for unknown model ${e.model}\"`),new Error(\"event model wasn't known\");break}}const i=new Map(this._all_models),l=new Map;for(const[e,t]of r)i.has(e)||l.set(e,t);E._initialize_references_json(o,i,l,t);for(const e of n)switch(e.kind){case\"MessageSent\":{const{msg_type:s,msg_data:o}=e;let n;if(void 0===o){if(1!=t.size)throw new Error(\"expected exactly one buffer\");{const[[,e]]=t;n=e}}else n=E._resolve_refs(o,i,l,t);this._trigger_on_message(s,n);break}case\"ModelChanged\":{const o=e.model.id,n=this._all_models.get(o);if(null==n)throw new Error(`Cannot apply patch to ${o} which is not in the document`);const r=e.attr,_=E._resolve_refs(e.new,i,l,t);n.setv({[r]:_},{setter_id:s});break}case\"ColumnDataChanged\":{const o=e.column_source.id,n=this._all_models.get(o);if(null==n)throw new Error(`Cannot stream to ${o} which is not in the document`);const r=E._resolve_refs(e.new,new Map,new Map,t);if(null!=e.cols)for(const e in n.data)e in r||(r[e]=n.data[e]);n.setv({data:r},{setter_id:s,check_eq:!1});break}case\"ColumnsStreamed\":{const t=e.column_source.id,o=this._all_models.get(t);if(null==o)throw new Error(`Cannot stream to ${t} which is not in the document`);if(!(o instanceof y.ColumnDataSource))throw new Error(\"Cannot stream to non-ColumnDataSource\");const n=e.data,r=e.rollover;o.stream(n,r,s);break}case\"ColumnsPatched\":{const t=e.column_source.id,o=this._all_models.get(t);if(null==o)throw new Error(`Cannot patch ${t} which is not in the document`);if(!(o instanceof y.ColumnDataSource))throw new Error(\"Cannot patch non-ColumnDataSource\");const n=e.patches;o.patch(n,s);break}case\"RootAdded\":{const t=e.model.id,o=r.get(t);this.add_root(o,s);break}case\"RootRemoved\":{const t=e.model.id,o=r.get(t);this.remove_root(o,s);break}case\"TitleChanged\":this.set_title(e.title,s);break;default:throw new Error(\"Unknown patch event \"+JSON.stringify(e))}}}s.Document=E,E.__name__=\"Document\"},\n", + " function _(e,o,s,r,t){r();const l=e(1),d=e(8),i=e(13),n=e(14);s.overrides={};const a=new Map;s.Models=e=>{const o=s.Models.get(e);if(null!=o)return o;throw new Error(`Model '${e}' does not exist. This could be due to a widget or a custom model not being registered before first usage.`)},s.Models.get=e=>{var o;return null!==(o=s.overrides[e])&&void 0!==o?o:a.get(e)},s.Models.register=(e,o)=>{s.overrides[e]=o},s.Models.unregister=e=>{delete s.overrides[e]},s.Models.register_models=(e,o=!1,s)=>{var r;if(null!=e)for(const t of d.isArray(e)?e:i.values(e))if(r=t,d.isObject(r)&&r.prototype instanceof n.HasProps){const e=t.__qualified__;o||!a.has(e)?a.set(e,t):null!=s?s(e):console.warn(`Model '${e}' was already registered`)}},s.register_models=s.Models.register_models,s.Models.registered_names=()=>[...a.keys()];class u{constructor(){this._known_models=new Map}get(e,o){var r;const t=null!==(r=s.Models.get(e))&&void 0!==r?r:this._known_models.get(e);if(null!=t)return t;if(void 0!==o)return o;throw new Error(`Model '${e}' does not exist. This could be due to a widget or a custom model not being registered before first usage.`)}register(e){const o=e.__qualified__;null==this.get(o,null)?this._known_models.set(o,e):console.warn(`Model '${o}' was already registered with this resolver`)}}s.ModelResolver=u,u.__name__=\"ModelResolver\";const _=l.__importStar(e(38));s.register_models(_)},\n", + " function _(n,r,t,e,i){e();\n", + " // (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n", + " // Underscore may be freely distributed under the MIT license.\n", + " const o=n(9),u=Object.prototype.toString;function c(n){return!0===n||!1===n||\"[object Boolean]\"===u.call(n)}function f(n){return\"[object Number]\"===u.call(n)}function a(n){return\"[object String]\"===u.call(n)}function l(n){const r=typeof n;return\"function\"===r||\"object\"===r&&!!n}function s(n){return l(n)&&void 0!==n[Symbol.iterator]}t.isBoolean=c,t.isNumber=f,t.isInteger=function(n){return f(n)&&Number.isInteger(n)},t.isString=a,t.isPrimitive=function(n){return null===n||c(n)||f(n)||a(n)},t.isFunction=function(n){return\"[object Function]\"===u.call(n)},t.isArray=function(n){return Array.isArray(n)},t.isArrayOf=function(n,r){return o.every(n,r)},t.isArrayableOf=function(n,r){for(let t=0,e=n.length;t0,\"'step' must be a positive number\"),null==t&&(t=n,n=0);const{max:r,ceil:o,abs:i}=Math,c=n<=t?e:-e,f=r(o(i(t-n)/e),0),s=new Array(f);for(let t=0;t=0?t:n.length+t]},e.zip=function(...n){if(0==n.length)return[];const t=c.min(n.map((n=>n.length))),e=n.length,r=new Array(t);for(let o=0;on.length))),r=Array(e);for(let n=0;nn[t]))},e.argmax=function(n){return c.max_by(m(n.length),(t=>n[t]))},e.sort_by=function(n,t){const e=n.map(((n,e)=>({value:n,index:e,key:t(n)})));return e.sort(((n,t)=>{const e=n.key,r=t.key;if(e!==r){if(e>r||void 0===e)return 1;if(en.value))},e.uniq=function(n){const t=new Set;for(const e of n)t.add(e);return[...t]},e.uniq_by=function(n,t){const e=[],r=[];for(const o of n){const n=t(o);l(r,n)||(r.push(n),e.push(o))}return e},e.union=function(...n){const t=new Set;for(const e of n)for(const n of e)t.add(n);return[...t]},e.intersection=function(n,...t){const e=[];n:for(const r of n)if(!l(e,r)){for(const n of t)if(!l(n,r))continue n;e.push(r)}return e},e.difference=function(n,...t){const e=a(t);return n.filter((n=>!l(e,n)))},e.remove_at=function(n,t){const e=s(n);return e.splice(t,1),e},e.remove_by=function(n,t){for(let e=0;e2*u;)n-=2*u;return n}function c(n,r){return a(n-r)}function f(){return Math.random()}function i(n){switch(n){case\"deg\":return u/180;case\"rad\":return 1;case\"grad\":return u/200;case\"turn\":return 2*u}}t.angle_norm=a,t.angle_dist=c,t.angle_between=function(n,r,t,e=!1){const o=c(r,t);if(0==o)return!1;if(o==2*u)return!0;const f=a(n),i=c(r,f)<=o&&c(f,t)<=o;return e?!i:i},t.random=f,t.randomIn=function(n,r){return null==r&&(r=n,n=0),n+Math.floor(Math.random()*(r-n+1))},t.atan2=function(n,r){return Math.atan2(r[1]-n[1],r[0]-n[0])},t.radians=function(n){return n*(u/180)},t.degrees=function(n){return n/(u/180)},t.resolve_angle=function(n,r){return-i(r)*n},t.to_radians_coeff=i,t.rnorm=function(n,r){let t,e;for(;t=f(),e=f(),e=(2*e-1)*Math.sqrt(1/Math.E*2),!(-4*t*t*Math.log(t)>=e*e););let o=e/t;return o=n+r*o,o},t.clamp=function(n,r,t){return nt?t:n},t.log=function(n,r=Math.E){return Math.log(n)/Math.log(r)}},\n", + " function _(r,n,e,o,s){o();class t extends Error{}e.AssertionError=t,t.__name__=\"AssertionError\",e.assert=function(r,n){if(!(!0===r||!1!==r&&r()))throw new t(null!=n?n:\"Assertion failed\")},e.unreachable=function(){throw new Error(\"unreachable code\")}},\n", + " function _(n,t,e,r,o){r();const i=n(10);function l(n,t,e,...r){const o=n.length;t<0&&(t+=o),t<0?t=0:t>o&&(t=o),null==e||e>o-t?e=o-t:e<0&&(e=0);const i=o-e+r.length,l=new n.constructor(i);let u=0;for(;u0?0:r-1;for(;o>=0&&ot[t.length-1])return t.length;let e=0,r=t.length-1;for(;r-e!=1;){const o=e+Math.floor((r-e)/2);n>=t[o]?e=o:r=o}return e}e.is_empty=function(n){return 0==n.length},e.copy=function(n){return Array.isArray(n)?n.slice():new n.constructor(n)},e.splice=l,e.head=u,e.insert=function(n,t,e){return l(n,e,0,t)},e.append=function(n,t){return l(n,n.length,0,t)},e.prepend=function(n,t){return l(n,0,0,t)},e.indexOf=function(n,t){for(let e=0,r=n.length;ee&&(e=t);return e},e.minmax=function(n){let t,e=1/0,r=-1/0;for(let o=0,i=n.length;or&&(r=t));return[e,r]},e.min_by=function(n,t){if(0==n.length)throw new Error(\"min_by() called with an empty array\");let e=n[0],r=t(e);for(let o=1,i=n.length;or&&(e=i,r=l)}return e},e.sum=function(n){let t=0;for(let e=0,r=n.length;et[r]=n+e),0),t},e.every=function(n,t){for(let e=0,r=n.length;e(n-t)/r))}},\n", + " function _(t,e,n,c,o){c();const s=t(9),{hasOwnProperty:r}=Object.prototype;function u(t){return Object.keys(t).length}n.keys=Object.keys,n.values=Object.values,n.entries=Object.entries,n.extend=Object.assign,n.clone=function(t){return Object.assign({},t)},n.merge=function(t,e){const n=Object.create(Object.prototype),c=s.concat([Object.keys(t),Object.keys(e)]);for(const o of c){const c=r.call(t,o)?t[o]:[],u=r.call(e,o)?e[o]:[];n[o]=s.union(c,u)}return n},n.size=u,n.isEmpty=function(t){return 0==u(t)},n.to_object=function(t){const e={};for(const[n,c]of t)e[n]=c;return e}},\n", + " function _(t,e,s,n,r){n();const i=t(1),o=t(15),c=t(17),a=i.__importStar(t(18)),_=i.__importStar(t(21)),h=t(34),u=t(13),l=t(8),f=t(26),p=t(30),d=t(35),g=t(26),y=t(36),v=t(37),m=i.__importStar(t(21));class b extends(o.Signalable()){constructor(t={}){var e,s;super(),this._subtype=void 0,this.document=null,this.destroyed=new o.Signal0(this,\"destroyed\"),this.change=new o.Signal0(this,\"change\"),this.transformchange=new o.Signal0(this,\"transformchange\"),this.exprchange=new o.Signal0(this,\"exprchange\"),this.properties={},this._pending=!1,this._changing=!1;const n=t instanceof Map?t.get.bind(t):e=>t[e];this.id=null!==(e=n(\"id\"))&&void 0!==e?e:h.uniqueId();for(const[t,{type:e,default_value:s,options:r}]of u.entries(this._props)){let i;e instanceof a.PropertyAlias?Object.defineProperty(this.properties,t,{get:()=>this.properties[e.attr],configurable:!1,enumerable:!1}):(i=e instanceof _.Kind?new a.PrimitiveProperty(this,t,e,s,n(t),r):new e(this,t,_.Any,s,n(t),r),this.properties[t]=i)}null!==(s=n(\"__deferred__\"))&&void 0!==s&&s||(this.finalize(),this.connect_signals())}get is_syncable(){return!0}set type(t){console.warn(\"prototype.type = 'ModelName' is deprecated, use static __name__ instead\"),this.constructor.__name__=t}get type(){return this.constructor.__qualified__}static get __qualified__(){const{__module__:t,__name__:e}=this;return null!=t?`${t}.${e}`:e}static get[Symbol.toStringTag](){return this.__name__}static init_HasProps(){this.prototype._props={},this.prototype._mixins=[]}static _fix_default(t,e){if(void 0===t||l.isFunction(t))return t;if(l.isPrimitive(t))return()=>t;{const e=new v.Cloner;return()=>e.clone(t)}}static define(t){for(const[e,s]of u.entries(l.isFunction(t)?t(m):t)){if(null!=this.prototype._props[e])throw new Error(`attempted to redefine property '${this.prototype.type}.${e}'`);if(null!=this.prototype[e])throw new Error(`attempted to redefine attribute '${this.prototype.type}.${e}'`);Object.defineProperty(this.prototype,e,{get(){return this.properties[e].get_value()},set(t){return this.setv({[e]:t}),this},configurable:!1,enumerable:!0});const[t,n,r={}]=s,i={type:t,default_value:this._fix_default(n,e),options:r},o=Object.assign({},this.prototype._props);o[e]=i,this.prototype._props=o}}static internal(t){const e={};for(const[s,n]of u.entries(l.isFunction(t)?t(m):t)){const[t,r,i={}]=n;e[s]=[t,r,Object.assign(Object.assign({},i),{internal:!0})]}this.define(e)}static mixins(t){function e(t,e){const s={};for(const[n,r]of u.entries(e))s[t+n]=r;return s}const s={},n=[];for(const r of l.isArray(t)?t:[t])if(l.isArray(r)){const[t,i]=r;u.extend(s,e(t,i)),n.push([t,i])}else{const t=r;u.extend(s,t),n.push([\"\",t])}this.define(s),this.prototype._mixins=[...this.prototype._mixins,...n]}static override(t){for(const[e,s]of u.entries(t)){const t=this._fix_default(s,e),n=this.prototype._props[e];if(null==n)throw new Error(`attempted to override nonexistent '${this.prototype.type}.${e}'`);const r=Object.assign({},this.prototype._props);r[e]=Object.assign(Object.assign({},n),{default_value:t}),this.prototype._props=r}}toString(){return`${this.type}(${this.id})`}property(t){const e=this.properties[t];if(null!=e)return e;throw new Error(`unknown property ${this.type}.${t}`)}get attributes(){const t={};for(const e of this)t[e.attr]=e.get_value();return t}[v.clone](t){const e=new Map;for(const s of this)s.dirty&&e.set(s.attr,t.clone(s.get_value()));return new this.constructor(e)}[g.equals](t,e){for(const s of this){const n=t.property(s.attr);if(e.eq(s.get_value(),n.get_value()))return!1}return!0}[y.pretty](t){const e=t.token,s=[];for(const n of this)if(n.dirty){const r=n.get_value();s.push(`${n.attr}${e(\":\")} ${t.to_string(r)}`)}return`${this.constructor.__qualified__}${e(\"(\")}${e(\"{\")}${s.join(`${e(\",\")} `)}${e(\"}\")}${e(\")\")}`}[p.serialize](t){const e=this.ref();t.add_ref(this,e);const s=this.struct();for(const e of this)e.syncable&&(t.include_defaults||e.dirty)&&(s.attributes[e.attr]=t.to_serializable(e.get_value()));return t.add_def(this,s),e}finalize(){for(const t of this){if(!(t instanceof a.VectorSpec||t instanceof a.ScalarSpec))continue;const e=t.get_value();if(null!=e){const{transform:t,expr:s}=e;null!=t&&this.connect(t.change,(()=>this.transformchange.emit())),null!=s&&this.connect(s.change,(()=>this.exprchange.emit()))}}this.initialize()}initialize(){}connect_signals(){}disconnect_signals(){o.Signal.disconnectReceiver(this)}destroy(){this.disconnect_signals(),this.destroyed.emit()}clone(){return(new v.Cloner).clone(this)}_setv(t,e){const s=e.check_eq,n=[],r=this._changing;this._changing=!0;for(const[e,r]of t)!1!==s&&f.is_equal(e.get_value(),r)||(e.set_value(r),n.push(e));n.length>0&&(this._pending=!0);for(const t of n)t.change.emit();if(!r){if(!e.no_change)for(;this._pending;)this._pending=!1,this.change.emit();this._pending=!1,this._changing=!1}}setv(t,e={}){const s=u.entries(t);if(0==s.length)return;if(!0===e.silent){for(const[t,e]of s)this.properties[t].set_value(e);return}const n=new Map,r=new Map;for(const[t,e]of s){const s=this.properties[t];n.set(s,e),r.set(s,s.get_value())}this._setv(n,e);const{document:i}=this;if(null!=i){const t=[];for(const[e,s]of r)t.push([e,s,e.get_value()]);for(const[,e,s]of t)if(this._needs_invalidate(e,s)){i._invalidate_all_models();break}this._push_changes(t,e)}}getv(t){return this.property(t).get_value()}ref(){return{id:this.id}}struct(){const t={type:this.type,id:this.id,attributes:{}};return null!=this._subtype&&(t.subtype=this._subtype),t}set_subtype(t){this._subtype=t}*[Symbol.iterator](){yield*u.values(this.properties)}*syncable_properties(){for(const t of this)t.syncable&&(yield t)}serializable_attributes(){const t={};for(const e of this.syncable_properties())t[e.attr]=e.get_value();return t}static _json_record_references(t,e,s,n){const{recursive:r}=n;if(c.is_ref(e)){const n=t.get_model_by_id(e.id);null==n||s.has(n)||b._value_record_references(n,s,{recursive:r})}else if(l.isArray(e))for(const n of e)b._json_record_references(t,n,s,{recursive:r});else if(l.isPlainObject(e))for(const n of u.values(e))b._json_record_references(t,n,s,{recursive:r})}static _value_record_references(t,e,s){const{recursive:n}=s;if(t instanceof b){if(!e.has(t)&&(e.add(t),n))for(const s of t.syncable_properties()){const t=s.get_value();b._value_record_references(t,e,{recursive:n})}}else if(l.isArray(t))for(const s of t)b._value_record_references(s,e,{recursive:n});else if(l.isPlainObject(t))for(const s of u.values(t))b._value_record_references(s,e,{recursive:n})}references(){const t=new Set;return b._value_record_references(this,t,{recursive:!0}),t}_doc_attached(){}_doc_detached(){}attach_document(t){if(null!=this.document&&this.document!=t)throw new Error(\"models must be owned by only a single document\");this.document=t,this._doc_attached()}detach_document(){this._doc_detached(),this.document=null}_needs_invalidate(t,e){const s=new Set;b._value_record_references(e,s,{recursive:!1});const n=new Set;b._value_record_references(t,n,{recursive:!1});for(const t of s)if(!n.has(t))return!0;for(const t of n)if(!s.has(t))return!0;return!1}_push_changes(t,e={}){if(!this.is_syncable)return;const{document:s}=this;if(null==s)return;const{setter_id:n}=e,r=[];for(const[e,i,o]of t)e.syncable&&r.push(new d.ModelChangedEvent(s,this,e.attr,i,o,n));if(0!=r.length){let t;1==r.length?[t]=r:t=new d.DocumentEventBatch(s,r,n),s._trigger_on_change(t)}}on_change(t,e){for(const s of l.isArray(t)?t:[t])this.connect(s.change,e)}}s.HasProps=b,b.init_HasProps()},\n", + " function _(n,t,e,l,s){l();const i=n(16),o=n(9);class c{constructor(n,t){this.sender=n,this.name=t}connect(n,t=null){u.has(this.sender)||u.set(this.sender,[]);const e=u.get(this.sender);if(null!=g(e,this,n,t))return!1;const l=null!=t?t:n;a.has(l)||a.set(l,[]);const s=a.get(l),i={signal:this,slot:n,context:t};return e.push(i),s.push(i),!0}disconnect(n,t=null){const e=u.get(this.sender);if(null==e||0===e.length)return!1;const l=g(e,this,n,t);if(null==l)return!1;const s=null!=t?t:n,i=a.get(s);return l.signal=null,d(e),d(i),!0}emit(n){var t;const e=null!==(t=u.get(this.sender))&&void 0!==t?t:[];for(const{signal:t,slot:l,context:s}of e)t===this&&l.call(s,n,this.sender)}}e.Signal=c,c.__name__=\"Signal\";class r extends c{emit(){super.emit(void 0)}}e.Signal0=r,r.__name__=\"Signal0\",function(n){function t(n,t){const e=u.get(n);if(null==e||0===e.length)return;const l=a.get(t);if(null!=l&&0!==l.length){for(const t of l){if(null==t.signal)return;t.signal.sender===n&&(t.signal=null)}d(e),d(l)}}function e(n){var t;const e=u.get(n);if(null!=e&&0!==e.length){for(const n of e){if(null==n.signal)return;const e=null!==(t=n.context)&&void 0!==t?t:n.slot;n.signal=null,d(a.get(e))}d(e)}}function l(n,t,e){const l=a.get(n);if(null!=l&&0!==l.length){for(const n of l){if(null==n.signal)return;if(null!=t&&n.slot!=t)continue;const l=n.signal.sender;null!=e&&e.has(l)||(n.signal=null,d(u.get(l)))}d(l)}}function s(n){const t=u.get(n);if(null!=t&&0!==t.length){for(const n of t)n.signal=null;d(t)}const e=a.get(n);if(null!=e&&0!==e.length){for(const n of e)n.signal=null;d(e)}}n.disconnect_between=t,n.disconnect_sender=e,n.disconnect_receiver=l,n.disconnect_all=s,n.disconnectBetween=t,n.disconnectSender=e,n.disconnectReceiver=l,n.disconnectAll=s}(c||(e.Signal=c={})),e.Signalable=function(){return class{connect(n,t){return n.connect(t,this)}disconnect(n,t){return n.disconnect(t,this)}}};const u=new WeakMap,a=new WeakMap;function g(n,t,e,l){return o.find(n,(n=>n.signal===t&&n.slot===e&&n.context===l))}const f=new Set;function d(n){0===f.size&&(async()=>{await i.defer(),function(){for(const n of f)o.remove_by(n,(n=>null==n.signal));f.clear()}()})(),f.add(n)}},\n", + " function _(e,n,t,s,o){s();const a=new MessageChannel,l=new Map;a.port1.onmessage=e=>{const n=e.data,t=l.get(n);if(null!=t)try{t()}finally{l.delete(n)}};let r=1;t.defer=function(){return new Promise((e=>{const n=r++;l.set(n,e),a.port2.postMessage(n)}))}},\n", + " function _(n,t,i,e,c){e();const r=n(8),s=n(13);i.is_ref=function(n){if(r.isPlainObject(n)){const t=s.keys(n);return 1==t.length&&\"id\"==t[0]}return!1}},\n", + " function _(e,t,n,a,r){a(),n.YCoordinateSeqSeqSeqSpec=n.XCoordinateSeqSeqSeqSpec=n.YCoordinateSeqSpec=n.XCoordinateSeqSpec=n.YCoordinateSpec=n.XCoordinateSpec=n.CoordinateSeqSeqSeqSpec=n.CoordinateSeqSpec=n.CoordinateSpec=n.BaseCoordinateSpec=n.NumberUnitsSpec=n.UnitsSpec=n.DataSpec=n.VectorSpec=n.TextBaselineScalar=n.TextAlignScalar=n.FontStyleScalar=n.FontSizeScalar=n.FontScalar=n.LineDashScalar=n.LineCapScalar=n.LineJoinScalar=n.ArrayScalar=n.NullStringScalar=n.StringScalar=n.NumberScalar=n.ColorScalar=n.AnyScalar=n.ScalarSpec=n.VerticalAlign=n.UpdateMode=n.TooltipAttachment=n.TickLabelOrientation=n.TextureRepetition=n.TextBaseline=n.TextAlign=n.TapBehavior=n.StepMode=n.StartEnd=n.SpatialUnits=n.Sort=n.SizingMode=n.Side=n.RoundingFunction=n.ResetPolicy=n.RenderMode=n.RenderLevel=n.RadiusDimension=n.PointPolicy=n.Place=void 0,n.TextBaselineSpec=n.TextAlignSpec=n.FontStyleSpec=n.FontSizeSpec=n.FontSpec=n.LineDashSpec=n.LineCapSpec=n.LineJoinSpec=n.MarkerSpec=n.ArraySpec=n.NullStringSpec=n.StringSpec=n.AnySpec=n.NDArraySpec=n.ColorSpec=n.NumberSpec=n.BooleanSpec=n.ScreenDistanceSpec=n.NullDistanceSpec=n.DistanceSpec=n.AngleSpec=void 0;const i=e(1),s=e(15),l=e(19),o=i.__importStar(e(20)),c=e(24),_=e(9),u=e(12),d=e(10),S=e(22),p=e(27),m=e(8),h=e(28),v=e(29),y=e(33);function x(e){try{return JSON.stringify(e)}catch(t){return e.toString()}}function g(e){return m.isPlainObject(e)&&(void 0===e.value?0:1)+(void 0===e.field?0:1)+(void 0===e.expr?0:1)==1}r(\"Uniform\",y.Uniform),r(\"UniformScalar\",y.UniformScalar),r(\"UniformVector\",y.UniformVector),n.isSpec=g;class f{constructor(e,t,n,a,r,i={}){var l;let o;if(this.obj=e,this.attr=t,this.kind=n,this.default_value=a,this._dirty=!1,this.change=new s.Signal0(this.obj,\"change\"),this.internal=null!==(l=i.internal)&&void 0!==l&&l,this.on_update=i.on_update,void 0!==r)o=r,this._dirty=!0;else{const t=this._default_override();if(void 0!==t)o=t;else{if(void 0===a)return void(this.spec={value:null});o=a(e)}}this._update(o)}get is_value(){return void 0!==this.spec.value}get syncable(){return!this.internal}get_value(){return this.spec.value}set_value(e){this._update(e),this._dirty=!0}_default_override(){}get dirty(){return this._dirty}_update(e){var t;this.validate(e),this.spec={value:e},null===(t=this.on_update)||void 0===t||t.call(this,e,this.obj)}toString(){return`Prop(${this.obj}.${this.attr}, spec: ${x(this.spec)})`}normalize(e){return e}validate(e){if(!this.valid(e))throw new Error(`${this.obj}.${this.attr} given invalid value: ${x(e)}`)}valid(e){return this.kind.valid(e)}_value(e=!0){if(!this.is_value)throw new Error(\"attempted to retrieve property value for property without value specification\");let t=this.normalize([this.spec.value])[0];return null!=this.spec.transform&&e&&(t=this.spec.transform.compute(t)),t}}n.Property=f,f.__name__=\"Property\";class A{constructor(e){this.attr=e}}n.PropertyAlias=A,A.__name__=\"PropertyAlias\",n.Alias=function(e){return new A(e)};class C extends f{}n.PrimitiveProperty=C,C.__name__=\"PrimitiveProperty\";class L extends f{}n.Any=L,L.__name__=\"Any\";class T extends f{valid(e){return m.isArray(e)||m.isTypedArray(e)}}n.Array=T,T.__name__=\"Array\";class P extends f{valid(e){return m.isBoolean(e)}}n.Boolean=P,P.__name__=\"Boolean\";class b extends f{valid(e){return S.is_Color(e)}}n.Color=b,b.__name__=\"Color\";class w extends f{}n.Instance=w,w.__name__=\"Instance\";class q extends f{valid(e){return m.isNumber(e)}}n.Number=q,q.__name__=\"Number\";class N extends q{valid(e){return m.isNumber(e)&&(0|e)==e}}n.Int=N,N.__name__=\"Int\";class B extends q{}n.Angle=B,B.__name__=\"Angle\";class D extends q{valid(e){return m.isNumber(e)&&0<=e&&e<=1}}n.Percent=D,D.__name__=\"Percent\";class F extends f{valid(e){return m.isString(e)}}n.String=F,F.__name__=\"String\";class z extends f{valid(e){return null===e||m.isString(e)}}n.NullString=z,z.__name__=\"NullString\";class U extends F{}n.FontSize=U,U.__name__=\"FontSize\";class M extends F{_default_override(){return h.settings.dev?\"Bokeh\":void 0}}n.Font=M,M.__name__=\"Font\";class R extends f{valid(e){return m.isString(e)&&_.includes(this.enum_values,e)}}function k(e){return class extends R{get enum_values(){return[...e]}}}n.EnumProperty=R,R.__name__=\"EnumProperty\",n.Enum=k;class O extends R{get enum_values(){return[...o.Direction]}normalize(e){const t=new Uint8Array(e.length);for(let n=0;n0){let o=r[e];return null==o&&(r[e]=o=new v(e,l)),o}throw new TypeError(\"Logger.get() expects a non-empty string name and an optional log-level\")}get level(){return this.get_level()}get_level(){return this._log_level}set_level(e){if(e instanceof i)this._log_level=e;else{if(!s.isString(e)||null==v.log_levels[e])throw new Error(\"Logger.set_level() expects a log-level object or a string name of a log-level\");this._log_level=v.log_levels[e]}const l=`[${this._name}]`;for(const[e,o]of g.entries(v.log_levels))o.level\",\"*\"),t.HTTPMethod=a.Enum(\"POST\",\"GET\"),t.HexTileOrientation=a.Enum(\"pointytop\",\"flattop\"),t.HoverMode=a.Enum(\"mouse\",\"hline\",\"vline\"),t.LatLon=a.Enum(\"lat\",\"lon\"),t.LegendClickPolicy=a.Enum(\"none\",\"hide\",\"mute\"),t.LegendLocation=t.Anchor,t.LineCap=a.Enum(\"butt\",\"round\",\"square\"),t.LineJoin=a.Enum(\"miter\",\"round\",\"bevel\"),t.LineDash=a.Enum(\"solid\",\"dashed\",\"dotted\",\"dotdash\",\"dashdot\"),t.LinePolicy=a.Enum(\"prev\",\"next\",\"nearest\",\"interp\",\"none\"),t.Location=a.Enum(\"above\",\"below\",\"left\",\"right\"),t.Logo=a.Enum(\"normal\",\"grey\"),t.MarkerType=a.Enum(\"asterisk\",\"circle\",\"circle_cross\",\"circle_dot\",\"circle_x\",\"circle_y\",\"cross\",\"dash\",\"diamond\",\"diamond_cross\",\"diamond_dot\",\"dot\",\"hex\",\"hex_dot\",\"inverted_triangle\",\"plus\",\"square\",\"square_cross\",\"square_dot\",\"square_pin\",\"square_x\",\"star\",\"star_dot\",\"triangle\",\"triangle_dot\",\"triangle_pin\",\"x\",\"y\"),t.MutedPolicy=a.Enum(\"show\",\"ignore\"),t.Orientation=a.Enum(\"vertical\",\"horizontal\"),t.OutputBackend=a.Enum(\"canvas\",\"svg\",\"webgl\"),t.PaddingUnits=a.Enum(\"percent\",\"absolute\"),t.Place=a.Enum(\"above\",\"below\",\"left\",\"right\",\"center\"),t.PointPolicy=a.Enum(\"snap_to_data\",\"follow_mouse\",\"none\"),t.RadiusDimension=a.Enum(\"x\",\"y\",\"max\",\"min\"),t.RenderLevel=a.Enum(\"image\",\"underlay\",\"glyph\",\"guide\",\"annotation\",\"overlay\"),t.RenderMode=a.Enum(\"canvas\",\"css\"),t.ResetPolicy=a.Enum(\"standard\",\"event_only\"),t.RoundingFunction=a.Enum(\"round\",\"nearest\",\"floor\",\"rounddown\",\"ceil\",\"roundup\"),t.SelectionMode=a.Enum(\"replace\",\"append\",\"intersect\",\"subtract\"),t.Side=a.Enum(\"above\",\"below\",\"left\",\"right\"),t.SizingMode=a.Enum(\"stretch_width\",\"stretch_height\",\"stretch_both\",\"scale_width\",\"scale_height\",\"scale_both\",\"fixed\"),t.Sort=a.Enum(\"ascending\",\"descending\"),t.SpatialUnits=a.Enum(\"screen\",\"data\"),t.StartEnd=a.Enum(\"start\",\"end\"),t.StepMode=a.Enum(\"after\",\"before\",\"center\"),t.TapBehavior=a.Enum(\"select\",\"inspect\"),t.TextAlign=a.Enum(\"left\",\"right\",\"center\"),t.TextBaseline=a.Enum(\"top\",\"middle\",\"bottom\",\"alphabetic\",\"hanging\",\"ideographic\"),t.TextureRepetition=a.Enum(\"repeat\",\"repeat_x\",\"repeat_y\",\"no_repeat\"),t.TickLabelOrientation=a.Enum(\"vertical\",\"horizontal\",\"parallel\",\"normal\"),t.TooltipAttachment=a.Enum(\"horizontal\",\"vertical\",\"left\",\"right\",\"above\",\"below\"),t.UpdateMode=a.Enum(\"replace\",\"append\"),t.VerticalAlign=a.Enum(\"top\",\"middle\",\"bottom\")},\n", + " function _(e,n,t,s,r){s();const i=e(1).__importStar(e(8)),a=e(22),l=e(13),_=window.Map,{hasOwnProperty:u}=Object.prototype;class d{}t.Kind=d,d.__name__=\"Kind\",function(e){class n extends d{valid(e){return!0}}n.__name__=\"Any\",e.Any=n;class t extends d{valid(e){return!0}}t.__name__=\"Unknown\",e.Unknown=t;class s extends d{valid(e){return i.isBoolean(e)}}s.__name__=\"Boolean\",e.Boolean=s;class r extends d{constructor(e){super(),this.obj_type=e}valid(e){return!0}}r.__name__=\"Ref\",e.Ref=r;class c extends d{valid(e){return!0}}c.__name__=\"AnyRef\",e.AnyRef=c;class o extends d{valid(e){return i.isNumber(e)}}o.__name__=\"Number\",e.Number=o;class p extends o{valid(e){return super.valid(e)&&i.isInteger(e)}}p.__name__=\"Int\",e.Int=p;class y extends o{valid(e){return super.valid(e)&&0<=e&&e<=1}}y.__name__=\"Percent\",e.Percent=y;class m extends d{constructor(e){super(),this.types=e,this.types=e}valid(e){return this.types.some((n=>n.valid(e)))}}m.__name__=\"Or\",e.Or=m;class v extends d{constructor(e){super(),this.types=e,this.types=e}valid(e){if(!i.isArray(e))return!1;for(let n=0;nthis.item_type.valid(e)))}}f.__name__=\"Array\",e.Array=f;class K extends d{valid(e){return null===e}}K.__name__=\"Null\",e.Null=K;class b extends d{constructor(e){super(),this.base_type=e}valid(e){return null===e||this.base_type.valid(e)}}b.__name__=\"Nullable\",e.Nullable=b;class A extends d{constructor(e){super(),this.base_type=e}valid(e){return void 0===e||this.base_type.valid(e)}}A.__name__=\"Opt\",e.Opt=A;class x extends d{valid(e){return i.isString(e)}}x.__name__=\"String\",e.String=x;class S extends d{constructor(e){super(),this.values=new Set(e)}valid(e){return this.values.has(e)}*[Symbol.iterator](){yield*this.values}}S.__name__=\"Enum\",e.Enum=S;class N extends d{constructor(e){super(),this.item_type=e}valid(e){if(!i.isPlainObject(e))return!1;for(const n in e)if(u.call(e,n)){const t=e[n];if(!this.item_type.valid(t))return!1}return!0}}N.__name__=\"Dict\",e.Dict=N;class O extends d{constructor(e,n){super(),this.key_type=e,this.item_type=n}valid(e){if(!(e instanceof _))return!1;for(const[n,t]of e.entries())if(!this.key_type.valid(n)||!this.item_type.valid(t))return!1;return!0}}O.__name__=\"Map\",e.Map=O;class g extends d{valid(e){return a.is_Color(e)}}g.__name__=\"Color\",e.Color=g;class P extends d{valid(e){return i.isFunction(e)}}P.__name__=\"Function\",e.Function=P}(t.Kinds||(t.Kinds={})),t.Any=new t.Kinds.Any,t.Unknown=new t.Kinds.Unknown,t.Boolean=new t.Kinds.Boolean,t.Number=new t.Kinds.Number,t.Int=new t.Kinds.Int,t.String=new t.Kinds.String,t.Null=new t.Kinds.Null;t.Nullable=e=>new t.Kinds.Nullable(e);t.Opt=e=>new t.Kinds.Opt(e);t.Or=(...e)=>new t.Kinds.Or(e);t.Tuple=(...e)=>new t.Kinds.Tuple(e);t.Struct=e=>new t.Kinds.Struct(e),t.Arrayable=new t.Kinds.Arrayable;t.Array=e=>new t.Kinds.Array(e);t.Dict=e=>new t.Kinds.Dict(e);t.Map=(e,n)=>new t.Kinds.Map(e,n);t.Enum=(...e)=>new t.Kinds.Enum(e);t.Ref=e=>new t.Kinds.Ref(e);t.AnyRef=()=>new t.Kinds.AnyRef;t.Function=()=>new t.Kinds.Function,t.Percent=new t.Kinds.Percent,t.Alpha=t.Percent,t.Color=new t.Kinds.Color,t.Auto=t.Enum(\"auto\"),t.FontSize=t.String,t.Font=t.String,t.Angle=t.Number},\n", + " function _(n,t,r,e,s){e();const u=n(23),c=n(10),l=n(8),{round:i}=Math;function o(n){return c.clamp(i(n),0,255)}function a(){return[0,0,0,0]}function f(n){return[n>>24&255,n>>16&255,n>>8&255,255&n]}function d(n,t){var r;let e,s,u,c;return null==n?[e,s,u,c]=[0,0,0,0]:l.isInteger(n)?[e,s,u,c]=f(n):l.isString(n)?[e,s,u,c]=null!==(r=_(n))&&void 0!==r?r:[0,0,0,0]:([e,s,u,c=1]=n,c=o(255*c)),255==c&&null!=t&&(c=o(255*t)),[e,s,u,c]}r.transparent=a,r.encode_rgba=function([n,t,r,e]){return n<<24|t<<16|r<<8|e},r.decode_rgba=f,r.compose_alpha=function(n,t){return 255==(255&n)?4294967040&n|o(255*t):n},r.color2rgba=d;const h={0:\"0\",1:\"1\",2:\"2\",3:\"3\",4:\"4\",5:\"5\",6:\"6\",7:\"7\",8:\"8\",9:\"9\",10:\"a\",11:\"b\",12:\"c\",13:\"d\",14:\"e\",15:\"f\"};function g(n){return h[n>>4]+h[15&n]}r.color2css=function(n,t){const[r,e,s,u]=d(n,t);return`rgba(${r}, ${e}, ${s}, ${u/255})`},r.color2hex=function(n,t){const[r,e,s,u]=d(n,t),c=`#${g(r)}${g(e)}${g(s)}`;return 255==u?c:`${c}${g(u)}`},r.color2hexrgb=function(n){const[t,r,e]=d(n);return`#${g(t)}${g(r)}${g(e)}`};const b=/^rgba?\\(\\s*([^\\s,]+?)\\s+([^\\s,]+?)\\s+([^\\s,]+?)(?:\\s*\\/\\s*([^\\s,]+?))?\\s*\\)$/,m=/^rgba?\\(\\s*([^\\s,]+?)\\s*,\\s*([^\\s,]+?)\\s*,\\s*([^\\s,]+?)(?:\\s*,\\s*([^\\s,]+?))?\\s*\\)$/,$=(()=>{const n=document.createElement(\"canvas\");n.width=1,n.height=1;const t=n.getContext(\"2d\"),r=t.createLinearGradient(0,0,1,1);return n=>{t.fillStyle=r,t.fillStyle=n;const e=t.fillStyle;return e!=r?e:null}})();function _(n){var t;if(!(n=n.trim().toLowerCase()))return null;if(\"transparent\"==n)return[0,0,0,0];if(u.is_named_color(n))return f(u.named_colors[n]);if(\"#\"==n[0]){const t=Number(\"0x\"+n.substr(1));if(isNaN(t))return null;switch(n.length-1){case 3:{const n=t>>8&15,r=t>>4&15,e=t>>0&15;return[n<<4|n,r<<4|r,e<<4|e,255]}case 4:{const n=t>>12&15,r=t>>8&15,e=t>>4&15,s=t>>0&15;return[n<<4|n,r<<4|r,e<<4|e,s<<4|s]}case 6:return[t>>16&255,t>>8&255,t>>0&255,255];case 8:return[t>>24&255,t>>16&255,t>>8&255,t>>0&255]}}else if(n.startsWith(\"rgb\")){const r=null!==(t=n.match(b))&&void 0!==t?t:n.match(m);if(null!=r){let[,n,t,e,s=\"1\"]=r;const u=n.endsWith(\"%\"),c=t.endsWith(\"%\"),l=e.endsWith(\"%\"),i=s.endsWith(\"%\");if(!(u&&c&&l)&&(u||c||l))return null;u&&(n=n.slice(0,-1)),c&&(t=t.slice(0,-1)),l&&(e=e.slice(0,-1)),i&&(s=s.slice(0,-1));let a=Number(n),f=Number(t),d=Number(e),h=Number(s);return isNaN(a+f+d+h)?null:(u&&(a=a/100*255),c&&(f=f/100*255),l&&(d=d/100*255),h=255*(i?h/100:h),a=o(a),f=o(f),d=o(d),h=o(h),[a,f,d,h])}}else{const t=$(n);if(null!=t)return _(t)}return null}r.css4_parse=_,r.is_Color=function(n){return!!l.isInteger(n)||(!(!l.isString(n)||null==_(n))||!(!l.isArray(n)||3!=n.length&&4!=n.length))},r.is_dark=function([n,t,r]){return 1-(.299*n+.587*t+.114*r)/255>=.6}},\n", + " function _(e,r,l,a,i){a();l.named_colors={aliceblue:4042850303,antiquewhite:4209760255,aqua:16777215,aquamarine:2147472639,azure:4043309055,beige:4126530815,bisque:4293182719,black:255,blanchedalmond:4293643775,blue:65535,blueviolet:2318131967,brown:2771004159,burlywood:3736635391,cadetblue:1604231423,chartreuse:2147418367,chocolate:3530104575,coral:4286533887,cornflowerblue:1687547391,cornsilk:4294499583,crimson:3692313855,cyan:16777215,darkblue:35839,darkcyan:9145343,darkgoldenrod:3095792639,darkgray:2846468607,darkgreen:6553855,darkgrey:2846468607,darkkhaki:3182914559,darkmagenta:2332068863,darkolivegreen:1433087999,darkorange:4287365375,darkorchid:2570243327,darkred:2332033279,darksalmon:3918953215,darkseagreen:2411499519,darkslateblue:1211993087,darkslategray:793726975,darkslategrey:793726975,darkturquoise:13554175,darkviolet:2483082239,deeppink:4279538687,deepskyblue:12582911,dimgray:1768516095,dimgrey:1768516095,dodgerblue:512819199,firebrick:2988581631,floralwhite:4294635775,forestgreen:579543807,fuchsia:4278255615,gainsboro:3705462015,ghostwhite:4177068031,gold:4292280575,goldenrod:3668254975,gray:2155905279,green:8388863,greenyellow:2919182335,grey:2155905279,honeydew:4043305215,hotpink:4285117695,indianred:3445382399,indigo:1258324735,ivory:4294963455,khaki:4041641215,lavender:3873897215,lavenderblush:4293981695,lawngreen:2096890111,lemonchiffon:4294626815,lightblue:2916673279,lightcoral:4034953471,lightcyan:3774873599,lightgoldenrodyellow:4210742015,lightgray:3553874943,lightgreen:2431553791,lightgrey:3553874943,lightpink:4290167295,lightsalmon:4288707327,lightseagreen:548580095,lightskyblue:2278488831,lightslategray:2005441023,lightslategrey:2005441023,lightsteelblue:2965692159,lightyellow:4294959359,lime:16711935,limegreen:852308735,linen:4210091775,magenta:4278255615,maroon:2147483903,mediumaquamarine:1724754687,mediumblue:52735,mediumorchid:3126187007,mediumpurple:2473647103,mediumseagreen:1018393087,mediumslateblue:2070474495,mediumspringgreen:16423679,mediumturquoise:1221709055,mediumvioletred:3340076543,midnightblue:421097727,mintcream:4127193855,mistyrose:4293190143,moccasin:4293178879,navajowhite:4292783615,navy:33023,oldlace:4260751103,olive:2155872511,olivedrab:1804477439,orange:4289003775,orangered:4282712319,orchid:3664828159,palegoldenrod:4008225535,palegreen:2566625535,paleturquoise:2951671551,palevioletred:3681588223,papayawhip:4293907967,peachpuff:4292524543,peru:3448061951,pink:4290825215,plum:3718307327,powderblue:2967529215,purple:2147516671,rebeccapurple:1714657791,red:4278190335,rosybrown:3163525119,royalblue:1097458175,saddlebrown:2336560127,salmon:4202722047,sandybrown:4104413439,seagreen:780883967,seashell:4294307583,sienna:2689740287,silver:3233857791,skyblue:2278484991,slateblue:1784335871,slategray:1887473919,slategrey:1887473919,snow:4294638335,springgreen:16744447,steelblue:1182971135,tan:3535047935,teal:8421631,thistle:3636451583,tomato:4284696575,turquoise:1088475391,violet:4001558271,wheat:4125012991,white:4294967295,whitesmoke:4126537215,yellow:4294902015,yellowgreen:2597139199},l.is_named_color=function(e){return e in l.named_colors}},\n", + " function _(r,t,n,a,o){a(),n.GeneratorFunction=Object.getPrototypeOf((function*(){})).constructor,n.ColorArray=Uint32Array,n.RGBAArray=Uint8ClampedArray,n.infer_type=function(r,t){return r instanceof Float64Array||r instanceof Array||t instanceof Float64Array||t instanceof Array?Float64Array:Float32Array},n.ScreenArray=Float32Array,n.to_screen=function(r){return r instanceof Float32Array?r:new Float32Array(r)},o(\"Indices\",r(25).BitSet)},\n", + " function _(t,s,r,e,i){e();const n=t(26),o=t(11);class a{constructor(t,s=0){this.size=t,this[Symbol.toStringTag]=\"BitSet\",this._count=null,this._nwords=Math.ceil(t/32),0==s||1==s?(this._array=new Uint32Array(this._nwords),1==s&&this._array.fill(4294967295)):(o.assert(s.length==this._nwords,\"Initializer size mismatch\"),this._array=s)}clone(){return new a(this.size,new Uint32Array(this._array))}[n.equals](t,s){if(!s.eq(this.size,t.size))return!1;const{_nwords:r}=this,e=this.size%r,i=0==e?r:r-1;for(let s=0;s>>5,r=31&t;return!!(this._array[s]>>r&1)}set(t,s=!0){this._check_bounds(t),this._count=null;const r=t>>>5,e=31&t;s?this._array[r]|=1<>>t&1&&(e+=1)}return e}*ones(){const{_array:t,_nwords:s,size:r}=this;for(let e=0,i=0;i>>t&1&&(yield e);else e+=32}}*zeros(){const{_array:t,_nwords:s,size:r}=this;for(let e=0,i=0;i>>t&1||(yield e);else e+=32}}_check_size(t){o.assert(this.size==t.size,\"Size mismatch\")}add(t){this._check_size(t);for(let s=0;s{if(a(t)&&a(e))return t[r.equals](e,this);switch(n){case\"[object Array]\":case\"[object Uint8Array]\":case\"[object Int8Array]\":case\"[object Uint16Array]\":case\"[object Int16Array]\":case\"[object Uint32Array]\":case\"[object Int32Array]\":case\"[object Float32Array]\":case\"[object Float64Array]\":return this.arrays(t,e);case\"[object Map]\":return this.maps(t,e);case\"[object Set]\":return this.sets(t,e);case\"[object Object]\":if(t.constructor==e.constructor&&(null==t.constructor||t.constructor===Object))return this.objects(t,e);case\"[object Function]\":if(t.constructor==e.constructor&&t.constructor===Function)return this.eq(`${t}`,`${e}`)}if(t instanceof Node)return this.nodes(t,e);throw Error(`can't compare objects of type ${n}`)})();return s.pop(),o.pop(),u}numbers(t,e){return Object.is(t,e)}arrays(t,e){const{length:r}=t;if(r!=e.length)return!1;for(let n=0;n{const n=navigator.userAgent;return n.includes(\"MSIE\")||n.includes(\"Trident\")||n.includes(\"Edge\")})(),e.is_mobile=\"undefined\"!=typeof window&&(\"ontouchstart\"in window||navigator.maxTouchPoints>0),e.is_little_endian=(()=>{const n=new ArrayBuffer(4),i=new Uint8Array(n);new Uint32Array(n)[1]=168496141;let e=!0;return 10==i[4]&&11==i[5]&&12==i[6]&&13==i[7]&&(e=!1),e})(),e.BYTE_ORDER=e.is_little_endian?\"little\":\"big\",e.to_big_endian=function(n){if(e.is_little_endian){const i=new Uint32Array(n.length),e=new DataView(i.buffer);let t=0;for(const i of n)e.setUint32(t,i),t+=4;return i}return n}},\n", + " function _(e,t,r,i,s){i();class _{constructor(){this._dev=!1,this._wireframe=!1}set dev(e){this._dev=e}get dev(){return this._dev}set wireframe(e){this._wireframe=e}get wireframe(){return this._wireframe}}r.Settings=_,_.__name__=\"Settings\",r.settings=new _},\n", + " function _(t,e,s,r,n){var a,i,h,u,l,c,o,y;r();const p=t(8),_=t(11),A=t(26),d=t(30),D=t(31),N=Symbol(\"__ndarray__\");class f extends Uint8Array{constructor(t,e){super(t),this[a]=!0,this.dtype=\"uint8\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(a=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Uint8NDArray=f,f.__name__=\"Uint8NDArray\";class m extends Int8Array{constructor(t,e){super(t),this[i]=!0,this.dtype=\"int8\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(i=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Int8NDArray=m,m.__name__=\"Int8NDArray\";class g extends Uint16Array{constructor(t,e){super(t),this[h]=!0,this.dtype=\"uint16\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(h=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Uint16NDArray=g,g.__name__=\"Uint16NDArray\";class q extends Int16Array{constructor(t,e){super(t),this[u]=!0,this.dtype=\"int16\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(u=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Int16NDArray=q,q.__name__=\"Int16NDArray\";class I extends Uint32Array{constructor(t,e){super(t),this[l]=!0,this.dtype=\"uint32\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(l=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Uint32NDArray=I,I.__name__=\"Uint32NDArray\";class U extends Int32Array{constructor(t,e){super(t),this[c]=!0,this.dtype=\"int32\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(c=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Int32NDArray=U,U.__name__=\"Int32NDArray\";class w extends Float32Array{constructor(t,e){super(t),this[o]=!0,this.dtype=\"float32\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(o=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}s.Float32NDArray=w,w.__name__=\"Float32NDArray\";class x extends Float64Array{constructor(t,e){super(t),this[y]=!0,this.dtype=\"float64\",this.shape=null!=e?e:z(t)?t.shape:[this.length],this.dimension=this.shape.length}[(y=N,A.equals)](t,e){return e.eq(this.shape,t.shape)&&e.arrays(this,t)}[d.serialize](t){return D.encode_NDArray(this)}}function z(t){return p.isObject(t)&&void 0!==t[N]}s.Float64NDArray=x,x.__name__=\"Float64NDArray\",s.is_NDArray=z,s.ndarray=function(t,e={}){let{dtype:s}=e;null==s&&(s=t instanceof ArrayBuffer||p.isArray(t)?\"float64\":(()=>{switch(!0){case t instanceof Uint8Array:return\"uint8\";case t instanceof Int8Array:return\"int8\";case t instanceof Uint16Array:return\"uint16\";case t instanceof Int16Array:return\"int16\";case t instanceof Uint32Array:return\"uint32\";case t instanceof Int32Array:return\"int32\";case t instanceof Float32Array:return\"float32\";case t instanceof Float64Array:return\"float64\";default:_.unreachable()}})());const{shape:r}=e;switch(s){case\"uint8\":return new f(t,r);case\"int8\":return new m(t,r);case\"uint16\":return new g(t,r);case\"int16\":return new q(t,r);case\"uint32\":return new I(t,r);case\"int32\":return new U(t,r);case\"float32\":return new w(t,r);case\"float64\":return new x(t,r)}}},\n", + " function _(e,r,t,i,s){i();const n=e(11),a=e(13),l=e(8);t.serialize=Symbol(\"serialize\");class o extends Error{}t.SerializationError=o,o.__name__=\"SerializationError\";class f{constructor(e){var r;this._references=new Map,this._definitions=new Map,this._refmap=new Map,this.include_defaults=null===(r=null==e?void 0:e.include_defaults)||void 0===r||r}get_ref(e){return this._references.get(e)}add_ref(e,r){n.assert(!this._references.has(e)),this._references.set(e,r)}add_def(e,r){const t=this.get_ref(e);n.assert(null!=t),this._definitions.set(e,r),this._refmap.set(t,r)}get objects(){return new Set(this._references.keys())}get references(){return new Set(this._references.values())}get definitions(){return new Set(this._definitions.values())}resolve_ref(e){return this._refmap.get(e)}remove_ref(e){return this._references.delete(e)}remove_def(e){return this._definitions.delete(e)}to_serializable(e){const r=this.get_ref(e);if(null!=r)return r;if(function(e){return l.isObject(e)&&void 0!==e[t.serialize]}(e))return e[t.serialize](this);if(l.isArray(e)||l.isTypedArray(e)){const r=e.length,t=new Array(r);for(let i=0;i{switch(t){case\"uint8\":return new u.Uint8NDArray(a,n);case\"int8\":return new u.Int8NDArray(a,n);case\"uint16\":return new u.Uint16NDArray(a,n);case\"int16\":return new u.Int16NDArray(a,n);case\"uint32\":return new u.Uint32NDArray(a,n);case\"int32\":return new u.Int32NDArray(a,n);case\"float32\":return new u.Float32NDArray(a,n);case\"float64\":return new u.Float64NDArray(a,n)}})();return _!==s.BYTE_ORDER&&o.swap(f),f},n.encode_NDArray=function(r,e){const n={order:s.BYTE_ORDER,dtype:r.dtype,shape:r.shape};if(null!=e){const t=`${e.size}`;return e.set(t,r.buffer),Object.assign({__buffer__:t},n)}{const e={toJSON:()=>o.buffer_to_base64(r.buffer)};return Object.assign({__ndarray__:e},n)}}},\n", + " function _(t,e,n,r,f){r(),n.buffer_to_base64=function(t){const e=new Uint8Array(t),n=Array.from(e).map((t=>String.fromCharCode(t)));return btoa(n.join(\"\"))},n.base64_to_buffer=function(t){const e=atob(t),n=e.length,r=new Uint8Array(n);for(let t=0,f=n;t\"'`])/g,(t=>{switch(t){case\"&\":return\"&\";case\"<\":return\"<\";case\">\":return\">\";case'\"':return\""\";case\"'\":return\"'\";case\"`\":return\"`\";default:return t}}))},r.unescape=function(t){return t.replace(/&(amp|lt|gt|quot|#x27|#x60);/g,((t,e)=>{switch(e){case\"amp\":return\"&\";case\"lt\":return\"<\";case\"gt\":return\">\";case\"quot\":return'\"';case\"#x27\":return\"'\";case\"#x60\":return\"`\";default:return e}}))},r.use_strict=function(t){return`'use strict';\\n${t}`},r.to_fixed=function(t,e){return t.toFixed(e).replace(/(\\.[0-9]*?)0+$/,\"$1\").replace(/\\.$/,\"\")}},\n", + " function _(e,t,s,n,o){n();const i=e(30);class r{constructor(e){this.document=e}}s.DocumentEvent=r,r.__name__=\"DocumentEvent\";class a extends r{constructor(e,t,s){super(e),this.events=t,this.setter_id=s}}s.DocumentEventBatch=a,a.__name__=\"DocumentEventBatch\";class d extends r{}s.DocumentChangedEvent=d,d.__name__=\"DocumentChangedEvent\";class l extends d{constructor(e,t,s){super(e),this.msg_type=t,this.msg_data=s}[i.serialize](e){const t=this.msg_data,s=e.to_serializable(t);return{kind:\"MessageSent\",msg_type:this.msg_type,msg_data:s}}}s.MessageSentEvent=l,l.__name__=\"MessageSentEvent\";class _ extends d{constructor(e,t,s,n,o,i,r){super(e),this.model=t,this.attr=s,this.old=n,this.new_=o,this.setter_id=i,this.hint=r}[i.serialize](e){if(null!=this.hint)return e.to_serializable(this.hint);const t=this.new_,s=e.to_serializable(t);return this.model!=t&&e.remove_def(this.model),{kind:\"ModelChanged\",model:this.model.ref(),attr:this.attr,new:s}}}s.ModelChangedEvent=_,_.__name__=\"ModelChangedEvent\";class c extends d{constructor(e,t,s){super(e),this.column_source=t,this.patches=s}[i.serialize](e){return{kind:\"ColumnsPatched\",column_source:this.column_source,patches:this.patches}}}s.ColumnsPatchedEvent=c,c.__name__=\"ColumnsPatchedEvent\";class h extends d{constructor(e,t,s,n){super(e),this.column_source=t,this.data=s,this.rollover=n}[i.serialize](e){return{kind:\"ColumnsStreamed\",column_source:this.column_source,data:this.data,rollover:this.rollover}}}s.ColumnsStreamedEvent=h,h.__name__=\"ColumnsStreamedEvent\";class m extends d{constructor(e,t,s){super(e),this.title=t,this.setter_id=s}[i.serialize](e){return{kind:\"TitleChanged\",title:this.title}}}s.TitleChangedEvent=m,m.__name__=\"TitleChangedEvent\";class u extends d{constructor(e,t,s){super(e),this.model=t,this.setter_id=s}[i.serialize](e){return{kind:\"RootAdded\",model:e.to_serializable(this.model)}}}s.RootAddedEvent=u,u.__name__=\"RootAddedEvent\";class v extends d{constructor(e,t,s){super(e),this.model=t,this.setter_id=s}[i.serialize](e){return{kind:\"RootRemoved\",model:this.model.ref()}}}s.RootRemovedEvent=v,v.__name__=\"RootRemovedEvent\"},\n", + " function _(t,r,n,i,e){i();const s=t(8),o=t(13);n.pretty=Symbol(\"pretty\");class c{constructor(t){this.precision=null==t?void 0:t.precision}to_string(t){return function(t){return s.isObject(t)&&void 0!==t[n.pretty]}(t)?t[n.pretty](this):s.isBoolean(t)?this.boolean(t):s.isNumber(t)?this.number(t):s.isString(t)?this.string(t):s.isArray(t)?this.array(t):s.isIterable(t)?this.iterable(t):s.isPlainObject(t)?this.object(t):`${t}`}token(t){return t}boolean(t){return`${t}`}number(t){return null!=this.precision?t.toFixed(this.precision):`${t}`}string(t){return`\"${t.replace(/'/g,\"\\\\'\")}\"`}array(t){const r=this.token,n=[];for(const r of t)n.push(this.to_string(r));return`${r(\"[\")}${n.join(`${r(\",\")} `)}${r(\"]\")}`}iterable(t){var r;const n=this.token,i=null!==(r=Object(t)[Symbol.toStringTag])&&void 0!==r?r:\"Object\",e=this.array(t);return`${i}${n(\"(\")}${e}${n(\")\")}`}object(t){const r=this.token,n=[];for(const[i,e]of o.entries(t))n.push(`${i}${r(\":\")} ${this.to_string(e)}`);return`${r(\"{\")}${n.join(`${r(\",\")} `)}${r(\"}\")}`}}n.Printer=c,c.__name__=\"Printer\",n.to_string=function(t,r){return new c(r).to_string(t)}},\n", + " function _(n,o,r,e,t){e();const l=n(13),i=n(8);function c(n){return i.isObject(n)&&void 0!==n[r.clone]}r.clone=Symbol(\"clone\"),r.is_Cloneable=c;class s extends Error{}r.CloningError=s,s.__name__=\"CloningError\";class a{constructor(){}clone(n){if(c(n))return n[r.clone](this);if(i.isArray(n)){const o=n.length,r=new Array(o);for(let e=0;e{null!=this.layout&&(this.layout.visible=this.model.visible,this.plot_view.request_layout())}))}get needs_clip(){return null==this.layout}serializable_state(){const t=super.serializable_state();return null==this.layout?t:Object.assign(Object.assign({},t),{bbox:this.layout.bbox.box})}}i.AnnotationView=a,a.__name__=\"AnnotationView\";class l extends o.Renderer{constructor(t){super(t)}static init_Annotation(){this.override({level:\"annotation\"})}}i.Annotation=l,l.__name__=\"Annotation\",l.init_Annotation()},\n", + " function _(e,i,t,n,s){n();const r=e(1),a=e(42),_=r.__importStar(e(45)),o=e(20),l=e(53),d=e(54);class h extends a.View{get coordinates(){const{_coordinates:e}=this;return null!=e?e:this._coordinates=this._initialize_coordinates()}initialize(){super.initialize(),this.visuals=new _.Visuals(this),this.needs_webgl_blit=!1}connect_signals(){super.connect_signals();const{x_range_name:e,y_range_name:i}=this.model.properties;this.on_change([e,i],(()=>this._initialize_coordinates()))}_initialize_coordinates(){const{x_range_name:e,y_range_name:i}=this.model,{frame:t}=this.plot_view,n=t.x_scales.get(e),s=t.y_scales.get(i);return new d.CoordinateTransform(n,s)}get plot_view(){return this.parent}get plot_model(){return this.parent.model}get layer(){const{overlays:e,primary:i}=this.canvas;return\"overlay\"==this.model.level?e:i}get canvas(){return this.plot_view.canvas_view}request_render(){this.request_paint()}request_paint(){this.plot_view.request_paint(this)}notify_finished(){this.plot_view.notify_finished()}get needs_clip(){return!1}get has_webgl(){return!1}render(){this.model.visible&&this._render(),this._has_finished=!0}renderer_view(e){}}t.RendererView=h,h.__name__=\"RendererView\";class c extends l.Model{constructor(e){super(e)}static init_Renderer(){this.define((({Boolean:e,String:i})=>({level:[o.RenderLevel,\"image\"],visible:[e,!0],x_range_name:[i,\"default\"],y_range_name:[i,\"default\"]})))}}t.Renderer=c,c.__name__=\"Renderer\",c.init_Renderer()},\n", + " function _(t,e,s,i,n){i();const r=t(1),o=t(15),h=t(43),l=t(8),a=r.__importDefault(t(44));class _{constructor(t){this.removed=new o.Signal0(this,\"removed\"),this._ready=Promise.resolve(void 0),this._slots=new WeakMap;const{model:e,parent:s}=t;this.model=e,this.parent=s,this.root=null==s?this:s.root,this.removed.emit()}get ready(){return this._ready}connect(t,e){let s=this._slots.get(e);return null==s&&(s=(t,s)=>{const i=Promise.resolve(e.call(this,t,s));this._ready=this._ready.then((()=>i))},this._slots.set(e,s)),t.connect(s,this)}disconnect(t,e){return t.disconnect(e,this)}initialize(){this._has_finished=!1,this.is_root&&(this._stylesheet=h.stylesheet);for(const t of this.styles())this.stylesheet.append(t)}async lazy_initialize(){}remove(){this.disconnect_signals(),this.removed.emit()}toString(){return`${this.model.type}View(${this.model.id})`}serializable_state(){return{type:this.model.type}}get is_root(){return null==this.parent}assert_root(){if(!this.is_root)throw new Error(`${this.toString()} is not a root layout`)}has_finished(){return this._has_finished}get is_idle(){return this.has_finished()}connect_signals(){}disconnect_signals(){o.Signal.disconnect_receiver(this)}on_change(t,e){for(const s of l.isArray(t)?t:[t])this.connect(s.change,e)}cursor(t,e){return null}get stylesheet(){return this.is_root?this._stylesheet:this.root.stylesheet}styles(){return[a.default]}}s.View=_,_.__name__=\"View\"},\n", + " function _(t,e,n,i,o){i();const s=t(8),l=t(13),r=t=>(e={},...n)=>{const i=document.createElement(t);i.classList.add(\"bk\");for(let[t,n]of l.entries(e))if(null!=n&&(!s.isBoolean(n)||n))if(\"class\"===t&&(s.isString(n)&&(n=n.split(/\\s+/)),s.isArray(n)))for(const t of n)null!=t&&i.classList.add(t);else if(\"style\"===t&&s.isPlainObject(n))for(const[t,e]of l.entries(n))i.style[t]=e;else if(\"data\"===t&&s.isPlainObject(n))for(const[t,e]of l.entries(n))i.dataset[t]=e;else i.setAttribute(t,n);function o(t){if(s.isString(t))i.appendChild(document.createTextNode(t));else if(t instanceof Node)i.appendChild(t);else if(t instanceof NodeList||t instanceof HTMLCollection)for(const e of t)i.appendChild(e);else if(null!=t&&!1!==t)throw new Error(`expected a DOM element, string, false or null, got ${JSON.stringify(t)}`)}for(const t of n)if(s.isArray(t))for(const e of t)o(e);else o(t);return i};function a(t){const e=t.parentNode;null!=e&&e.removeChild(t)}function c(t,...e){const n=t.firstChild;for(const i of e)t.insertBefore(i,n)}function d(t,e){var n,i,o;const s=Element.prototype;return(null!==(o=null!==(i=null!==(n=s.matches)&&void 0!==n?n:s.webkitMatchesSelector)&&void 0!==i?i:s.mozMatchesSelector)&&void 0!==o?o:s.msMatchesSelector).call(t,e)}function h(t){return parseFloat(t)||0}function u(t){const e=getComputedStyle(t);return{border:{top:h(e.borderTopWidth),bottom:h(e.borderBottomWidth),left:h(e.borderLeftWidth),right:h(e.borderRightWidth)},margin:{top:h(e.marginTop),bottom:h(e.marginBottom),left:h(e.marginLeft),right:h(e.marginRight)},padding:{top:h(e.paddingTop),bottom:h(e.paddingBottom),left:h(e.paddingLeft),right:h(e.paddingRight)}}}function f(t){const e=t.getBoundingClientRect();return{width:Math.ceil(e.width),height:Math.ceil(e.height)}}n.createElement=function(t,e,...n){return r(t)(e,...n)},n.div=r(\"div\"),n.span=r(\"span\"),n.canvas=r(\"canvas\"),n.link=r(\"link\"),n.style=r(\"style\"),n.a=r(\"a\"),n.p=r(\"p\"),n.i=r(\"i\"),n.pre=r(\"pre\"),n.button=r(\"button\"),n.label=r(\"label\"),n.input=r(\"input\"),n.select=r(\"select\"),n.option=r(\"option\"),n.optgroup=r(\"optgroup\"),n.textarea=r(\"textarea\"),n.nbsp=function(){return document.createTextNode(\" \")},n.append=function(t,...e){for(const n of e)t.appendChild(n)},n.remove=a,n.removeElement=a,n.replaceWith=function(t,e){const n=t.parentNode;null!=n&&n.replaceChild(e,t)},n.prepend=c,n.empty=function(t,e=!1){let n;for(;n=t.firstChild;)t.removeChild(n);if(e&&t instanceof Element)for(const e of t.attributes)t.removeAttributeNode(e)},n.display=function(t){t.style.display=\"\"},n.undisplay=function(t){t.style.display=\"none\"},n.show=function(t){t.style.visibility=\"\"},n.hide=function(t){t.style.visibility=\"hidden\"},n.offset=function(t){const e=t.getBoundingClientRect();return{top:e.top+window.pageYOffset-document.documentElement.clientTop,left:e.left+window.pageXOffset-document.documentElement.clientLeft}},n.matches=d,n.parent=function(t,e){let n=t;for(;n=n.parentElement;)if(d(n,e))return n;return null},n.extents=u,n.size=f,n.scroll_size=function(t){return{width:Math.ceil(t.scrollWidth),height:Math.ceil(t.scrollHeight)}},n.outer_size=function(t){const{margin:{left:e,right:n,top:i,bottom:o}}=u(t),{width:s,height:l}=f(t);return{width:Math.ceil(s+e+n),height:Math.ceil(l+i+o)}},n.content_size=function(t){const{left:e,top:n}=t.getBoundingClientRect(),{padding:i}=u(t);let o=0,s=0;for(const l of t.children){const t=l.getBoundingClientRect();o=Math.max(o,Math.ceil(t.left-e-i.left+t.width)),s=Math.max(s,Math.ceil(t.top-n-i.top+t.height))}return{width:o,height:s}},n.position=function(t,e,n){const{style:i}=t;if(i.left=`${e.x}px`,i.top=`${e.y}px`,i.width=`${e.width}px`,i.height=`${e.height}px`,null==n)i.margin=\"\";else{const{top:t,right:e,bottom:o,left:s}=n;i.margin=`${t}px ${e}px ${o}px ${s}px`}},n.children=function(t){return Array.from(t.children)};class p{constructor(t){this.el=t,this.classList=t.classList}get values(){const t=[];for(let e=0;e{document.addEventListener(\"DOMContentLoaded\",(()=>t()),{once:!0})}))}},\n", + " function _(o,i,t,e,r){e(),t.root=\"bk-root\",t.default=\".bk-root{position:relative;width:auto;height:auto;box-sizing:border-box;font-family:Helvetica, Arial, sans-serif;font-size:13px;}.bk-root .bk,.bk-root .bk:before,.bk-root .bk:after{box-sizing:inherit;margin:0;border:0;padding:0;background-image:none;font-family:inherit;font-size:100%;line-height:1.42857143;}.bk-root pre.bk{font-family:Courier, monospace;}\"},\n", + " function _(e,t,r,a,c){a();const l=e(1),n=e(46);c(\"Line\",n.Line),c(\"LineScalar\",n.LineScalar),c(\"LineVector\",n.LineVector);const i=e(49);c(\"Fill\",i.Fill),c(\"FillScalar\",i.FillScalar),c(\"FillVector\",i.FillVector);const s=e(50);c(\"Text\",s.Text),c(\"TextScalar\",s.TextScalar),c(\"TextVector\",s.TextVector);const o=e(51);c(\"Hatch\",o.Hatch),c(\"HatchScalar\",o.HatchScalar),c(\"HatchVector\",o.HatchVector);const u=l.__importStar(e(48)),V=e(47);c(\"VisualProperties\",V.VisualProperties),c(\"VisualUniforms\",V.VisualUniforms);class h{constructor(e){this._visuals=[];for(const[t,r]of e.model._mixins){const a=(()=>{switch(r){case u.Line:return new n.Line(e,t);case u.LineScalar:return new n.LineScalar(e,t);case u.LineVector:return new n.LineVector(e,t);case u.Fill:return new i.Fill(e,t);case u.FillScalar:return new i.FillScalar(e,t);case u.FillVector:return new i.FillVector(e,t);case u.Text:return new s.Text(e,t);case u.TextScalar:return new s.TextScalar(e,t);case u.TextVector:return new s.TextVector(e,t);case u.Hatch:return new o.Hatch(e,t);case u.HatchScalar:return new o.HatchScalar(e,t);case u.HatchVector:return new o.HatchVector(e,t);default:throw new Error(\"unknown visual\")}})();this._visuals.push(a),Object.defineProperty(this,t+a.type,{get:()=>a,configurable:!1,enumerable:!0})}}*[Symbol.iterator](){yield*this._visuals}}r.Visuals=h,h.__name__=\"Visuals\"},\n", + " function _(e,t,i,l,s){l();const n=e(1),a=e(47),o=n.__importStar(e(48)),r=e(22),_=e(8);function h(e){if(_.isArray(e))return e;switch(e){case\"solid\":return[];case\"dashed\":return[6];case\"dotted\":return[2,4];case\"dotdash\":return[2,4,6,4];case\"dashdot\":return[6,4,2,4];default:return e.split(\" \").map(Number).filter(_.isInteger)}}i.resolve_line_dash=h;class c extends a.VisualProperties{get doit(){const e=this.line_color.get_value(),t=this.line_alpha.get_value(),i=this.line_width.get_value();return!(null==e||0==t||0==i)}set_value(e){const t=this.line_color.get_value(),i=this.line_alpha.get_value();e.strokeStyle=r.color2css(t,i),e.lineWidth=this.line_width.get_value(),e.lineJoin=this.line_join.get_value(),e.lineCap=this.line_cap.get_value(),e.lineDash=h(this.line_dash.get_value()),e.lineDashOffset=this.line_dash_offset.get_value()}}i.Line=c,c.__name__=\"Line\";class u extends a.VisualUniforms{get doit(){const e=this.line_color.value,t=this.line_alpha.value,i=this.line_width.value;return!(0==e||0==t||0==i)}set_value(e){const t=this.line_color.value,i=this.line_alpha.value;e.strokeStyle=r.color2css(t,i),e.lineWidth=this.line_width.value,e.lineJoin=this.line_join.value,e.lineCap=this.line_cap.value,e.lineDash=h(this.line_dash.value),e.lineDashOffset=this.line_dash_offset.value}}i.LineScalar=u,u.__name__=\"LineScalar\";class d extends a.VisualUniforms{get doit(){const{line_color:e}=this;if(e.is_Scalar()&&0==e.value)return!1;const{line_alpha:t}=this;if(t.is_Scalar()&&0==t.value)return!1;const{line_width:i}=this;return!i.is_Scalar()||0!=i.value}set_vectorize(e,t){const i=this.line_color.get(t),l=this.line_alpha.get(t),s=this.line_width.get(t),n=this.line_join.get(t),a=this.line_cap.get(t),o=this.line_dash.get(t),_=this.line_dash_offset.get(t);e.strokeStyle=r.color2css(i,l),e.lineWidth=s,e.lineJoin=n,e.lineCap=a,e.lineDash=h(o),e.lineDashOffset=_}}i.LineVector=d,d.__name__=\"LineVector\",c.prototype.type=\"line\",c.prototype.attrs=Object.keys(o.Line),u.prototype.type=\"line\",u.prototype.attrs=Object.keys(o.LineScalar),d.prototype.type=\"line\",d.prototype.attrs=Object.keys(o.LineVector)},\n", + " function _(t,s,o,i,r){i();class e{constructor(t,s=\"\"){this.obj=t,this.prefix=s;const o=this;this._props=[];for(const i of this.attrs){const r=t.model.properties[s+i];r.change.connect((()=>this.update())),o[i]=r,this._props.push(r)}this.update()}*[Symbol.iterator](){yield*this._props}update(){}}o.VisualProperties=e,e.__name__=\"VisualProperties\";class p{constructor(t,s=\"\"){this.obj=t,this.prefix=s;for(const o of this.attrs)Object.defineProperty(this,o,{get:()=>t[s+o]})}*[Symbol.iterator](){for(const t of this.attrs)yield this.obj.model.properties[this.prefix+t]}update(){}}o.VisualUniforms=p,p.__name__=\"VisualUniforms\"},\n", + " function _(e,l,t,a,c){a();const r=e(1),o=r.__importStar(e(18)),n=e(20),i=r.__importStar(e(21)),_=e(13);t.Line={line_color:[i.Nullable(i.Color),\"black\"],line_alpha:[i.Alpha,1],line_width:[i.Number,1],line_join:[n.LineJoin,\"bevel\"],line_cap:[n.LineCap,\"butt\"],line_dash:[i.Or(n.LineDash,i.Array(i.Number)),[]],line_dash_offset:[i.Number,0]},t.Fill={fill_color:[i.Nullable(i.Color),\"gray\"],fill_alpha:[i.Alpha,1]},t.Hatch={hatch_color:[i.Nullable(i.Color),\"black\"],hatch_alpha:[i.Alpha,1],hatch_scale:[i.Number,12],hatch_pattern:[i.Nullable(i.Or(n.HatchPatternType,i.String)),null],hatch_weight:[i.Number,1],hatch_extra:[i.Dict(i.AnyRef()),{}]},t.Text={text_color:[i.Nullable(i.Color),\"#444444\"],text_alpha:[i.Alpha,1],text_font:[o.Font,\"helvetica\"],text_font_size:[i.FontSize,\"16px\"],text_font_style:[n.FontStyle,\"normal\"],text_align:[n.TextAlign,\"left\"],text_baseline:[n.TextBaseline,\"bottom\"],text_line_height:[i.Number,1.2]},t.LineScalar={line_color:[o.ColorScalar,\"black\"],line_alpha:[o.NumberScalar,1],line_width:[o.NumberScalar,1],line_join:[o.LineJoinScalar,\"bevel\"],line_cap:[o.LineCapScalar,\"butt\"],line_dash:[o.LineDashScalar,[]],line_dash_offset:[o.NumberScalar,0]},t.FillScalar={fill_color:[o.ColorScalar,\"gray\"],fill_alpha:[o.NumberScalar,1]},t.HatchScalar={hatch_color:[o.ColorScalar,\"black\"],hatch_alpha:[o.NumberScalar,1],hatch_scale:[o.NumberScalar,12],hatch_pattern:[o.NullStringScalar,null],hatch_weight:[o.NumberScalar,1],hatch_extra:[o.AnyScalar,{}]},t.TextScalar={text_color:[o.ColorScalar,\"#444444\"],text_alpha:[o.NumberScalar,1],text_font:[o.FontScalar,\"helvetica\"],text_font_size:[o.FontSizeScalar,\"16px\"],text_font_style:[o.FontStyleScalar,\"normal\"],text_align:[o.TextAlignScalar,\"left\"],text_baseline:[o.TextBaselineScalar,\"bottom\"],text_line_height:[o.NumberScalar,1.2]},t.LineVector={line_color:[o.ColorSpec,\"black\"],line_alpha:[o.NumberSpec,1],line_width:[o.NumberSpec,1],line_join:[o.LineJoinSpec,\"bevel\"],line_cap:[o.LineCapSpec,\"butt\"],line_dash:[o.LineDashSpec,[]],line_dash_offset:[o.NumberSpec,0]},t.FillVector={fill_color:[o.ColorSpec,\"gray\"],fill_alpha:[o.NumberSpec,1]},t.HatchVector={hatch_color:[o.ColorSpec,\"black\"],hatch_alpha:[o.NumberSpec,1],hatch_scale:[o.NumberSpec,12],hatch_pattern:[o.NullStringSpec,null],hatch_weight:[o.NumberSpec,1],hatch_extra:[o.AnyScalar,{}]},t.TextVector={text_color:[o.ColorSpec,\"#444444\"],text_alpha:[o.NumberSpec,1],text_font:[o.FontSpec,\"helvetica\"],text_font_size:[o.FontSizeSpec,\"16px\"],text_font_style:[o.FontStyleSpec,\"normal\"],text_align:[o.TextAlignSpec,\"left\"],text_baseline:[o.TextBaselineSpec,\"bottom\"],text_line_height:[o.NumberSpec,1.2]},t.attrs_of=function(e,l,t,a=!1){const c={};for(const r of _.keys(t)){const t=`${l}${r}`,o=e[t];c[a?t:r]=o}return c}},\n", + " function _(l,t,e,i,s){i();const o=l(1),a=l(47),r=o.__importStar(l(48)),c=l(22);class _ extends a.VisualProperties{get doit(){const l=this.fill_color.get_value(),t=this.fill_alpha.get_value();return!(null==l||0==t)}set_value(l){const t=this.fill_color.get_value(),e=this.fill_alpha.get_value();l.fillStyle=c.color2css(t,e)}}e.Fill=_,_.__name__=\"Fill\";class n extends a.VisualUniforms{get doit(){const l=this.fill_color.value,t=this.fill_alpha.value;return!(0==l||0==t)}set_value(l){const t=this.fill_color.value,e=this.fill_alpha.value;l.fillStyle=c.color2css(t,e)}}e.FillScalar=n,n.__name__=\"FillScalar\";class p extends a.VisualUniforms{get doit(){const{fill_color:l}=this;if(l.is_Scalar()&&0==l.value)return!1;const{fill_alpha:t}=this;return!t.is_Scalar()||0!=t.value}set_vectorize(l,t){const e=this.fill_color.get(t),i=this.fill_alpha.get(t);l.fillStyle=c.color2css(e,i)}}e.FillVector=p,p.__name__=\"FillVector\",_.prototype.type=\"fill\",_.prototype.attrs=Object.keys(r.Fill),n.prototype.type=\"fill\",n.prototype.attrs=Object.keys(r.FillScalar),p.prototype.type=\"fill\",p.prototype.attrs=Object.keys(r.FillVector)},\n", + " function _(t,e,s,l,a){l();const o=t(1),_=t(47),i=o.__importStar(t(48)),n=t(22);class x extends _.VisualProperties{get doit(){const t=this.text_color.get_value(),e=this.text_alpha.get_value();return!(null==t||0==e)}set_value(t){const e=this.text_color.get_value(),s=this.text_alpha.get_value();t.fillStyle=n.color2css(e,s),t.font=this.font_value(),t.textAlign=this.text_align.get_value(),t.textBaseline=this.text_baseline.get_value()}font_value(){return`${this.text_font_style.get_value()} ${this.text_font_size.get_value()} ${this.text_font.get_value()}`}}s.Text=x,x.__name__=\"Text\";class r extends _.VisualUniforms{get doit(){const t=this.text_color.value,e=this.text_alpha.value;return!(0==t||0==e)}set_value(t){const e=this.text_color.value,s=this.text_alpha.value,l=this.font_value(),a=this.text_align.value,o=this.text_baseline.value;t.fillStyle=n.color2css(e,s),t.font=l,t.textAlign=a,t.textBaseline=o}font_value(){return`${this.text_font_style.value} ${this.text_font_size.value} ${this.text_font.value}`}}s.TextScalar=r,r.__name__=\"TextScalar\";class u extends _.VisualUniforms{get doit(){const{text_color:t}=this;if(t.is_Scalar()&&0==t.value)return!1;const{text_alpha:e}=this;return!e.is_Scalar()||0!=e.value}set_vectorize(t,e){const s=this.text_color.get(e),l=this.text_alpha.get(e),a=this.font_value(e),o=this.text_align.get(e),_=this.text_baseline.get(e);t.fillStyle=n.color2css(s,l),t.font=a,t.textAlign=o,t.textBaseline=_}font_value(t){return`${this.text_font_style.get(t)} ${this.text_font_size.get(t)} ${this.text_font.get(t)}`}}s.TextVector=u,u.__name__=\"TextVector\",x.prototype.type=\"text\",x.prototype.attrs=Object.keys(i.Text),r.prototype.type=\"text\",r.prototype.attrs=Object.keys(i.TextScalar),u.prototype.type=\"text\",u.prototype.attrs=Object.keys(i.TextVector)},\n", + " function _(t,e,a,h,r){h();const i=t(1),s=t(47),c=t(52),n=i.__importStar(t(18)),_=i.__importStar(t(48));class l extends s.VisualProperties{constructor(){super(...arguments),this._update_iteration=0}update(){if(this._update_iteration++,this._hatch_image=null,!this.doit)return;const t=this.hatch_color.get_value(),e=this.hatch_alpha.get_value(),a=this.hatch_scale.get_value(),h=this.hatch_pattern.get_value(),r=this.hatch_weight.get_value(),i=t=>{this._hatch_image=t},s=this.hatch_extra.get_value()[h];if(null!=s){const h=s.get_pattern(t,e,a,r);if(h instanceof Promise){const{_update_iteration:t}=this;h.then((e=>{this._update_iteration==t&&(i(e),this.obj.request_render())}))}else i(h)}else{const s=this.obj.canvas.create_layer(),n=c.get_pattern(s,h,t,e,a,r);i(n)}}get doit(){const t=this.hatch_color.get_value(),e=this.hatch_alpha.get_value(),a=this.hatch_pattern.get_value();return!(null==t||0==e||\" \"==a||\"blank\"==a||null==a)}set_value(t){const e=this.pattern(t);t.fillStyle=null!=e?e:\"transparent\"}pattern(t){const e=this._hatch_image;return null==e?null:t.createPattern(e,this.repetition())}repetition(){const t=this.hatch_pattern.get_value(),e=this.hatch_extra.get_value()[t];if(null==e)return\"repeat\";switch(e.repetition){case\"repeat\":return\"repeat\";case\"repeat_x\":return\"repeat-x\";case\"repeat_y\":return\"repeat-y\";case\"no_repeat\":return\"no-repeat\"}}}a.Hatch=l,l.__name__=\"Hatch\";class o extends s.VisualUniforms{constructor(){super(...arguments),this._static_doit=!1,this._update_iteration=0}_compute_static_doit(){const t=this.hatch_color.value,e=this.hatch_alpha.value,a=this.hatch_pattern.value;return!(null==t||0==e||\" \"==a||\"blank\"==a||null==a)}update(){this._update_iteration++;const t=this.hatch_color.length;if(this._hatch_image=new n.UniformScalar(null,t),this._static_doit=this._compute_static_doit(),!this._static_doit)return;const e=this.hatch_color.value,a=this.hatch_alpha.value,h=this.hatch_scale.value,r=this.hatch_pattern.value,i=this.hatch_weight.value,s=e=>{this._hatch_image=new n.UniformScalar(e,t)},_=this.hatch_extra.value[r];if(null!=_){const t=_.get_pattern(e,a,h,i);if(t instanceof Promise){const{_update_iteration:e}=this;t.then((t=>{this._update_iteration==e&&(s(t),this.obj.request_render())}))}else s(t)}else{const t=this.obj.canvas.create_layer(),n=c.get_pattern(t,r,e,a,h,i);s(n)}}get doit(){return this._static_doit}set_value(t){var e;t.fillStyle=null!==(e=this.pattern(t))&&void 0!==e?e:\"transparent\"}pattern(t){const e=this._hatch_image.value;return null==e?null:t.createPattern(e,this.repetition())}repetition(){const t=this.hatch_pattern.value,e=this.hatch_extra.value[t];if(null==e)return\"repeat\";switch(e.repetition){case\"repeat\":return\"repeat\";case\"repeat_x\":return\"repeat-x\";case\"repeat_y\":return\"repeat-y\";case\"no_repeat\":return\"no-repeat\"}}}a.HatchScalar=o,o.__name__=\"HatchScalar\";class u extends s.VisualUniforms{constructor(){super(...arguments),this._static_doit=!1,this._update_iteration=0}_compute_static_doit(){const{hatch_color:t}=this;if(t.is_Scalar()&&0==t.value)return!1;const{hatch_alpha:e}=this;if(e.is_Scalar()&&0==e.value)return!1;const{hatch_pattern:a}=this;if(a.is_Scalar()){const t=a.value;if(\" \"==t||\"blank\"==t||null==t)return!1}return!0}update(){this._update_iteration++;const t=this.hatch_color.length;if(this._hatch_image=new n.UniformScalar(null,t),this._static_doit=this._compute_static_doit(),!this._static_doit)return;const e=(t,e,a,h,r,i)=>{const s=this.hatch_extra.value[t];if(null!=s){const t=s.get_pattern(e,a,h,r);if(t instanceof Promise){const{_update_iteration:e}=this;t.then((t=>{this._update_iteration==e&&(i(t),this.obj.request_render())}))}else i(t)}else{const s=this.obj.canvas.create_layer(),n=c.get_pattern(s,t,e,a,h,r);i(n)}};if(this.hatch_color.is_Scalar()&&this.hatch_alpha.is_Scalar()&&this.hatch_scale.is_Scalar()&&this.hatch_pattern.is_Scalar()&&this.hatch_weight.is_Scalar()){const a=this.hatch_color.value,h=this.hatch_alpha.value,r=this.hatch_scale.value;e(this.hatch_pattern.value,a,h,r,this.hatch_weight.value,(e=>{this._hatch_image=new n.UniformScalar(e,t)}))}else{const a=new Array(t);a.fill(null),this._hatch_image=new n.UniformVector(a);for(let h=0;h{a[h]=t}))}}}get doit(){return this._static_doit}set_vectorize(t,e){var a;t.fillStyle=null!==(a=this.pattern(t,e))&&void 0!==a?a:\"transparent\"}pattern(t,e){const a=this._hatch_image.get(e);return null==a?null:t.createPattern(a,this.repetition(e))}repetition(t){const e=this.hatch_pattern.get(t),a=this.hatch_extra.value[e];if(null==a)return\"repeat\";switch(a.repetition){case\"repeat\":return\"repeat\";case\"repeat_x\":return\"repeat-x\";case\"repeat_y\":return\"repeat-y\";case\"no_repeat\":return\"no-repeat\"}}}a.HatchVector=u,u.__name__=\"HatchVector\",l.prototype.type=\"hatch\",l.prototype.attrs=Object.keys(_.Hatch),o.prototype.type=\"hatch\",o.prototype.attrs=Object.keys(_.HatchScalar),u.prototype.type=\"hatch\",u.prototype.attrs=Object.keys(_.HatchVector)},\n", + " function _(e,o,a,s,r){s();const i=e(22);function l(e,o,a){e.moveTo(0,a+.5),e.lineTo(o,a+.5),e.stroke()}function n(e,o,a){e.moveTo(a+.5,0),e.lineTo(a+.5,o),e.stroke()}function t(e,o){e.moveTo(0,o),e.lineTo(o,0),e.stroke(),e.moveTo(0,0),e.lineTo(o,o),e.stroke()}a.hatch_aliases={\" \":\"blank\",\".\":\"dot\",o:\"ring\",\"-\":\"horizontal_line\",\"|\":\"vertical_line\",\"+\":\"cross\",'\"':\"horizontal_dash\",\":\":\"vertical_dash\",\"@\":\"spiral\",\"/\":\"right_diagonal_line\",\"\\\\\":\"left_diagonal_line\",x:\"diagonal_cross\",\",\":\"right_diagonal_dash\",\"`\":\"left_diagonal_dash\",v:\"horizontal_wave\",\">\":\"vertical_wave\",\"*\":\"criss_cross\"},a.get_pattern=function(e,o,s,r,c,k){return e.resize(c,c),e.prepare(),function(e,o,s,r,c,k){var _;const T=c,v=T/2,h=v/2,d=i.color2css(s,r);switch(e.strokeStyle=d,e.fillStyle=d,e.lineCap=\"square\",e.lineWidth=k,null!==(_=a.hatch_aliases[o])&&void 0!==_?_:o){case\"blank\":break;case\"dot\":e.arc(v,v,v/2,0,2*Math.PI,!0),e.fill();break;case\"ring\":e.arc(v,v,v/2,0,2*Math.PI,!0),e.stroke();break;case\"horizontal_line\":l(e,T,v);break;case\"vertical_line\":n(e,T,v);break;case\"cross\":l(e,T,v),n(e,T,v);break;case\"horizontal_dash\":l(e,v,v);break;case\"vertical_dash\":n(e,v,v);break;case\"spiral\":{const o=T/30;e.moveTo(v,v);for(let a=0;a<360;a++){const s=.1*a,r=v+o*s*Math.cos(s),i=v+o*s*Math.sin(s);e.lineTo(r,i)}e.stroke();break}case\"right_diagonal_line\":e.moveTo(.5-h,T),e.lineTo(h+.5,0),e.stroke(),e.moveTo(h+.5,T),e.lineTo(3*h+.5,0),e.stroke(),e.moveTo(3*h+.5,T),e.lineTo(5*h+.5,0),e.stroke(),e.stroke();break;case\"left_diagonal_line\":e.moveTo(h+.5,T),e.lineTo(.5-h,0),e.stroke(),e.moveTo(3*h+.5,T),e.lineTo(h+.5,0),e.stroke(),e.moveTo(5*h+.5,T),e.lineTo(3*h+.5,0),e.stroke(),e.stroke();break;case\"diagonal_cross\":t(e,T);break;case\"right_diagonal_dash\":e.moveTo(h+.5,3*h+.5),e.lineTo(3*h+.5,h+.5),e.stroke();break;case\"left_diagonal_dash\":e.moveTo(h+.5,h+.5),e.lineTo(3*h+.5,3*h+.5),e.stroke();break;case\"horizontal_wave\":e.moveTo(0,h),e.lineTo(v,3*h),e.lineTo(T,h),e.stroke();break;case\"vertical_wave\":e.moveTo(h,0),e.lineTo(3*h,v),e.lineTo(h,T),e.stroke();break;case\"criss_cross\":t(e,T),l(e,T,v),n(e,T,v)}}(e.ctx,o,s,r,c,k),e.canvas}},\n", + " function _(e,t,s,n,c){n();const a=e(14),i=e(8),r=e(13),l=e(19);class o extends a.HasProps{constructor(e){super(e)}get is_syncable(){return this.syncable}static init_Model(){this.define((({Any:e,Unknown:t,Boolean:s,String:n,Array:c,Dict:a,Nullable:i})=>({tags:[c(t),[]],name:[i(n),null],js_property_callbacks:[a(c(e)),{}],js_event_callbacks:[a(c(e)),{}],subscribed_events:[c(n),[]],syncable:[s,!0]})))}initialize(){super.initialize(),this._js_callbacks=new Map}connect_signals(){super.connect_signals(),this._update_property_callbacks(),this.connect(this.properties.js_property_callbacks.change,(()=>this._update_property_callbacks())),this.connect(this.properties.js_event_callbacks.change,(()=>this._update_event_callbacks())),this.connect(this.properties.subscribed_events.change,(()=>this._update_event_callbacks()))}_process_event(e){var t;for(const s of null!==(t=this.js_event_callbacks[e.event_name])&&void 0!==t?t:[])s.execute(e);null!=this.document&&this.subscribed_events.some((t=>t==e.event_name))&&this.document.event_manager.send_event(e)}trigger_event(e){null!=this.document&&(e.origin=this,this.document.event_manager.trigger(e))}_update_event_callbacks(){null!=this.document?this.document.event_manager.subscribed_models.add(this):l.logger.warn(\"WARNING: Document not defined for updating event callbacks\")}_update_property_callbacks(){const e=e=>{const[t,s=null]=e.split(\":\");return null!=s?this.properties[s][t]:this[t]};for(const[t,s]of this._js_callbacks){const n=e(t);for(const e of s)this.disconnect(n,e)}this._js_callbacks.clear();for(const[t,s]of r.entries(this.js_property_callbacks)){const n=s.map((e=>()=>e.execute(this)));this._js_callbacks.set(t,n);const c=e(t);for(const e of n)this.connect(c,e)}}_doc_attached(){r.isEmpty(this.js_event_callbacks)&&0==this.subscribed_events.length||this._update_event_callbacks()}_doc_detached(){this.document.event_manager.subscribed_models.delete(this)}select(e){if(i.isString(e))return[...this.references()].filter((t=>t instanceof o&&t.name===e));if(e.prototype instanceof a.HasProps)return[...this.references()].filter((t=>t instanceof e));throw new Error(\"invalid selector\")}select_one(e){const t=this.select(e);switch(t.length){case 0:return null;case 1:return t[0];default:throw new Error(\"found more than one object matching given selector\")}}}s.Model=o,o.__name__=\"Model\",o.init_Model()},\n", + " function _(s,e,_,t,a){t();class r{constructor(s,e){this.x_scale=s,this.y_scale=e,this.x_range=this.x_scale.source_range,this.y_range=this.y_scale.source_range,this.ranges=[this.x_range,this.y_range],this.scales=[this.x_scale,this.y_scale]}map_to_screen(s,e){return[this.x_scale.v_compute(s),this.y_scale.v_compute(e)]}map_from_screen(s,e){return[this.x_scale.v_invert(s),this.y_scale.v_invert(e)]}}_.CoordinateTransform=r,r.__name__=\"CoordinateTransform\"},\n", + " function _(t,e,s,a,i){a();const n=t(1),_=t(56),r=t(133),o=t(48),l=t(20),d=t(24),h=t(122),c=n.__importStar(t(18)),u=t(10);class v extends _.DataAnnotationView{async lazy_initialize(){await super.lazy_initialize();const{start:t,end:e}=this.model;null!=t&&(this.start=await h.build_view(t,{parent:this})),null!=e&&(this.end=await h.build_view(e,{parent:this}))}set_data(t){var e,s;super.set_data(t),null===(e=this.start)||void 0===e||e.set_data(t),null===(s=this.end)||void 0===s||s.set_data(t)}remove(){var t,e;null===(t=this.start)||void 0===t||t.remove(),null===(e=this.end)||void 0===e||e.remove(),super.remove()}map_data(){const{frame:t}=this.plot_view;\"data\"==this.model.start_units?(this._sx_start=this.coordinates.x_scale.v_compute(this._x_start),this._sy_start=this.coordinates.y_scale.v_compute(this._y_start)):(this._sx_start=t.bbox.xview.v_compute(this._x_start),this._sy_start=t.bbox.yview.v_compute(this._y_start)),\"data\"==this.model.end_units?(this._sx_end=this.coordinates.x_scale.v_compute(this._x_end),this._sy_end=this.coordinates.y_scale.v_compute(this._y_end)):(this._sx_end=t.bbox.xview.v_compute(this._x_end),this._sy_end=t.bbox.yview.v_compute(this._y_end));const{_sx_start:e,_sy_start:s,_sx_end:a,_sy_end:i}=this,n=e.length,_=this._angles=new d.ScreenArray(n);for(let t=0;t({x_start:[c.XCoordinateSpec,{field:\"x_start\"}],y_start:[c.YCoordinateSpec,{field:\"y_start\"}],start_units:[l.SpatialUnits,\"data\"],start:[e(t(r.ArrowHead)),null],x_end:[c.XCoordinateSpec,{field:\"x_end\"}],y_end:[c.YCoordinateSpec,{field:\"y_end\"}],end_units:[l.SpatialUnits,\"data\"],end:[e(t(r.ArrowHead)),()=>new r.OpenHead]})))}}s.Arrow=p,p.__name__=\"Arrow\",p.init_Arrow()},\n", + " function _(t,n,s,a,e){a();const i=t(1),o=t(40),c=t(57),_=t(130),r=t(65),l=i.__importStar(t(18));class h extends o.AnnotationView{constructor(){super(...arguments),this._initial_set_data=!1}connect_signals(){super.connect_signals();const t=()=>{this.set_data(this.model.source),this.request_render()};this.connect(this.model.change,t),this.connect(this.model.source.streaming,t),this.connect(this.model.source.patching,t),this.connect(this.model.source.change,t)}set_data(t){const n=this;for(const s of this.model)if(s instanceof l.VectorSpec||s instanceof l.ScalarSpec)if(s instanceof l.BaseCoordinateSpec){const a=s.array(t);n[`_${s.attr}`]=a}else{const a=s.uniform(t);n[`${s.attr}`]=a}this.plot_model.use_map&&(null!=n._x&&r.inplace.project_xy(n._x,n._y),null!=n._xs&&r.inplace.project_xsys(n._xs,n._ys));for(const t of this.visuals)t.update()}_render(){this._initial_set_data||(this.set_data(this.model.source),this._initial_set_data=!0),this.map_data(),this.paint(this.layer.ctx)}}s.DataAnnotationView=h,h.__name__=\"DataAnnotationView\";class u extends o.Annotation{constructor(t){super(t)}static init_DataAnnotation(){this.define((({Ref:t})=>({source:[t(c.ColumnarDataSource),()=>new _.ColumnDataSource]})))}}s.DataAnnotation=u,u.__name__=\"DataAnnotation\",u.init_DataAnnotation()},\n", + " function _(t,e,n,a,i){a();const s=t(58),r=t(15),l=t(19),o=t(60),c=t(8),u=t(9),h=t(13),g=t(59),d=t(129),_=t(29);class m extends s.DataSource{constructor(t){super(t)}get_array(t){let e=this.data[t];return null==e?this.data[t]=e=[]:c.isArray(e)||(this.data[t]=e=Array.from(e)),e}static init_ColumnarDataSource(){this.define((({Ref:t})=>({selection_policy:[t(d.SelectionPolicy),()=>new d.UnionRenderers]}))),this.internal((({AnyRef:t})=>({selection_manager:[t(),t=>new o.SelectionManager({source:t})],inspected:[t(),()=>new g.Selection]})))}initialize(){super.initialize(),this._select=new r.Signal0(this,\"select\"),this.inspect=new r.Signal(this,\"inspect\"),this.streaming=new r.Signal0(this,\"streaming\"),this.patching=new r.Signal(this,\"patching\")}get_column(t){const e=this.data[t];return null!=e?e:null}columns(){return h.keys(this.data)}get_length(t=!0){const e=u.uniq(h.values(this.data).map((t=>_.is_NDArray(t)?t.shape[0]:t.length)));switch(e.length){case 0:return null;case 1:return e[0];default:{const n=\"data source has columns of inconsistent lengths\";if(t)return l.logger.warn(n),e.sort()[0];throw new Error(n)}}}get length(){var t;return null!==(t=this.get_length())&&void 0!==t?t:0}clear(){const t={};for(const e of this.columns())t[e]=new this.data[e].constructor(0);this.data=t}}n.ColumnarDataSource=m,m.__name__=\"ColumnarDataSource\",m.init_ColumnarDataSource()},\n", + " function _(e,t,c,n,a){n();const o=e(53),i=e(59);class s extends o.Model{constructor(e){super(e)}static init_DataSource(){this.define((({Ref:e})=>({selected:[e(i.Selection),()=>new i.Selection]})))}}c.DataSource=s,s.__name__=\"DataSource\",s.init_DataSource()},\n", + " function _(i,e,s,t,n){t();const l=i(53),c=i(9),h=i(13);class d extends l.Model{constructor(i){super(i)}get_view(){return this.view}static init_Selection(){this.define((({Int:i,Array:e,Dict:s})=>({indices:[e(i),[]],line_indices:[e(i),[]],multiline_indices:[s(e(i)),{}]}))),this.internal((({Int:i,Array:e,AnyRef:s,Struct:t,Nullable:n})=>({selected_glyphs:[e(s()),[]],view:[n(s()),null],image_indices:[e(t({index:i,dim1:i,dim2:i,flat_index:i})),[]]})))}get selected_glyph(){return this.selected_glyphs.length>0?this.selected_glyphs[0]:null}add_to_selected_glyphs(i){this.selected_glyphs.push(i)}update(i,e=!0,s=\"replace\"){switch(s){case\"replace\":this.indices=i.indices,this.line_indices=i.line_indices,this.selected_glyphs=i.selected_glyphs,this.view=i.view,this.multiline_indices=i.multiline_indices,this.image_indices=i.image_indices;break;case\"append\":this.update_through_union(i);break;case\"intersect\":this.update_through_intersection(i);break;case\"subtract\":this.update_through_subtraction(i)}}clear(){this.indices=[],this.line_indices=[],this.multiline_indices={},this.view=null,this.selected_glyphs=[]}is_empty(){return 0==this.indices.length&&0==this.line_indices.length&&0==this.image_indices.length}update_through_union(i){this.indices=c.union(this.indices,i.indices),this.selected_glyphs=c.union(i.selected_glyphs,this.selected_glyphs),this.line_indices=c.union(i.line_indices,this.line_indices),this.view=i.view,this.multiline_indices=h.merge(i.multiline_indices,this.multiline_indices)}update_through_intersection(i){this.indices=c.intersection(this.indices,i.indices),this.selected_glyphs=c.union(i.selected_glyphs,this.selected_glyphs),this.line_indices=c.union(i.line_indices,this.line_indices),this.view=i.view,this.multiline_indices=h.merge(i.multiline_indices,this.multiline_indices)}update_through_subtraction(i){this.indices=c.difference(this.indices,i.indices),this.selected_glyphs=c.union(i.selected_glyphs,this.selected_glyphs),this.line_indices=c.union(i.line_indices,this.line_indices),this.view=i.view,this.multiline_indices=h.merge(i.multiline_indices,this.multiline_indices)}}s.Selection=d,d.__name__=\"Selection\",d.init_Selection()},\n", + " function _(e,t,s,n,i){n();const o=e(14),c=e(59),r=e(61),l=e(123);class p extends o.HasProps{constructor(e){super(e),this.inspectors=new Map}static init_SelectionManager(){this.internal((({AnyRef:e})=>({source:[e()]})))}select(e,t,s,n=\"replace\"){const i=[],o=[];for(const t of e)t instanceof r.GlyphRendererView?i.push(t):t instanceof l.GraphRendererView&&o.push(t);let c=!1;for(const e of o){const i=e.model.selection_policy.hit_test(t,e);c=c||e.model.selection_policy.do_selection(i,e.model,s,n)}if(i.length>0){const e=this.source.selection_policy.hit_test(t,i);c=c||this.source.selection_policy.do_selection(e,this.source,s,n)}return c}inspect(e,t){let s=!1;if(e instanceof r.GlyphRendererView){const n=e.hit_test(t);if(null!=n){s=!n.is_empty();const i=this.get_or_create_inspector(e.model);i.update(n,!0,\"replace\"),this.source.setv({inspected:i},{silent:!0}),this.source.inspect.emit([e.model,{geometry:t}])}}else if(e instanceof l.GraphRendererView){const n=e.model.inspection_policy.hit_test(t,e);s=s||e.model.inspection_policy.do_inspection(n,t,e,!1,\"replace\")}return s}clear(e){this.source.selected.clear(),null!=e&&this.get_or_create_inspector(e.model).clear()}get_or_create_inspector(e){let t=this.inspectors.get(e);return null==t&&(t=new c.Selection,this.inspectors.set(e,t)),t}}s.SelectionManager=p,p.__name__=\"SelectionManager\",p.init_SelectionManager()},\n", + " function _(e,t,i,s,l){s();const h=e(62),n=e(63),o=e(116),a=e(117),c=e(119),d=e(98),_=e(57),r=e(120),p=e(24),g=e(12),u=e(9),y=e(13),m=e(122),v=e(104),f={fill:{},line:{}},w={fill:{fill_alpha:.3,fill_color:\"grey\"},line:{line_alpha:.3,line_color:\"grey\"}},b={fill:{fill_alpha:.2},line:{}};class V extends h.DataRendererView{get glyph_view(){return this.glyph}async lazy_initialize(){var e,t;await super.lazy_initialize();const i=this.model.glyph;this.glyph=await this.build_glyph_view(i);const s=\"fill\"in this.glyph.visuals,l=\"line\"in this.glyph.visuals,h=Object.assign({},i.attributes);function n(e){const t=y.clone(h);return s&&y.extend(t,e.fill),l&&y.extend(t,e.line),new i.constructor(t)}delete h.id;let{selection_glyph:o}=this.model;null==o?o=n({fill:{},line:{}}):\"auto\"==o&&(o=n(f)),this.selection_glyph=await this.build_glyph_view(o);let{nonselection_glyph:a}=this.model;null==a?a=n({fill:{},line:{}}):\"auto\"==a&&(a=n(b)),this.nonselection_glyph=await this.build_glyph_view(a);const{hover_glyph:c}=this.model;null!=c&&(this.hover_glyph=await this.build_glyph_view(c));const{muted_glyph:d}=this.model;null!=d&&(this.muted_glyph=await this.build_glyph_view(d));const _=n(w);this.decimated_glyph=await this.build_glyph_view(_),this.selection_glyph.set_base(this.glyph),this.nonselection_glyph.set_base(this.glyph),null===(e=this.hover_glyph)||void 0===e||e.set_base(this.glyph),null===(t=this.muted_glyph)||void 0===t||t.set_base(this.glyph),this.decimated_glyph.set_base(this.glyph),this.set_data()}async build_glyph_view(e){return m.build_view(e,{parent:this})}remove(){var e,t;this.glyph.remove(),this.selection_glyph.remove(),this.nonselection_glyph.remove(),null===(e=this.hover_glyph)||void 0===e||e.remove(),null===(t=this.muted_glyph)||void 0===t||t.remove(),this.decimated_glyph.remove(),super.remove()}connect_signals(){super.connect_signals();const e=()=>this.request_render(),t=()=>this.update_data();this.connect(this.model.change,e),this.connect(this.glyph.model.change,t),this.connect(this.selection_glyph.model.change,t),this.connect(this.nonselection_glyph.model.change,t),null!=this.hover_glyph&&this.connect(this.hover_glyph.model.change,t),null!=this.muted_glyph&&this.connect(this.muted_glyph.model.change,t),this.connect(this.decimated_glyph.model.change,t),this.connect(this.model.data_source.change,t),this.connect(this.model.data_source.streaming,t),this.connect(this.model.data_source.patching,(e=>this.update_data(e))),this.connect(this.model.data_source.selected.change,e),this.connect(this.model.data_source._select,e),null!=this.hover_glyph&&this.connect(this.model.data_source.inspect,e),this.connect(this.model.properties.view.change,t),this.connect(this.model.view.properties.indices.change,t),this.connect(this.model.view.properties.masked.change,(()=>this.set_visuals())),this.connect(this.model.properties.visible.change,(()=>this.plot_view.invalidate_dataranges=!0));const{x_ranges:i,y_ranges:s}=this.plot_view.frame;for(const[,e]of i)e instanceof v.FactorRange&&this.connect(e.change,t);for(const[,e]of s)e instanceof v.FactorRange&&this.connect(e.change,t);const{transformchange:l,exprchange:h}=this.model.glyph;this.connect(l,t),this.connect(h,t)}_update_masked_indices(){const e=this.glyph.mask_data();return this.model.view.masked=e,e}update_data(e){this.set_data(e),this.request_render()}set_data(e){const t=this.model.data_source;this.all_indices=this.model.view.indices;const{all_indices:i}=this;this.glyph.set_data(t,i,e),this.set_visuals(),this._update_masked_indices();const{lod_factor:s}=this.plot_model,l=this.all_indices.count;this.decimated=new p.Indices(l);for(let e=0;e!d||d.is_empty()?[]:d.selected_glyph?this.model.view.convert_indices_from_subset(i):d.indices.length>0?d.indices:Object.keys(d.multiline_indices).map((e=>parseInt(e))))()),r=g.filter(i,(e=>_.has(t[e]))),{lod_threshold:p}=this.plot_model;let y,m,v;if(null!=this.model.document&&this.model.document.interactive_duration()>0&&!e&&null!=p&&t.length>p?(i=[...this.decimated],y=this.decimated_glyph,m=this.decimated_glyph,v=this.selection_glyph):(y=this.model.muted&&null!=this.muted_glyph?this.muted_glyph:this.glyph,m=this.nonselection_glyph,v=this.selection_glyph),null!=this.hover_glyph&&r.length&&(i=u.difference(i,r)),h.length){const e={};for(const t of h)e[t]=!0;const l=new Array,o=new Array;if(this.glyph instanceof n.LineView)for(const i of t)null!=e[i]?l.push(i):o.push(i);else for(const s of i)null!=e[t[s]]?l.push(s):o.push(s);m.render(s,o),v.render(s,l),null!=this.hover_glyph&&(this.glyph instanceof n.LineView?this.hover_glyph.render(s,this.model.view.convert_indices_from_subset(r)):this.hover_glyph.render(s,r))}else if(this.glyph instanceof n.LineView)this.hover_glyph&&r.length?this.hover_glyph.render(s,this.model.view.convert_indices_from_subset(r)):y.render(s,t);else if(this.glyph instanceof o.PatchView||this.glyph instanceof a.HAreaView||this.glyph instanceof c.VAreaView)if(0==d.selected_glyphs.length||null==this.hover_glyph)y.render(s,t);else for(const e of d.selected_glyphs)e==this.glyph.model&&this.hover_glyph.render(s,t);else y.render(s,i),this.hover_glyph&&r.length&&this.hover_glyph.render(s,r);s.restore()}draw_legend(e,t,i,s,l,h,n,o){0!=this.glyph.data_size&&(null==o&&(o=this.model.get_reference_point(h,n)),this.glyph.draw_legend_for_index(e,{x0:t,x1:i,y0:s,y1:l},o))}hit_test(e){if(!this.model.visible)return null;const t=this.glyph.hit_test(e);return null==t?null:this.model.view.convert_selection_from_subset(t)}}i.GlyphRendererView=V,V.__name__=\"GlyphRendererView\";class G extends h.DataRenderer{constructor(e){super(e)}static init_GlyphRenderer(){this.prototype.default_view=V,this.define((({Boolean:e,Auto:t,Or:i,Ref:s,Null:l,Nullable:h})=>({data_source:[s(_.ColumnarDataSource)],view:[s(r.CDSView),e=>new r.CDSView({source:e.data_source})],glyph:[s(d.Glyph)],hover_glyph:[h(s(d.Glyph)),null],nonselection_glyph:[i(s(d.Glyph),t,l),\"auto\"],selection_glyph:[i(s(d.Glyph),t,l),\"auto\"],muted_glyph:[h(s(d.Glyph)),null],muted:[e,!1]})))}initialize(){super.initialize(),this.view.source!=this.data_source&&(this.view.source=this.data_source,this.view.compute_indices())}get_reference_point(e,t){if(null!=e){const i=this.data_source.get_column(e);if(null!=i)for(const[e,s]of Object.entries(this.view.indices_map))if(i[parseInt(e)]==t)return s}return 0}get_selection_manager(){return this.data_source.selection_manager}}i.GlyphRenderer=G,G.__name__=\"GlyphRenderer\",G.init_GlyphRenderer()},\n", + " function _(e,r,t,a,n){a();const s=e(41);class i extends s.RendererView{get xscale(){return this.coordinates.x_scale}get yscale(){return this.coordinates.y_scale}}t.DataRendererView=i,i.__name__=\"DataRendererView\";class _ extends s.Renderer{constructor(e){super(e)}static init_DataRenderer(){this.override({level:\"glyph\"})}get selection_manager(){return this.get_selection_manager()}}t.DataRenderer=_,_.__name__=\"DataRenderer\",_.init_DataRenderer()},\n", + " function _(e,i,t,s,n){s();const l=e(1),_=e(64),r=e(106),h=e(108),o=l.__importStar(e(48)),a=l.__importStar(e(107)),c=e(59);class d extends _.XYGlyphView{initialize(){super.initialize();const{webgl:e}=this.renderer.plot_view.canvas_view;null!=e&&(this.glglyph=new h.LineGL(e.gl,this))}_render(e,i,t){const{sx:s,sy:n}=null!=t?t:this;let l=!0;e.beginPath();for(const t of i){const i=s[t],_=n[t];isFinite(i+_)?l?(e.moveTo(i,_),l=!1):e.lineTo(i,_):l=!0}this.visuals.line.set_value(e),e.stroke()}_hit_point(e){const i=new c.Selection,t={x:e.sx,y:e.sy};let s=9999;const n=Math.max(2,this.line_width.value/2);for(let e=0,l=this.sx.length-1;e({x:[p.XCoordinateSpec,{field:\"x\"}],y:[p.YCoordinateSpec,{field:\"y\"}]})))}}i.XYGlyph=d,d.__name__=\"XYGlyph\",d.init_XYGlyph()},\n", + " function _(n,t,e,o,r){o();const c=n(1),l=c.__importDefault(n(66)),i=c.__importDefault(n(67)),u=n(24),a=new i.default(\"GOOGLE\"),s=new i.default(\"WGS84\"),f=l.default(s,a);e.wgs84_mercator={compute:(n,t)=>isFinite(n)&&isFinite(t)?f.forward([n,t]):[NaN,NaN],invert:(n,t)=>isFinite(n)&&isFinite(t)?f.inverse([n,t]):[NaN,NaN]};const _={lon:[-20026376.39,20026376.39],lat:[-20048966.1,20048966.1]},p={lon:[-180,180],lat:[-85.06,85.06]},{min:g,max:h}=Math;function m(n,t){const o=g(n.length,t.length),r=u.infer_type(n,t),c=new r(o),l=new r(o);return e.inplace.project_xy(n,t,c,l),[c,l]}e.clip_mercator=function(n,t,e){const[o,r]=_[e];return[h(n,o),g(t,r)]},e.in_bounds=function(n,t){const[e,o]=p[t];return e2?void 0!==e.name&&\"geocent\"===e.name||void 0!==n.name&&\"geocent\"===n.name?\"number\"==typeof r.z?[r.x,r.y,r.z].concat(t.splice(3)):[r.x,r.y,t[2]].concat(t.splice(3)):[r.x,r.y].concat(t.splice(2)):[r.x,r.y]):(o=c.default(e,n,t),2===(a=Object.keys(t)).length||a.forEach((function(r){if(void 0!==e.name&&\"geocent\"===e.name||void 0!==n.name&&\"geocent\"===n.name){if(\"x\"===r||\"y\"===r||\"z\"===r)return}else if(\"x\"===r||\"y\"===r)return;o[r]=t[r]})),o)}function l(e){return e instanceof i.default?e:e.oProj?e.oProj:i.default(e)}t.default=function(e,n,t){e=l(e);var r,o=!1;return void 0===n?(n=e,e=u,o=!0):(void 0!==n.x||Array.isArray(n))&&(t=n,n=e,e=u,o=!0),n=l(n),t?f(e,n,t):(r={forward:function(t){return f(e,n,t)},inverse:function(t){return f(n,e,t)}},o&&(r.oProj=n),r)}},\n", + " function _(t,e,a,s,i){s();const u=t(1),l=u.__importDefault(t(68)),o=u.__importDefault(t(79)),r=u.__importDefault(t(80)),f=t(88),p=u.__importDefault(t(90)),d=u.__importDefault(t(91)),m=u.__importDefault(t(75));function n(t,e){if(!(this instanceof n))return new n(t);e=e||function(t){if(t)throw t};var a=l.default(t);if(\"object\"==typeof a){var s=n.projections.get(a.projName);if(s){if(a.datumCode&&\"none\"!==a.datumCode){var i=m.default(p.default,a.datumCode);i&&(a.datum_params=i.towgs84?i.towgs84.split(\",\"):null,a.ellps=i.ellipse,a.datumName=i.datumName?i.datumName:a.datumCode)}a.k0=a.k0||1,a.axis=a.axis||\"enu\",a.ellps=a.ellps||\"wgs84\";var u=f.sphere(a.a,a.b,a.rf,a.ellps,a.sphere),r=f.eccentricity(u.a,u.b,u.rf,a.R_A),h=a.datum||d.default(a.datumCode,a.datum_params,u.a,u.b,r.es,r.ep2);o.default(this,a),o.default(this,s),this.a=u.a,this.b=u.b,this.rf=u.rf,this.sphere=u.sphere,this.es=r.es,this.e=r.e,this.ep2=r.ep2,this.datum=h,this.init(),e(null,this)}else e(t)}else e(t)}n.projections=r.default,n.projections.start(),a.default=n},\n", + " function _(t,r,n,u,e){u();const f=t(1),i=f.__importDefault(t(69)),a=f.__importDefault(t(76)),o=f.__importDefault(t(71)),l=f.__importDefault(t(75));var C=[\"PROJECTEDCRS\",\"PROJCRS\",\"GEOGCS\",\"GEOCCS\",\"PROJCS\",\"LOCAL_CS\",\"GEODCRS\",\"GEODETICCRS\",\"GEODETICDATUM\",\"ENGCRS\",\"ENGINEERINGCRS\"];var d=[\"3857\",\"900913\",\"3785\",\"102113\"];n.default=function(t){if(!function(t){return\"string\"==typeof t}(t))return t;if(function(t){return t in i.default}(t))return i.default[t];if(function(t){return C.some((function(r){return t.indexOf(r)>-1}))}(t)){var r=a.default(t);if(function(t){var r=l.default(t,\"authority\");if(r){var n=l.default(r,\"epsg\");return n&&d.indexOf(n)>-1}}(r))return i.default[\"EPSG:3857\"];var n=function(t){var r=l.default(t,\"extension\");if(r)return l.default(r,\"proj4\")}(r);return n?o.default(n):r}return function(t){return\"+\"===t[0]}(t)?o.default(t):void 0}},\n", + " function _(t,r,i,e,n){e();const f=t(1),a=f.__importDefault(t(70)),l=f.__importDefault(t(71)),u=f.__importDefault(t(76));function o(t){var r=this;if(2===arguments.length){var i=arguments[1];\"string\"==typeof i?\"+\"===i.charAt(0)?o[t]=l.default(arguments[1]):o[t]=u.default(arguments[1]):o[t]=i}else if(1===arguments.length){if(Array.isArray(t))return t.map((function(t){Array.isArray(t)?o.apply(r,t):o(t)}));if(\"string\"==typeof t){if(t in o)return o[t]}else\"EPSG\"in t?o[\"EPSG:\"+t.EPSG]=t:\"ESRI\"in t?o[\"ESRI:\"+t.ESRI]=t:\"IAU2000\"in t?o[\"IAU2000:\"+t.IAU2000]=t:console.log(t);return}}a.default(o),i.default=o},\n", + " function _(t,l,G,S,e){S(),G.default=function(t){t(\"EPSG:4326\",\"+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees\"),t(\"EPSG:4269\",\"+title=NAD83 (long/lat) +proj=longlat +a=6378137.0 +b=6356752.31414036 +ellps=GRS80 +datum=NAD83 +units=degrees\"),t(\"EPSG:3857\",\"+title=WGS 84 / Pseudo-Mercator +proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs\"),t.WGS84=t[\"EPSG:4326\"],t[\"EPSG:3785\"]=t[\"EPSG:3857\"],t.GOOGLE=t[\"EPSG:3857\"],t[\"EPSG:900913\"]=t[\"EPSG:3857\"],t[\"EPSG:102113\"]=t[\"EPSG:3857\"]}},\n", + " function _(t,n,o,a,u){a();const e=t(1),r=t(72),i=e.__importDefault(t(73)),f=e.__importDefault(t(74)),l=e.__importDefault(t(75));o.default=function(t){var n,o,a,u={},e=t.split(\"+\").map((function(t){return t.trim()})).filter((function(t){return t})).reduce((function(t,n){var o=n.split(\"=\");return o.push(!0),t[o[0].toLowerCase()]=o[1],t}),{}),c={proj:\"projName\",datum:\"datumCode\",rf:function(t){u.rf=parseFloat(t)},lat_0:function(t){u.lat0=t*r.D2R},lat_1:function(t){u.lat1=t*r.D2R},lat_2:function(t){u.lat2=t*r.D2R},lat_ts:function(t){u.lat_ts=t*r.D2R},lon_0:function(t){u.long0=t*r.D2R},lon_1:function(t){u.long1=t*r.D2R},lon_2:function(t){u.long2=t*r.D2R},alpha:function(t){u.alpha=parseFloat(t)*r.D2R},lonc:function(t){u.longc=t*r.D2R},x_0:function(t){u.x0=parseFloat(t)},y_0:function(t){u.y0=parseFloat(t)},k_0:function(t){u.k0=parseFloat(t)},k:function(t){u.k0=parseFloat(t)},a:function(t){u.a=parseFloat(t)},b:function(t){u.b=parseFloat(t)},r_a:function(){u.R_A=!0},zone:function(t){u.zone=parseInt(t,10)},south:function(){u.utmSouth=!0},towgs84:function(t){u.datum_params=t.split(\",\").map((function(t){return parseFloat(t)}))},to_meter:function(t){u.to_meter=parseFloat(t)},units:function(t){u.units=t;var n=l.default(f.default,t);n&&(u.to_meter=n.to_meter)},from_greenwich:function(t){u.from_greenwich=t*r.D2R},pm:function(t){var n=l.default(i.default,t);u.from_greenwich=(n||parseFloat(t))*r.D2R},nadgrids:function(t){\"@null\"===t?u.datumCode=\"none\":u.nadgrids=t},axis:function(t){var n=\"ewnsud\";3===t.length&&-1!==n.indexOf(t.substr(0,1))&&-1!==n.indexOf(t.substr(1,1))&&-1!==n.indexOf(t.substr(2,1))&&(u.axis=t)}};for(n in e)o=e[n],n in c?\"function\"==typeof(a=c[n])?a(o):u[a]=o:u[n]=o;return\"string\"==typeof u.datumCode&&\"WGS84\"!==u.datumCode&&(u.datumCode=u.datumCode.toLowerCase()),u}},\n", + " function _(P,A,_,D,I){D(),_.PJD_3PARAM=1,_.PJD_7PARAM=2,_.PJD_WGS84=4,_.PJD_NODATUM=5,_.SEC_TO_RAD=484813681109536e-20,_.HALF_PI=Math.PI/2,_.SIXTH=.16666666666666666,_.RA4=.04722222222222222,_.RA6=.022156084656084655,_.EPSLN=1e-10,_.D2R=.017453292519943295,_.R2D=57.29577951308232,_.FORTPI=Math.PI/4,_.TWO_PI=2*Math.PI,_.SPI=3.14159265359},\n", + " function _(o,r,a,e,s){e();var n={};a.default=n,n.greenwich=0,n.lisbon=-9.131906111111,n.paris=2.337229166667,n.bogota=-74.080916666667,n.madrid=-3.687938888889,n.rome=12.452333333333,n.bern=7.439583333333,n.jakarta=106.807719444444,n.ferro=-17.666666666667,n.brussels=4.367975,n.stockholm=18.058277777778,n.athens=23.7163375,n.oslo=10.722916666667},\n", + " function _(t,e,f,o,u){o(),f.default={ft:{to_meter:.3048},\"us-ft\":{to_meter:1200/3937}}},\n", + " function _(e,r,t,a,n){a();var o=/[\\s_\\-\\/\\(\\)]/g;t.default=function(e,r){if(e[r])return e[r];for(var t,a=Object.keys(e),n=r.toLowerCase().replace(o,\"\"),f=-1;++f0?90:-90),e.lat_ts=e.lat1)}(d),d}},\n", + " function _(t,e,r,i,s){i(),r.default=function(t){return new d(t).output()};var h=/\\s/,o=/[A-Za-z]/,n=/[A-Za-z84]/,a=/[,\\]]/,u=/[\\d\\.E\\-\\+]/;function d(t){if(\"string\"!=typeof t)throw new Error(\"not a string\");this.text=t.trim(),this.level=0,this.place=0,this.root=null,this.stack=[],this.currentObject=null,this.state=1}d.prototype.readCharicter=function(){var t=this.text[this.place++];if(4!==this.state)for(;h.test(t);){if(this.place>=this.text.length)return;t=this.text[this.place++]}switch(this.state){case 1:return this.neutral(t);case 2:return this.keyword(t);case 4:return this.quoted(t);case 5:return this.afterquote(t);case 3:return this.number(t);case-1:return}},d.prototype.afterquote=function(t){if('\"'===t)return this.word+='\"',void(this.state=4);if(a.test(t))return this.word=this.word.trim(),void this.afterItem(t);throw new Error(\"havn't handled \\\"\"+t+'\" in afterquote yet, index '+this.place)},d.prototype.afterItem=function(t){return\",\"===t?(null!==this.word&&this.currentObject.push(this.word),this.word=null,void(this.state=1)):\"]\"===t?(this.level--,null!==this.word&&(this.currentObject.push(this.word),this.word=null),this.state=1,this.currentObject=this.stack.pop(),void(this.currentObject||(this.state=-1))):void 0},d.prototype.number=function(t){if(!u.test(t)){if(a.test(t))return this.word=parseFloat(this.word),void this.afterItem(t);throw new Error(\"havn't handled \\\"\"+t+'\" in number yet, index '+this.place)}this.word+=t},d.prototype.quoted=function(t){'\"'!==t?this.word+=t:this.state=5},d.prototype.keyword=function(t){if(n.test(t))this.word+=t;else{if(\"[\"===t){var e=[];return e.push(this.word),this.level++,null===this.root?this.root=e:this.currentObject.push(e),this.stack.push(this.currentObject),this.currentObject=e,void(this.state=1)}if(!a.test(t))throw new Error(\"havn't handled \\\"\"+t+'\" in keyword yet, index '+this.place);this.afterItem(t)}},d.prototype.neutral=function(t){if(o.test(t))return this.word=t,void(this.state=2);if('\"'===t)return this.word=\"\",void(this.state=4);if(u.test(t))return this.word=t,void(this.state=3);if(!a.test(t))throw new Error(\"havn't handled \\\"\"+t+'\" in neutral yet, index '+this.place);this.afterItem(t)},d.prototype.output=function(){for(;this.place90&&a*o.R2D<-90&&h*o.R2D>180&&h*o.R2D<-180)return null;if(Math.abs(Math.abs(a)-o.HALF_PI)<=o.EPSLN)return null;if(this.sphere)i=this.x0+this.a*this.k0*n.default(h-this.long0),s=this.y0+this.a*this.k0*Math.log(Math.tan(o.FORTPI+.5*a));else{var e=Math.sin(a),r=l.default(this.e,a,e);i=this.x0+this.a*this.k0*n.default(h-this.long0),s=this.y0-this.a*this.k0*Math.log(r)}return t.x=i,t.y=s,t}function M(t){var i,s,h=t.x-this.x0,a=t.y-this.y0;if(this.sphere)s=o.HALF_PI-2*Math.atan(Math.exp(-a/(this.a*this.k0)));else{var e=Math.exp(-a/(this.a*this.k0));if(-9999===(s=u.default(this.e,e)))return null}return i=n.default(this.long0+h/(this.a*this.k0)),t.x=i,t.y=s,t}s.init=f,s.forward=_,s.inverse=M,s.names=[\"Mercator\",\"Popular Visualisation Pseudo Mercator\",\"Mercator_1SP\",\"Mercator_Auxiliary_Sphere\",\"merc\"],s.default={init:f,forward:_,inverse:M,names:s.names}},\n", + " function _(t,n,r,u,a){u(),r.default=function(t,n,r){var u=t*n;return r/Math.sqrt(1-u*u)}},\n", + " function _(t,n,u,a,f){a();const e=t(1),o=t(72),_=e.__importDefault(t(84));u.default=function(t){return Math.abs(t)<=o.SPI?t:t-_.default(t)*o.TWO_PI}},\n", + " function _(n,t,u,f,c){f(),u.default=function(n){return n<0?-1:1}},\n", + " function _(t,n,a,o,u){o();const c=t(72);a.default=function(t,n,a){var o=t*a,u=.5*t;return o=Math.pow((1-o)/(1+o),u),Math.tan(.5*(c.HALF_PI-n))/o}},\n", + " function _(t,a,n,r,f){r();const h=t(72);n.default=function(t,a){for(var n,r,f=.5*t,o=h.HALF_PI-2*Math.atan(a),u=0;u<=15;u++)if(n=t*Math.sin(o),o+=r=h.HALF_PI-2*Math.atan(a*Math.pow((1-n)/(1+n),f))-o,Math.abs(r)<=1e-10)return o;return-9999}},\n", + " function _(n,i,e,t,r){function a(){}function f(n){return n}t(),e.init=a,e.forward=f,e.inverse=f,e.names=[\"longlat\",\"identity\"],e.default={init:a,forward:f,inverse:f,names:e.names}},\n", + " function _(t,r,e,a,n){a();const f=t(1),i=t(72),u=f.__importStar(t(89)),c=f.__importDefault(t(75));e.eccentricity=function(t,r,e,a){var n=t*t,f=r*r,u=(n-f)/n,c=0;return a?(n=(t*=1-u*(i.SIXTH+u*(i.RA4+u*i.RA6)))*t,u=0):c=Math.sqrt(u),{es:u,e:c,ep2:(n-f)/f}},e.sphere=function(t,r,e,a,n){if(!t){var f=c.default(u.default,a);f||(f=u.WGS84),t=f.a,r=f.b,e=f.rf}return e&&!r&&(r=(1-1/e)*t),(0===e||Math.abs(t-r)3&&(0===r.datum_params[3]&&0===r.datum_params[4]&&0===r.datum_params[5]&&0===r.datum_params[6]||(r.datum_type=p.PJD_7PARAM,r.datum_params[3]*=p.SEC_TO_RAD,r.datum_params[4]*=p.SEC_TO_RAD,r.datum_params[5]*=p.SEC_TO_RAD,r.datum_params[6]=r.datum_params[6]/1e6+1))),r.a=_,r.b=t,r.es=u,r.ep2=d,r}},\n", + " function _(t,e,a,r,u){r();const m=t(1),_=t(72),o=m.__importDefault(t(93)),d=m.__importDefault(t(95)),f=m.__importDefault(t(67)),n=m.__importDefault(t(96)),i=m.__importDefault(t(97));a.default=function t(e,a,r){var u;if(Array.isArray(r)&&(r=n.default(r)),i.default(r),e.datum&&a.datum&&function(t,e){return(t.datum.datum_type===_.PJD_3PARAM||t.datum.datum_type===_.PJD_7PARAM)&&\"WGS84\"!==e.datumCode||(e.datum.datum_type===_.PJD_3PARAM||e.datum.datum_type===_.PJD_7PARAM)&&\"WGS84\"!==t.datumCode}(e,a)&&(r=t(e,u=new f.default(\"WGS84\"),r),e=u),\"enu\"!==e.axis&&(r=d.default(e,!1,r)),\"longlat\"===e.projName)r={x:r.x*_.D2R,y:r.y*_.D2R,z:r.z||0};else if(e.to_meter&&(r={x:r.x*e.to_meter,y:r.y*e.to_meter,z:r.z||0}),!(r=e.inverse(r)))return;return e.from_greenwich&&(r.x+=e.from_greenwich),r=o.default(e.datum,a.datum,r),a.from_greenwich&&(r={x:r.x-a.from_greenwich,y:r.y,z:r.z||0}),\"longlat\"===a.projName?r={x:r.x*_.R2D,y:r.y*_.R2D,z:r.z||0}:(r=a.forward(r),a.to_meter&&(r={x:r.x/a.to_meter,y:r.y/a.to_meter,z:r.z||0})),\"enu\"!==a.axis?d.default(a,!0,r):r}},\n", + " function _(t,e,a,u,c){u();const m=t(72),o=t(94);function _(t){return t===m.PJD_3PARAM||t===m.PJD_7PARAM}a.default=function(t,e,a){return o.compareDatums(t,e)||t.datum_type===m.PJD_NODATUM||e.datum_type===m.PJD_NODATUM?a:t.es!==e.es||t.a!==e.a||_(t.datum_type)||_(e.datum_type)?(a=o.geodeticToGeocentric(a,t.es,t.a),_(t.datum_type)&&(a=o.geocentricToWgs84(a,t.datum_type,t.datum_params)),_(e.datum_type)&&(a=o.geocentricFromWgs84(a,e.datum_type,e.datum_params)),o.geocentricToGeodetic(a,e.es,e.a,e.b)):a}},\n", + " function _(a,t,r,m,s){m();const u=a(72);r.compareDatums=function(a,t){return a.datum_type===t.datum_type&&(!(a.a!==t.a||Math.abs(a.es-t.es)>5e-11)&&(a.datum_type===u.PJD_3PARAM?a.datum_params[0]===t.datum_params[0]&&a.datum_params[1]===t.datum_params[1]&&a.datum_params[2]===t.datum_params[2]:a.datum_type!==u.PJD_7PARAM||a.datum_params[0]===t.datum_params[0]&&a.datum_params[1]===t.datum_params[1]&&a.datum_params[2]===t.datum_params[2]&&a.datum_params[3]===t.datum_params[3]&&a.datum_params[4]===t.datum_params[4]&&a.datum_params[5]===t.datum_params[5]&&a.datum_params[6]===t.datum_params[6]))},r.geodeticToGeocentric=function(a,t,r){var m,s,_,e,n=a.x,d=a.y,i=a.z?a.z:0;if(d<-u.HALF_PI&&d>-1.001*u.HALF_PI)d=-u.HALF_PI;else if(d>u.HALF_PI&&d<1.001*u.HALF_PI)d=u.HALF_PI;else{if(d<-u.HALF_PI)return{x:-1/0,y:-1/0,z:a.z};if(d>u.HALF_PI)return{x:1/0,y:1/0,z:a.z}}return n>Math.PI&&(n-=2*Math.PI),s=Math.sin(d),e=Math.cos(d),_=s*s,{x:((m=r/Math.sqrt(1-t*_))+i)*e*Math.cos(n),y:(m+i)*e*Math.sin(n),z:(m*(1-t)+i)*s}},r.geocentricToGeodetic=function(a,t,r,m){var s,_,e,n,d,i,p,P,y,z,M,o,A,c,x,h=1e-12,f=a.x,I=a.y,F=a.z?a.z:0;if(s=Math.sqrt(f*f+I*I),_=Math.sqrt(f*f+I*I+F*F),s/r1e-24&&A<30);return{x:c,y:Math.atan(M/Math.abs(z)),z:x}},r.geocentricToWgs84=function(a,t,r){if(t===u.PJD_3PARAM)return{x:a.x+r[0],y:a.y+r[1],z:a.z+r[2]};if(t===u.PJD_7PARAM){var m=r[0],s=r[1],_=r[2],e=r[3],n=r[4],d=r[5],i=r[6];return{x:i*(a.x-d*a.y+n*a.z)+m,y:i*(d*a.x+a.y-e*a.z)+s,z:i*(-n*a.x+e*a.y+a.z)+_}}},r.geocentricFromWgs84=function(a,t,r){if(t===u.PJD_3PARAM)return{x:a.x-r[0],y:a.y-r[1],z:a.z-r[2]};if(t===u.PJD_7PARAM){var m=r[0],s=r[1],_=r[2],e=r[3],n=r[4],d=r[5],i=r[6],p=(a.x-m)/i,P=(a.y-s)/i,y=(a.z-_)/i;return{x:p+d*P-n*y,y:-d*p+P+e*y,z:n*p-e*P+y}}}},\n", + " function _(e,a,i,r,s){r(),i.default=function(e,a,i){var r,s,n,c=i.x,d=i.y,f=i.z||0,u={};for(n=0;n<3;n++)if(!a||2!==n||void 0!==i.z)switch(0===n?(r=c,s=-1!==\"ew\".indexOf(e.axis[n])?\"x\":\"y\"):1===n?(r=d,s=-1!==\"ns\".indexOf(e.axis[n])?\"y\":\"x\"):(r=f,s=\"z\"),e.axis[n]){case\"e\":u[s]=r;break;case\"w\":u[s]=-r;break;case\"n\":u[s]=r;break;case\"s\":u[s]=-r;break;case\"u\":void 0!==i[s]&&(u.z=r);break;case\"d\":void 0!==i[s]&&(u.z=-r);break;default:return null}return u}},\n", + " function _(n,t,e,u,f){u(),e.default=function(n){var t={x:n[0],y:n[1]};return n.length>2&&(t.z=n[2]),n.length>3&&(t.m=n[3]),t}},\n", + " function _(e,i,n,t,r){function o(e){if(\"function\"==typeof Number.isFinite){if(Number.isFinite(e))return;throw new TypeError(\"coordinates must be finite numbers\")}if(\"number\"!=typeof e||e!=e||!isFinite(e))throw new TypeError(\"coordinates must be finite numbers\")}t(),n.default=function(e){o(e.x),o(e.y)}},\n", + " function _(e,t,s,i,n){i();const r=e(1),a=r.__importStar(e(18)),o=r.__importStar(e(99)),_=r.__importStar(e(45)),l=e(42),c=e(53),h=e(19),d=e(24),u=e(8),f=e(100),p=e(12),g=e(26),y=e(101),x=e(104),v=e(59),{abs:b,ceil:m}=Math;class w extends l.View{constructor(){super(...arguments),this._index=null,this._data_size=null,this._nohit_warned=new Set}get renderer(){return this.parent}get has_webgl(){return null!=this.glglyph}get index(){const{_index:e}=this;if(null!=e)return e;throw new Error(`${this}.index_data() wasn't called`)}get data_size(){const{_data_size:e}=this;if(null!=e)return e;throw new Error(`${this}.set_data() wasn't called`)}initialize(){super.initialize(),this.visuals=new _.Visuals(this)}request_render(){this.parent.request_render()}get canvas(){return this.renderer.parent.canvas_view}render(e,t,s){var i;null!=this.glglyph&&(this.renderer.needs_webgl_blit=this.glglyph.render(e,t,null!==(i=this.base)&&void 0!==i?i:this),this.renderer.needs_webgl_blit)||(e.beginPath(),this._render(e,t,null!=s?s:this.base))}has_finished(){return!0}notify_finished(){this.renderer.notify_finished()}_bounds(e){return e}bounds(){return this._bounds(this.index.bbox)}log_bounds(){const{x0:e,x1:t}=this.index.bounds(o.positive_x()),{y0:s,y1:i}=this.index.bounds(o.positive_y());return this._bounds({x0:e,y0:s,x1:t,y1:i})}get_anchor_point(e,t,[s,i]){switch(e){case\"center\":case\"center_center\":{const[e,n]=this.scenterxy(t,s,i);return{x:e,y:n}}default:return null}}scenterx(e,t,s){return this.scenterxy(e,t,s)[0]}scentery(e,t,s){return this.scenterxy(e,t,s)[1]}sdist(e,t,s,i=\"edge\",n=!1){const r=t.length,a=new d.ScreenArray(r),o=e.s_compute;if(\"center\"==i)for(let e=0;em(e))),a}draw_legend_for_index(e,t,s){}hit_test(e){switch(e.type){case\"point\":if(null!=this._hit_point)return this._hit_point(e);break;case\"span\":if(null!=this._hit_span)return this._hit_span(e);break;case\"rect\":if(null!=this._hit_rect)return this._hit_rect(e);break;case\"poly\":if(null!=this._hit_poly)return this._hit_poly(e)}return this._nohit_warned.has(e.type)||(h.logger.debug(`'${e.type}' selection not available for ${this.model.type}`),this._nohit_warned.add(e.type)),null}_hit_rect_against_index(e){const{sx0:t,sx1:s,sy0:i,sy1:n}=e,[r,a]=this.renderer.coordinates.x_scale.r_invert(t,s),[o,_]=this.renderer.coordinates.y_scale.r_invert(i,n),l=[...this.index.indices({x0:r,x1:a,y0:o,y1:_})];return new v.Selection({indices:l})}_project_data(){}*_iter_visuals(){for(const e of this.visuals)for(const t of e)(t instanceof a.VectorSpec||t instanceof a.ScalarSpec)&&(yield t)}set_base(e){e!=this&&e instanceof this.constructor&&(this.base=e)}_configure(e,t){Object.defineProperty(this,u.isString(e)?e:e.attr,Object.assign({configurable:!0,enumerable:!0},t))}set_visuals(e,t){var s;for(const s of this._iter_visuals()){const{base:i}=this;if(null!=i){const e=i.model.properties[s.attr];if(null!=e&&g.is_equal(s.get_value(),e.get_value())){this._configure(s,{get:()=>i[`${s.attr}`]});continue}}const n=s.uniform(e).select(t);this._configure(s,{value:n})}for(const e of this.visuals)e.update();null===(s=this.glglyph)||void 0===s||s.set_visuals_changed()}set_data(e,t,s){var i;const{x_range:n,y_range:r}=this.renderer.coordinates,o=new Set(this._iter_visuals());this._data_size=t.count;for(const s of this.model)if((s instanceof a.VectorSpec||s instanceof a.ScalarSpec)&&!o.has(s))if(s instanceof a.BaseCoordinateSpec){const i=s.array(e);let o=t.select(i);const _=\"x\"==s.dimension?n:r;if(_ instanceof x.FactorRange)if(s instanceof a.CoordinateSpec)o=_.v_synthetic(o);else if(s instanceof a.CoordinateSeqSpec)for(let e=0;e=0&&r>=0))throw new Error(`invalid bbox {x: ${i}, y: ${e}, width: ${h}, height: ${r}}`);this.x0=i,this.y0=e,this.x1=i+h,this.y1=e+r}else{let i,e,h,r;if(\"width\"in t)if(\"left\"in t)i=t.left,e=i+t.width;else if(\"right\"in t)e=t.right,i=e-t.width;else{const h=t.width/2;i=t.hcenter-h,e=t.hcenter+h}else i=t.left,e=t.right;if(\"height\"in t)if(\"top\"in t)h=t.top,r=h+t.height;else if(\"bottom\"in t)r=t.bottom,h=r-t.height;else{const i=t.height/2;h=t.vcenter-i,r=t.vcenter+i}else h=t.top,r=t.bottom;if(!(i<=e&&h<=r))throw new Error(`invalid bbox {left: ${i}, top: ${h}, right: ${e}, bottom: ${r}}`);this.x0=i,this.y0=h,this.x1=e,this.y1=r}}static from_rect({left:t,right:i,top:e,bottom:h}){return new o({x0:Math.min(t,i),y0:Math.min(e,h),x1:Math.max(t,i),y1:Math.max(e,h)})}equals(t){return this.x0==t.x0&&this.y0==t.y0&&this.x1==t.x1&&this.y1==t.y1}[n.equals](t,i){return i.eq(this.x0,t.x0)&&i.eq(this.y0,t.y0)&&i.eq(this.x1,t.x1)&&i.eq(this.y1,t.y1)}toString(){return`BBox({left: ${this.left}, top: ${this.top}, width: ${this.width}, height: ${this.height}})`}get left(){return this.x0}get top(){return this.y0}get right(){return this.x1}get bottom(){return this.y1}get p0(){return[this.x0,this.y0]}get p1(){return[this.x1,this.y1]}get x(){return this.x0}get y(){return this.y0}get width(){return this.x1-this.x0}get height(){return this.y1-this.y0}get size(){return{width:this.width,height:this.height}}get rect(){const{x0:t,y0:i,x1:e,y1:h}=this;return{p0:{x:t,y:i},p1:{x:e,y:i},p2:{x:e,y:h},p3:{x:t,y:h}}}get box(){const{x:t,y:i,width:e,height:h}=this;return{x:t,y:i,width:e,height:h}}get h_range(){return{start:this.x0,end:this.x1}}get v_range(){return{start:this.y0,end:this.y1}}get ranges(){return[this.h_range,this.v_range]}get aspect(){return this.width/this.height}get hcenter(){return(this.left+this.right)/2}get vcenter(){return(this.top+this.bottom)/2}get area(){return this.width*this.height}relative(){const{width:t,height:i}=this;return new o({x:0,y:0,width:t,height:i})}translate(t,i){const{x:e,y:h,width:r,height:s}=this;return new o({x:t+e,y:i+h,width:r,height:s})}relativize(t,i){return[t-this.x,i-this.y]}contains(t,i){return this.x0<=t&&t<=this.x1&&this.y0<=i&&i<=this.y1}clip(t,i){return tthis.x1&&(t=this.x1),ithis.y1&&(i=this.y1),[t,i]}grow_by(t){return new o({left:this.left-t,right:this.right+t,top:this.top-t,bottom:this.bottom+t})}shrink_by(t){return new o({left:this.left+t,right:this.right-t,top:this.top+t,bottom:this.bottom-t})}union(t){return new o({x0:x(this.x0,t.x0),y0:x(this.y0,t.y0),x1:y(this.x1,t.x1),y1:y(this.y1,t.y1)})}intersection(t){return this.intersects(t)?new o({x0:y(this.x0,t.x0),y0:y(this.y0,t.y0),x1:x(this.x1,t.x1),y1:x(this.y1,t.y1)}):null}intersects(t){return!(t.x1this.x1||t.y1this.y1)}get xview(){return{compute:t=>this.left+t,v_compute:t=>{const i=new s.ScreenArray(t.length),e=this.left;for(let h=0;hthis.bottom-t,v_compute:t=>{const i=new s.ScreenArray(t.length),e=this.bottom;for(let h=0;h{const s=new Uint32Array(r);for(let n=0;n>1;i[s]>n?e=s:t=s+1}return i[t]}class r extends o.default{search_indices(n,i,t,e){if(this._pos!==this._boxes.length)throw new Error(\"Data not yet indexed - call index.finish().\");let s=this._boxes.length-4;const o=[],x=new d.Indices(this.numItems);for(;void 0!==s;){const d=Math.min(s+4*this.nodeSize,h(s,this._levelBounds));for(let h=s;h>2];tthis._boxes[h+2]||i>this._boxes[h+3]||(s<4*this.numItems?x.set(d):o.push(d)))}s=o.pop()}return x}}r.__name__=\"_FlatBush\";class l{constructor(n){this.index=null,n>0&&(this.index=new r(n))}add(n,i,t,e){var s;null===(s=this.index)||void 0===s||s.add(n,i,t,e)}add_empty(){var n;null===(n=this.index)||void 0===n||n.add(1/0,1/0,-1/0,-1/0)}finish(){var n;null===(n=this.index)||void 0===n||n.finish()}_normalize(n){let{x0:i,y0:t,x1:e,y1:s}=n;return i>e&&([i,e]=[e,i]),t>s&&([t,s]=[s,t]),{x0:i,y0:t,x1:e,y1:s}}get bbox(){if(null==this.index)return x.empty();{const{minX:n,minY:i,maxX:t,maxY:e}=this.index;return{x0:n,y0:i,x1:t,y1:e}}}indices(n){if(null==this.index)return new d.Indices(0);{const{x0:i,y0:t,x1:e,y1:s}=this._normalize(n);return this.index.search_indices(i,t,e,s)}}bounds(n){const i=x.empty();for(const t of this.indices(n)){const n=this.index._boxes,e=n[4*t+0],s=n[4*t+1],o=n[4*t+2],d=n[4*t+3];ei.x1&&(i.x1=o),si.y1&&(i.y1=d)}return i}}t.SpatialIndex=l,l.__name__=\"SpatialIndex\"},\n", + " function _(t,s,i,e,h){e();const n=t(1).__importDefault(t(103)),o=[Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];class r{static from(t){if(!(t instanceof ArrayBuffer))throw new Error(\"Data must be an instance of ArrayBuffer.\");const[s,i]=new Uint8Array(t,0,2);if(251!==s)throw new Error(\"Data does not appear to be in a Flatbush format.\");if(i>>4!=3)throw new Error(`Got v${i>>4} data when expected v3.`);const[e]=new Uint16Array(t,2,1),[h]=new Uint32Array(t,4,1);return new r(h,e,o[15&i],t)}constructor(t,s=16,i=Float64Array,e){if(void 0===t)throw new Error(\"Missing required argument: numItems.\");if(isNaN(t)||t<=0)throw new Error(`Unpexpected numItems value: ${t}.`);this.numItems=+t,this.nodeSize=Math.min(Math.max(+s,2),65535);let h=t,r=h;this._levelBounds=[4*h];do{h=Math.ceil(h/this.nodeSize),r+=h,this._levelBounds.push(4*r)}while(1!==h);this.ArrayType=i||Float64Array,this.IndexArrayType=r<16384?Uint16Array:Uint32Array;const a=o.indexOf(this.ArrayType),_=4*r*this.ArrayType.BYTES_PER_ELEMENT;if(a<0)throw new Error(`Unexpected typed array class: ${i}.`);e&&e instanceof ArrayBuffer?(this.data=e,this._boxes=new this.ArrayType(this.data,8,4*r),this._indices=new this.IndexArrayType(this.data,8+_,r),this._pos=4*r,this.minX=this._boxes[this._pos-4],this.minY=this._boxes[this._pos-3],this.maxX=this._boxes[this._pos-2],this.maxY=this._boxes[this._pos-1]):(this.data=new ArrayBuffer(8+_+r*this.IndexArrayType.BYTES_PER_ELEMENT),this._boxes=new this.ArrayType(this.data,8,4*r),this._indices=new this.IndexArrayType(this.data,8+_,r),this._pos=0,this.minX=1/0,this.minY=1/0,this.maxX=-1/0,this.maxY=-1/0,new Uint8Array(this.data,0,2).set([251,48+a]),new Uint16Array(this.data,2,1)[0]=s,new Uint32Array(this.data,4,1)[0]=t),this._queue=new n.default}add(t,s,i,e){const h=this._pos>>2;return this._indices[h]=h,this._boxes[this._pos++]=t,this._boxes[this._pos++]=s,this._boxes[this._pos++]=i,this._boxes[this._pos++]=e,tthis.maxX&&(this.maxX=i),e>this.maxY&&(this.maxY=e),h}finish(){if(this._pos>>2!==this.numItems)throw new Error(`Added ${this._pos>>2} items when expected ${this.numItems}.`);if(this.numItems<=this.nodeSize)return this._boxes[this._pos++]=this.minX,this._boxes[this._pos++]=this.minY,this._boxes[this._pos++]=this.maxX,void(this._boxes[this._pos++]=this.maxY);const t=this.maxX-this.minX,s=this.maxY-this.minY,i=new Uint32Array(this.numItems);for(let e=0;e>2]=t,this._boxes[this._pos++]=e,this._boxes[this._pos++]=h,this._boxes[this._pos++]=n,this._boxes[this._pos++]=o}}}search(t,s,i,e,h){if(this._pos!==this._boxes.length)throw new Error(\"Data not yet indexed - call index.finish().\");let n=this._boxes.length-4;const o=[],r=[];for(;void 0!==n;){const a=Math.min(n+4*this.nodeSize,_(n,this._levelBounds));for(let _=n;_>2];ithis._boxes[_+2]||s>this._boxes[_+3]||(n<4*this.numItems?(void 0===h||h(a))&&r.push(a):o.push(a)))}n=o.pop()}return r}neighbors(t,s,i=1/0,e=1/0,h){if(this._pos!==this._boxes.length)throw new Error(\"Data not yet indexed - call index.finish().\");let n=this._boxes.length-4;const o=this._queue,r=[],x=e*e;for(;void 0!==n;){const e=Math.min(n+4*this.nodeSize,_(n,this._levelBounds));for(let i=n;i>2],r=a(t,this._boxes[i],this._boxes[i+2]),_=a(s,this._boxes[i+1],this._boxes[i+3]),x=r*r+_*_;n<4*this.numItems?(void 0===h||h(e))&&o.push(-e-1,x):o.push(e,x)}for(;o.length&&o.peek()<0;){if(o.peekValue()>x)return o.clear(),r;if(r.push(-o.pop()-1),r.length===i)return o.clear(),r}n=o.pop()}return o.clear(),r}}function a(t,s,i){return t>1;s[h]>t?e=h:i=h+1}return s[i]}function x(t,s,i,e,h,n){if(Math.floor(e/n)>=Math.floor(h/n))return;const o=t[e+h>>1];let r=e-1,a=h+1;for(;;){do{r++}while(t[r]o);if(r>=a)break;d(t,s,i,r,a)}x(t,s,i,e,a,n),x(t,s,i,a+1,h,n)}function d(t,s,i,e,h){const n=t[e];t[e]=t[h],t[h]=n;const o=4*e,r=4*h,a=s[o],_=s[o+1],x=s[o+2],d=s[o+3];s[o]=s[r],s[o+1]=s[r+1],s[o+2]=s[r+2],s[o+3]=s[r+3],s[r]=a,s[r+1]=_,s[r+2]=x,s[r+3]=d;const m=i[e];i[e]=i[h],i[h]=m}function m(t,s){let i=t^s,e=65535^i,h=65535^(t|s),n=t&(65535^s),o=i|e>>1,r=i>>1^i,a=h>>1^e&n>>1^h,_=i&h>>1^n>>1^n;i=o,e=r,h=a,n=_,o=i&i>>2^e&e>>2,r=i&e>>2^e&(i^e)>>2,a^=i&h>>2^e&n>>2,_^=e&h>>2^(i^e)&n>>2,i=o,e=r,h=a,n=_,o=i&i>>4^e&e>>4,r=i&e>>4^e&(i^e)>>4,a^=i&h>>4^e&n>>4,_^=e&h>>4^(i^e)&n>>4,i=o,e=r,h=a,n=_,a^=i&h>>8^e&n>>8,_^=e&h>>8^(i^e)&n>>8,i=a^a>>1,e=_^_>>1;let x=t^s,d=e|65535^(x|i);return x=16711935&(x|x<<8),x=252645135&(x|x<<4),x=858993459&(x|x<<2),x=1431655765&(x|x<<1),d=16711935&(d|d<<8),d=252645135&(d|d<<4),d=858993459&(d|d<<2),d=1431655765&(d|d<<1),(d<<1|x)>>>0}i.default=r},\n", + " function _(s,t,i,h,e){h();i.default=class{constructor(){this.ids=[],this.values=[],this.length=0}clear(){this.length=0}push(s,t){let i=this.length++;for(this.ids[i]=s,this.values[i]=t;i>0;){const s=i-1>>1,h=this.values[s];if(t>=h)break;this.ids[i]=this.ids[s],this.values[i]=h,i=s}this.ids[i]=s,this.values[i]=t}pop(){if(0===this.length)return;const s=this.ids[0];if(this.length--,this.length>0){const s=this.ids[0]=this.ids[this.length],t=this.values[0]=this.values[this.length],i=this.length>>1;let h=0;for(;h=t)break;this.ids[h]=e,this.values[h]=l,h=s}this.ids[h]=s,this.values[h]=t}return s}peek(){if(0!==this.length)return this.ids[0]}peekValue(){if(0!==this.length)return this.values[0]}}},\n", + " function _(t,n,e,i,s){i();const r=t(105),a=t(20),o=t(21),g=t(24),p=t(9),c=t(8),l=t(11);function u(t,n,e=0){const i=new Map;for(let s=0;sa.get(t).value)));r.set(t,{value:l/s,mapping:a}),o+=s+n+c}return[r,(a.size-1)*n+g]}function d(t,n,e,i,s=0){var r;const a=new Map,o=new Map;for(const[n,e,i]of t){const t=null!==(r=o.get(n))&&void 0!==r?r:[];o.set(n,[...t,[e,i]])}let g=s,c=0;for(const[t,s]of o){const r=s.length,[o,l]=h(s,e,i,g);c+=l;const u=p.sum(s.map((([t])=>o.get(t).value)));a.set(t,{value:u/r,mapping:o}),g+=r+n+l}return[a,(o.size-1)*n+c]}e.Factor=o.Or(o.String,o.Tuple(o.String,o.String),o.Tuple(o.String,o.String,o.String)),e.FactorSeq=o.Or(o.Array(o.String),o.Array(o.Tuple(o.String,o.String)),o.Array(o.Tuple(o.String,o.String,o.String))),e.map_one_level=u,e.map_two_levels=h,e.map_three_levels=d;class _ extends r.Range{constructor(t){super(t)}static init_FactorRange(){this.define((({Number:t})=>({factors:[e.FactorSeq,[]],factor_padding:[t,0],subgroup_padding:[t,.8],group_padding:[t,1.4],range_padding:[t,0],range_padding_units:[a.PaddingUnits,\"percent\"],start:[t],end:[t]}))),this.internal((({Number:t,String:n,Array:e,Tuple:i,Nullable:s})=>({levels:[t],mids:[s(e(i(n,n))),null],tops:[s(e(n)),null]})))}get min(){return this.start}get max(){return this.end}initialize(){super.initialize(),this._init(!0)}connect_signals(){super.connect_signals(),this.connect(this.properties.factors.change,(()=>this.reset())),this.connect(this.properties.factor_padding.change,(()=>this.reset())),this.connect(this.properties.group_padding.change,(()=>this.reset())),this.connect(this.properties.subgroup_padding.change,(()=>this.reset())),this.connect(this.properties.range_padding.change,(()=>this.reset())),this.connect(this.properties.range_padding_units.change,(()=>this.reset()))}reset(){this._init(!1),this.change.emit()}_lookup(t){switch(t.length){case 1:{const[n]=t,e=this._mapping.get(n);return null!=e?e.value:NaN}case 2:{const[n,e]=t,i=this._mapping.get(n);if(null!=i){const t=i.mapping.get(e);if(null!=t)return t.value}return NaN}case 3:{const[n,e,i]=t,s=this._mapping.get(n);if(null!=s){const t=s.mapping.get(e);if(null!=t){const n=t.mapping.get(i);if(null!=n)return n.value}}return NaN}default:l.unreachable()}}synthetic(t){if(c.isNumber(t))return t;if(c.isString(t))return this._lookup([t]);let n=0;const e=t[t.length-1];return c.isNumber(e)&&(n=e,t=t.slice(0,-1)),this._lookup(t)+n}v_synthetic(t){const n=t.length,e=new g.ScreenArray(n);for(let i=0;i{if(p.every(this.factors,c.isString)){const t=this.factors,[n,e]=u(t,this.factor_padding);return{levels:1,mapping:n,tops:null,mids:null,inside_padding:e}}if(p.every(this.factors,(t=>c.isArray(t)&&2==t.length&&c.isString(t[0])&&c.isString(t[1])))){const t=this.factors,[n,e]=h(t,this.group_padding,this.factor_padding),i=[...n.keys()];return{levels:2,mapping:n,tops:i,mids:null,inside_padding:e}}if(p.every(this.factors,(t=>c.isArray(t)&&3==t.length&&c.isString(t[0])&&c.isString(t[1])&&c.isString(t[2])))){const t=this.factors,[n,e]=d(t,this.group_padding,this.subgroup_padding,this.factor_padding),i=[...n.keys()],s=[];for(const[t,e]of n)for(const n of e.mapping.keys())s.push([t,n]);return{levels:3,mapping:n,tops:i,mids:s,inside_padding:e}}l.unreachable()})();this._mapping=e,this.tops=i,this.mids=s;let a=0,o=this.factors.length+r;if(\"percent\"==this.range_padding_units){const t=(o-a)*this.range_padding/2;a-=t,o+=t}else a-=this.range_padding,o+=this.range_padding;this.setv({start:a,end:o,levels:n},{silent:t}),\"auto\"==this.bounds&&this.setv({bounds:[a,o]},{silent:!0})}}e.FactorRange=_,_.__name__=\"FactorRange\",_.init_FactorRange()},\n", + " function _(e,t,i,n,s){n();const a=e(53);class l extends a.Model{constructor(e){super(e),this.have_updated_interactively=!1}static init_Range(){this.define((({Number:e,Tuple:t,Or:i,Auto:n,Nullable:s})=>({bounds:[s(i(t(s(e),s(e)),n)),null],min_interval:[s(e),null],max_interval:[s(e),null]}))),this.internal((({Array:e,AnyRef:t})=>({plots:[e(t()),[]]})))}get is_reversed(){return this.start>this.end}get is_valid(){return isFinite(this.min)&&isFinite(this.max)}}i.Range=l,l.__name__=\"Range\",l.init_Range()},\n", + " function _(e,t,i,n,l){n();const o=e(1).__importStar(e(107));function a(e,t,{x0:i,x1:n,y0:l,y1:o},a){t.save(),t.beginPath(),t.moveTo(i,(l+o)/2),t.lineTo(n,(l+o)/2),e.line.doit&&(e.line.set_vectorize(t,a),t.stroke()),t.restore()}function r(e,t,{x0:i,x1:n,y0:l,y1:o},a){var r,c;const s=.1*Math.abs(n-i),_=.1*Math.abs(o-l),v=i+s,d=n-s,h=l+_,g=o-_;t.beginPath(),t.rect(v,h,d-v,g-h),e.fill.doit&&(e.fill.set_vectorize(t,a),t.fill()),(null===(r=e.hatch)||void 0===r?void 0:r.doit)&&(e.hatch.set_vectorize(t,a),t.fill()),(null===(c=e.line)||void 0===c?void 0:c.doit)&&(e.line.set_vectorize(t,a),t.stroke())}i.generic_line_scalar_legend=function(e,t,{x0:i,x1:n,y0:l,y1:o}){t.save(),t.beginPath(),t.moveTo(i,(l+o)/2),t.lineTo(n,(l+o)/2),e.line.doit&&(e.line.set_value(t),t.stroke()),t.restore()},i.generic_line_vector_legend=a,i.generic_line_legend=a,i.generic_area_scalar_legend=function(e,t,{x0:i,x1:n,y0:l,y1:o}){var a,r;const c=.1*Math.abs(n-i),s=.1*Math.abs(o-l),_=i+c,v=n-c,d=l+s,h=o-s;t.beginPath(),t.rect(_,d,v-_,h-d),e.fill.doit&&(e.fill.set_value(t),t.fill()),(null===(a=e.hatch)||void 0===a?void 0:a.doit)&&(e.hatch.set_value(t),t.fill()),(null===(r=e.line)||void 0===r?void 0:r.doit)&&(e.line.set_value(t),t.stroke())},i.generic_area_vector_legend=r,i.generic_area_legend=r,i.line_interpolation=function(e,t,i,n,l,a){const{sx:r,sy:c}=t;let s,_,v,d;\"point\"==t.type?([v,d]=e.yscale.r_invert(c-1,c+1),[s,_]=e.xscale.r_invert(r-1,r+1)):\"v\"==t.direction?([v,d]=e.yscale.r_invert(c,c),[s,_]=[Math.min(i-1,l-1),Math.max(i+1,l+1)]):([s,_]=e.xscale.r_invert(r,r),[v,d]=[Math.min(n-1,a-1),Math.max(n+1,a+1)]);const{x:h,y:g}=o.check_2_segments_intersect(s,v,_,d,i,n,l,a);return[h,g]}},\n", + " function _(t,n,e,i,r){function s(t,n){return(t.x-n.x)**2+(t.y-n.y)**2}function o(t,n,e){const i=s(n,e);if(0==i)return s(t,n);const r=((t.x-n.x)*(e.x-n.x)+(t.y-n.y)*(e.y-n.y))/i;if(r<0)return s(t,n);if(r>1)return s(t,e);return s(t,{x:n.x+r*(e.x-n.x),y:n.y+r*(e.y-n.y)})}i(),e.point_in_poly=function(t,n,e,i){let r=!1,s=e[e.length-1],o=i[i.length-1];for(let u=0;u0&&_<1&&h>0&&h<1,x:t+_*(e-t),y:n+_*(i-n)}}}},\n", + " function _(t,e,s,i,a){i();const o=t(1),n=t(109),_=t(113),r=o.__importDefault(t(114)),h=o.__importDefault(t(115)),l=t(22),g=t(46);class u{constructor(t){this._atlas=new Map,this._width=256,this._height=256,this.tex=new n.Texture2d(t),this.tex.set_wrapping(t.REPEAT,t.REPEAT),this.tex.set_interpolation(t.NEAREST,t.NEAREST),this.tex.set_size([this._width,this._height],t.RGBA),this.tex.set_data([0,0],[this._width,this._height],new Uint8Array(4*this._width*this._height)),this.get_atlas_data([1])}get_atlas_data(t){const e=t.join(\"-\");let s=this._atlas.get(e);if(null==s){const[i,a]=this.make_pattern(t),o=this._atlas.size;this.tex.set_data([0,o],[this._width,1],new Uint8Array(i.map((t=>t+10)))),s=[o/this._height,a],this._atlas.set(e,s)}return s}make_pattern(t){t.length>1&&t.length%2&&(t=t.concat(t));let e=0;for(const s of t)e+=s;const s=[];let i=0;for(let e=0,a=t.length+2;es[h]?-1:0,n=s[h-1],i=s[h]),o[4*t+0]=s[h],o[4*t+1]=_,o[4*t+2]=n,o[4*t+3]=i}return[o,e]}}u.__name__=\"DashAtlas\";const f={miter:0,round:1,bevel:2},c={\"\":0,none:0,\".\":0,round:1,\")\":1,\"(\":1,o:1,\"triangle in\":2,\"<\":2,\"triangle out\":3,\">\":3,square:4,\"[\":4,\"]\":4,\"=\":4,butt:5,\"|\":5};class d extends _.BaseGLGlyph{constructor(t,e){super(t,e),this.glyph=e,this._scale_aspect=0;const s=r.default,i=h.default;this.prog=new n.Program(t),this.prog.set_shaders(s,i),this.index_buffer=new n.IndexBuffer(t),this.vbo_position=new n.VertexBuffer(t),this.vbo_tangents=new n.VertexBuffer(t),this.vbo_segment=new n.VertexBuffer(t),this.vbo_angles=new n.VertexBuffer(t),this.vbo_texcoord=new n.VertexBuffer(t),this.dash_atlas=new u(t)}draw(t,e,s){const i=e.glglyph;if(i.data_changed&&(i._set_data(),i.data_changed=!1),this.visuals_changed&&(this._set_visuals(),this.visuals_changed=!1),i._update_scale(1,1),this._scale_aspect=1,this.prog.set_attribute(\"a_position\",\"vec2\",i.vbo_position),this.prog.set_attribute(\"a_tangents\",\"vec4\",i.vbo_tangents),this.prog.set_attribute(\"a_segment\",\"vec2\",i.vbo_segment),this.prog.set_attribute(\"a_angles\",\"vec2\",i.vbo_angles),this.prog.set_attribute(\"a_texcoord\",\"vec2\",i.vbo_texcoord),this.prog.set_uniform(\"u_length\",\"float\",[i.cumsum]),this.prog.set_texture(\"u_dash_atlas\",this.dash_atlas.tex),this.prog.set_uniform(\"u_pixel_ratio\",\"float\",[s.pixel_ratio]),this.prog.set_uniform(\"u_canvas_size\",\"vec2\",[s.width,s.height]),this.prog.set_uniform(\"u_scale_aspect\",\"vec2\",[1,1]),this.prog.set_uniform(\"u_scale_length\",\"float\",[Math.sqrt(2)]),this.I_triangles=i.I_triangles,this.I_triangles.length<65535)this.index_buffer.set_size(2*this.I_triangles.length),this.index_buffer.set_data(0,new Uint16Array(this.I_triangles)),this.prog.draw(this.gl.TRIANGLES,this.index_buffer);else{t=Array.from(this.I_triangles);const e=this.I_triangles.length,s=64008,a=[];for(let t=0,i=Math.ceil(e/s);t1)for(let e=0;e0||console.log(`Variable ${t} is not an active attribute`));else if(this._unset_variables.has(t)&&this._unset_variables.delete(t),this.activate(),i instanceof r.VertexBuffer){const[r,o]=this.ATYPEINFO[e],l=\"vertexAttribPointer\",_=[r,o,n,s,a];this._attributes.set(t,[i.handle,h,l,_])}else{const s=this.ATYPEMAP[e];this._attributes.set(t,[null,h,s,i])}}_pre_draw(){this.activate();for(const[t,e,i]of this._samplers.values())this.gl.activeTexture(this.gl.TEXTURE0+i),this.gl.bindTexture(t,e);for(const[t,e,i,s]of this._attributes.values())null!=t?(this.gl.bindBuffer(this.gl.ARRAY_BUFFER,t),this.gl.enableVertexAttribArray(e),this.gl[i].apply(this.gl,[e,...s])):(this.gl.bindBuffer(this.gl.ARRAY_BUFFER,null),this.gl.disableVertexAttribArray(e),this.gl[i].apply(this.gl,[e,...s]));this._validated||(this._validated=!0,this._validate())}_validate(){if(this._unset_variables.size&&console.log(`Program has unset variables: ${this._unset_variables}`),this.gl.validateProgram(this.handle),!this.gl.getProgramParameter(this.handle,this.gl.VALIDATE_STATUS))throw console.log(this.gl.getProgramInfoLog(this.handle)),new Error(\"Program validation error\")}draw(t,e){if(!this._linked)throw new Error(\"Cannot draw program if code has not been set\");if(e instanceof r.IndexBuffer){this._pre_draw(),e.activate();const i=e.buffer_size/2,s=this.gl.UNSIGNED_SHORT;this.gl.drawElements(t,i,s,0),e.deactivate()}else{const[i,s]=e;0!=s&&(this._pre_draw(),this.gl.drawArrays(t,i,s))}}}i.Program=n,n.__name__=\"Program\"},\n", + " function _(t,e,s,i,a){i();class r{constructor(t){this.gl=t,this._usage=35048,this.buffer_size=0,this.handle=this.gl.createBuffer()}delete(){this.gl.deleteBuffer(this.handle)}activate(){this.gl.bindBuffer(this._target,this.handle)}deactivate(){this.gl.bindBuffer(this._target,null)}set_size(t){t!=this.buffer_size&&(this.activate(),this.gl.bufferData(this._target,t,this._usage),this.buffer_size=t)}set_data(t,e){this.activate(),this.gl.bufferSubData(this._target,t,e)}}s.Buffer=r,r.__name__=\"Buffer\";class f extends r{constructor(){super(...arguments),this._target=34962}}s.VertexBuffer=f,f.__name__=\"VertexBuffer\";class h extends r{constructor(){super(...arguments),this._target=34963}}s.IndexBuffer=h,h.__name__=\"IndexBuffer\"},\n", + " function _(t,e,i,a,r){a();const s=t(11);class h{constructor(t){this.gl=t,this._target=3553,this._types={Int8Array:5120,Uint8Array:5121,Int16Array:5122,Uint16Array:5123,Int32Array:5124,Uint32Array:5125,Float32Array:5126},this.handle=this.gl.createTexture()}delete(){this.gl.deleteTexture(this.handle)}activate(){this.gl.bindTexture(this._target,this.handle)}deactivate(){this.gl.bindTexture(this._target,0)}_get_alignment(t){const e=[4,8,2,1];for(const i of e)if(t%i==0)return i;s.unreachable()}set_wrapping(t,e){this.activate(),this.gl.texParameterf(this._target,this.gl.TEXTURE_WRAP_S,t),this.gl.texParameterf(this._target,this.gl.TEXTURE_WRAP_T,e)}set_interpolation(t,e){this.activate(),this.gl.texParameterf(this._target,this.gl.TEXTURE_MIN_FILTER,t),this.gl.texParameterf(this._target,this.gl.TEXTURE_MAG_FILTER,e)}set_size([t,e],i){var a,r,s;t==(null===(a=this._shape_format)||void 0===a?void 0:a.width)&&e==(null===(r=this._shape_format)||void 0===r?void 0:r.height)&&i==(null===(s=this._shape_format)||void 0===s?void 0:s.format)||(this._shape_format={width:t,height:e,format:i},this.activate(),this.gl.texImage2D(this._target,0,i,t,e,0,i,this.gl.UNSIGNED_BYTE,null))}set_data(t,[e,i],a){this.activate();const{format:r}=this._shape_format,[s,h]=t,l=this._types[a.constructor.name];if(null==l)throw new Error(`Type ${a.constructor.name} not allowed for texture`);const _=this._get_alignment(e);4!=_&&this.gl.pixelStorei(this.gl.UNPACK_ALIGNMENT,_),this.gl.texSubImage2D(this._target,0,s,h,e,i,r,l,a),4!=_&&this.gl.pixelStorei(this.gl.UNPACK_ALIGNMENT,4)}}i.Texture2d=h,h.__name__=\"Texture2d\"},\n", + " function _(e,t,s,i,h){i();class a{constructor(e,t){this.gl=e,this.glyph=t,this.nvertices=0,this.size_changed=!1,this.data_changed=!1,this.visuals_changed=!1}set_data_changed(){const{data_size:e}=this.glyph;e!=this.nvertices&&(this.nvertices=e,this.size_changed=!0),this.data_changed=!0}set_visuals_changed(){this.visuals_changed=!0}render(e,t,s){if(0==t.length)return!0;const{width:i,height:h}=this.glyph.renderer.plot_view.canvas_view.webgl.canvas,a={pixel_ratio:this.glyph.renderer.plot_view.canvas_view.pixel_ratio,width:i,height:h};return this.draw(t,s,a),!0}}s.BaseGLGlyph=a,a.__name__=\"BaseGLGlyph\"},\n", + " function _(n,e,t,a,i){a();t.default=\"\\nprecision mediump float;\\n\\nconst float PI = 3.14159265358979323846264;\\nconst float THETA = 15.0 * 3.14159265358979323846264/180.0;\\n\\nuniform float u_pixel_ratio;\\nuniform vec2 u_canvas_size, u_offset;\\nuniform vec2 u_scale_aspect;\\nuniform float u_scale_length;\\n\\nuniform vec4 u_color;\\nuniform float u_antialias;\\nuniform float u_length;\\nuniform float u_linewidth;\\nuniform float u_dash_index;\\nuniform float u_closed;\\n\\nattribute vec2 a_position;\\nattribute vec4 a_tangents;\\nattribute vec2 a_segment;\\nattribute vec2 a_angles;\\nattribute vec2 a_texcoord;\\n\\nvarying vec4 v_color;\\nvarying vec2 v_segment;\\nvarying vec2 v_angles;\\nvarying vec2 v_texcoord;\\nvarying vec2 v_miter;\\nvarying float v_length;\\nvarying float v_linewidth;\\n\\nfloat cross(in vec2 v1, in vec2 v2)\\n{\\n return v1.x*v2.y - v1.y*v2.x;\\n}\\n\\nfloat signed_distance(in vec2 v1, in vec2 v2, in vec2 v3)\\n{\\n return cross(v2-v1,v1-v3) / length(v2-v1);\\n}\\n\\nvoid rotate( in vec2 v, in float alpha, out vec2 result )\\n{\\n float c = cos(alpha);\\n float s = sin(alpha);\\n result = vec2( c*v.x - s*v.y,\\n s*v.x + c*v.y );\\n}\\n\\nvoid main()\\n{\\n bool closed = (u_closed > 0.0);\\n\\n // Attributes and uniforms to varyings\\n v_color = u_color;\\n v_linewidth = u_linewidth;\\n v_segment = a_segment * u_scale_length;\\n v_length = u_length * u_scale_length;\\n\\n // Scale to map to pixel coordinates. The original algorithm from the paper\\n // assumed isotropic scale. We obviously do not have this.\\n vec2 abs_scale_aspect = abs(u_scale_aspect);\\n vec2 abs_scale = u_scale_length * abs_scale_aspect;\\n\\n // Correct angles for aspect ratio\\n vec2 av;\\n av = vec2(1.0, tan(a_angles.x)) / abs_scale_aspect;\\n v_angles.x = atan(av.y, av.x);\\n av = vec2(1.0, tan(a_angles.y)) / abs_scale_aspect;\\n v_angles.y = atan(av.y, av.x);\\n\\n // Thickness below 1 pixel are represented using a 1 pixel thickness\\n // and a modified alpha\\n v_color.a = min(v_linewidth, v_color.a);\\n v_linewidth = max(v_linewidth, 1.0);\\n\\n // If color is fully transparent we just will discard the fragment anyway\\n if( v_color.a <= 0.0 ) {\\n gl_Position = vec4(0.0,0.0,0.0,1.0);\\n return;\\n }\\n\\n // This is the actual half width of the line\\n float w = ceil(u_antialias+v_linewidth)/2.0;\\n\\n vec2 position = a_position;\\n\\n vec2 t1 = normalize(a_tangents.xy * abs_scale_aspect); // note the scaling for aspect ratio here\\n vec2 t2 = normalize(a_tangents.zw * abs_scale_aspect);\\n float u = a_texcoord.x;\\n float v = a_texcoord.y;\\n vec2 o1 = vec2( +t1.y, -t1.x);\\n vec2 o2 = vec2( +t2.y, -t2.x);\\n\\n // This is a join\\n // ----------------------------------------------------------------\\n if( t1 != t2 ) {\\n float angle = atan (t1.x*t2.y-t1.y*t2.x, t1.x*t2.x+t1.y*t2.y); // Angle needs recalculation for some reason\\n vec2 t = normalize(t1+t2);\\n vec2 o = vec2( + t.y, - t.x);\\n\\n if ( u_dash_index > 0.0 )\\n {\\n // Broken angle\\n // ----------------------------------------------------------------\\n if( (abs(angle) > THETA) ) {\\n position += v * w * o / cos(angle/2.0);\\n float s = sign(angle);\\n if( angle < 0.0 ) {\\n if( u == +1.0 ) {\\n u = v_segment.y + v * w * tan(angle/2.0);\\n if( v == 1.0 ) {\\n position -= 2.0 * w * t1 / sin(angle);\\n u -= 2.0 * w / sin(angle);\\n }\\n } else {\\n u = v_segment.x - v * w * tan(angle/2.0);\\n if( v == 1.0 ) {\\n position += 2.0 * w * t2 / sin(angle);\\n u += 2.0*w / sin(angle);\\n }\\n }\\n } else {\\n if( u == +1.0 ) {\\n u = v_segment.y + v * w * tan(angle/2.0);\\n if( v == -1.0 ) {\\n position += 2.0 * w * t1 / sin(angle);\\n u += 2.0 * w / sin(angle);\\n }\\n } else {\\n u = v_segment.x - v * w * tan(angle/2.0);\\n if( v == -1.0 ) {\\n position -= 2.0 * w * t2 / sin(angle);\\n u -= 2.0*w / sin(angle);\\n }\\n }\\n }\\n // Continuous angle\\n // ------------------------------------------------------------\\n } else {\\n position += v * w * o / cos(angle/2.0);\\n if( u == +1.0 ) u = v_segment.y;\\n else u = v_segment.x;\\n }\\n }\\n\\n // Solid line\\n // --------------------------------------------------------------------\\n else\\n {\\n position.xy += v * w * o / cos(angle/2.0);\\n if( angle < 0.0 ) {\\n if( u == +1.0 ) {\\n u = v_segment.y + v * w * tan(angle/2.0);\\n } else {\\n u = v_segment.x - v * w * tan(angle/2.0);\\n }\\n } else {\\n if( u == +1.0 ) {\\n u = v_segment.y + v * w * tan(angle/2.0);\\n } else {\\n u = v_segment.x - v * w * tan(angle/2.0);\\n }\\n }\\n }\\n\\n // This is a line start or end (t1 == t2)\\n // ------------------------------------------------------------------------\\n } else {\\n position += v * w * o1;\\n if( u == -1.0 ) {\\n u = v_segment.x - w;\\n position -= w * t1;\\n } else {\\n u = v_segment.y + w;\\n position += w * t2;\\n }\\n }\\n\\n // Miter distance\\n // ------------------------------------------------------------------------\\n vec2 t;\\n vec2 curr = a_position * abs_scale;\\n if( a_texcoord.x < 0.0 ) {\\n vec2 next = curr + t2*(v_segment.y-v_segment.x);\\n\\n rotate( t1, +v_angles.x/2.0, t);\\n v_miter.x = signed_distance(curr, curr+t, position);\\n\\n rotate( t2, +v_angles.y/2.0, t);\\n v_miter.y = signed_distance(next, next+t, position);\\n } else {\\n vec2 prev = curr - t1*(v_segment.y-v_segment.x);\\n\\n rotate( t1, -v_angles.x/2.0,t);\\n v_miter.x = signed_distance(prev, prev+t, position);\\n\\n rotate( t2, -v_angles.y/2.0,t);\\n v_miter.y = signed_distance(curr, curr+t, position);\\n }\\n\\n if (!closed && v_segment.x <= 0.0) {\\n v_miter.x = 1e10;\\n }\\n if (!closed && v_segment.y >= v_length)\\n {\\n v_miter.y = 1e10;\\n }\\n\\n v_texcoord = vec2( u, v*w );\\n\\n // Calculate position in device coordinates. Note that we\\n // already scaled with abs scale above.\\n vec2 normpos = position * sign(u_scale_aspect);\\n normpos += 0.5; // make up for Bokeh's offset\\n normpos /= u_canvas_size / u_pixel_ratio; // in 0..1\\n gl_Position = vec4(normpos*2.0-1.0, 0.0, 1.0);\\n gl_Position.y *= -1.0;\\n}\\n\"},\n", + " function _(n,t,e,s,a){s();e.default=\"\\nprecision mediump float;\\n\\nconst float PI = 3.14159265358979323846264;\\nconst float THETA = 15.0 * 3.14159265358979323846264/180.0;\\n\\nuniform sampler2D u_dash_atlas;\\n\\nuniform vec2 u_linecaps;\\nuniform float u_miter_limit;\\nuniform float u_linejoin;\\nuniform float u_antialias;\\nuniform float u_dash_phase;\\nuniform float u_dash_period;\\nuniform float u_dash_index;\\nuniform vec2 u_dash_caps;\\nuniform float u_closed;\\n\\nvarying vec4 v_color;\\nvarying vec2 v_segment;\\nvarying vec2 v_angles;\\nvarying vec2 v_texcoord;\\nvarying vec2 v_miter;\\nvarying float v_length;\\nvarying float v_linewidth;\\n\\n// Compute distance to cap ----------------------------------------------------\\nfloat cap( int type, float dx, float dy, float t, float linewidth )\\n{\\n float d = 0.0;\\n dx = abs(dx);\\n dy = abs(dy);\\n if (type == 0) discard; // None\\n else if (type == 1) d = sqrt(dx*dx+dy*dy); // Round\\n else if (type == 3) d = (dx+abs(dy)); // Triangle in\\n else if (type == 2) d = max(abs(dy),(t+dx-abs(dy))); // Triangle out\\n else if (type == 4) d = max(dx,dy); // Square\\n else if (type == 5) d = max(dx+t,dy); // Butt\\n return d;\\n}\\n\\n// Compute distance to join -------------------------------------------------\\nfloat join( in int type, in float d, in vec2 segment, in vec2 texcoord, in vec2 miter,\\n in float linewidth )\\n{\\n // texcoord.x is distance from start\\n // texcoord.y is distance from centerline\\n // segment.x and y indicate the limits (as for texcoord.x) for this segment\\n\\n float dx = texcoord.x;\\n\\n // Round join\\n if( type == 1 ) {\\n if (dx < segment.x) {\\n d = max(d,length( texcoord - vec2(segment.x,0.0)));\\n //d = length( texcoord - vec2(segment.x,0.0));\\n } else if (dx > segment.y) {\\n d = max(d,length( texcoord - vec2(segment.y,0.0)));\\n //d = length( texcoord - vec2(segment.y,0.0));\\n }\\n }\\n // Bevel join\\n else if ( type == 2 ) {\\n if (dx < segment.x) {\\n vec2 x = texcoord - vec2(segment.x,0.0);\\n d = max(d, max(abs(x.x), abs(x.y)));\\n\\n } else if (dx > segment.y) {\\n vec2 x = texcoord - vec2(segment.y,0.0);\\n d = max(d, max(abs(x.x), abs(x.y)));\\n }\\n /* Original code for bevel which does not work for us\\n if( (dx < segment.x) || (dx > segment.y) )\\n d = max(d, min(abs(x.x),abs(x.y)));\\n */\\n }\\n\\n return d;\\n}\\n\\nvoid main()\\n{\\n // If color is fully transparent we just discard the fragment\\n if( v_color.a <= 0.0 ) {\\n discard;\\n }\\n\\n // Test if dash pattern is the solid one (0)\\n bool solid = (u_dash_index == 0.0);\\n\\n // Test if path is closed\\n bool closed = (u_closed > 0.0);\\n\\n vec4 color = v_color;\\n float dx = v_texcoord.x;\\n float dy = v_texcoord.y;\\n float t = v_linewidth/2.0-u_antialias;\\n float width = 1.0; //v_linewidth; original code had dashes scale with line width, we do not\\n float d = 0.0;\\n\\n vec2 linecaps = u_linecaps;\\n vec2 dash_caps = u_dash_caps;\\n float line_start = 0.0;\\n float line_stop = v_length;\\n\\n // Apply miter limit; fragments too far into the miter are simply discarded\\n if( (dx < v_segment.x) || (dx > v_segment.y) ) {\\n float into_miter = max(v_segment.x - dx, dx - v_segment.y);\\n if (into_miter > u_miter_limit*v_linewidth/2.0)\\n discard;\\n }\\n\\n // Solid line --------------------------------------------------------------\\n if( solid ) {\\n d = abs(dy);\\n if( (!closed) && (dx < line_start) ) {\\n d = cap( int(u_linecaps.x), abs(dx), abs(dy), t, v_linewidth );\\n }\\n else if( (!closed) && (dx > line_stop) ) {\\n d = cap( int(u_linecaps.y), abs(dx)-line_stop, abs(dy), t, v_linewidth );\\n }\\n else {\\n d = join( int(u_linejoin), abs(dy), v_segment, v_texcoord, v_miter, v_linewidth );\\n }\\n\\n // Dash line --------------------------------------------------------------\\n } else {\\n float segment_start = v_segment.x;\\n float segment_stop = v_segment.y;\\n float segment_center= (segment_start+segment_stop)/2.0;\\n float freq = u_dash_period*width;\\n float u = mod( dx + u_dash_phase*width, freq);\\n vec4 tex = texture2D(u_dash_atlas, vec2(u/freq, u_dash_index)) * 255.0 -10.0; // conversion to int-like\\n float dash_center= tex.x * width;\\n float dash_type = tex.y;\\n float _start = tex.z * width;\\n float _stop = tex.a * width;\\n float dash_start = dx - u + _start;\\n float dash_stop = dx - u + _stop;\\n\\n // Compute extents of the first dash (the one relative to v_segment.x)\\n // Note: this could be computed in the vertex shader\\n if( (dash_stop < segment_start) && (dash_caps.x != 5.0) ) {\\n float u = mod(segment_start + u_dash_phase*width, freq);\\n vec4 tex = texture2D(u_dash_atlas, vec2(u/freq, u_dash_index)) * 255.0 -10.0; // conversion to int-like\\n dash_center= tex.x * width;\\n //dash_type = tex.y;\\n float _start = tex.z * width;\\n float _stop = tex.a * width;\\n dash_start = segment_start - u + _start;\\n dash_stop = segment_start - u + _stop;\\n }\\n\\n // Compute extents of the last dash (the one relatives to v_segment.y)\\n // Note: This could be computed in the vertex shader\\n else if( (dash_start > segment_stop) && (dash_caps.y != 5.0) ) {\\n float u = mod(segment_stop + u_dash_phase*width, freq);\\n vec4 tex = texture2D(u_dash_atlas, vec2(u/freq, u_dash_index)) * 255.0 -10.0; // conversion to int-like\\n dash_center= tex.x * width;\\n //dash_type = tex.y;\\n float _start = tex.z * width;\\n float _stop = tex.a * width;\\n dash_start = segment_stop - u + _start;\\n dash_stop = segment_stop - u + _stop;\\n }\\n\\n // This test if the we are dealing with a discontinuous angle\\n bool discontinuous = ((dx < segment_center) && abs(v_angles.x) > THETA) ||\\n ((dx >= segment_center) && abs(v_angles.y) > THETA);\\n //if( dx < line_start) discontinuous = false;\\n //if( dx > line_stop) discontinuous = false;\\n\\n float d_join = join( int(u_linejoin), abs(dy),\\n v_segment, v_texcoord, v_miter, v_linewidth );\\n\\n // When path is closed, we do not have room for linecaps, so we make room\\n // by shortening the total length\\n if (closed) {\\n line_start += v_linewidth/2.0;\\n line_stop -= v_linewidth/2.0;\\n }\\n\\n // We also need to take antialias area into account\\n //line_start += u_antialias;\\n //line_stop -= u_antialias;\\n\\n // Check is dash stop is before line start\\n if( dash_stop <= line_start ) {\\n discard;\\n }\\n // Check is dash start is beyond line stop\\n if( dash_start >= line_stop ) {\\n discard;\\n }\\n\\n // Check if current dash start is beyond segment stop\\n if( discontinuous ) {\\n // Dash start is beyond segment, we discard\\n if( (dash_start > segment_stop) ) {\\n discard;\\n //gl_FragColor = vec4(1.0,0.0,0.0,.25); return;\\n }\\n\\n // Dash stop is before segment, we discard\\n if( (dash_stop < segment_start) ) {\\n discard; //gl_FragColor = vec4(0.0,1.0,0.0,.25); return;\\n }\\n\\n // Special case for round caps (nicer with this)\\n if( dash_caps.x == 1.0 ) {\\n if( (u > _stop) && (dash_stop > segment_stop ) && (abs(v_angles.y) < PI/2.0)) {\\n discard;\\n }\\n }\\n\\n // Special case for round caps (nicer with this)\\n if( dash_caps.y == 1.0 ) {\\n if( (u < _start) && (dash_start < segment_start ) && (abs(v_angles.x) < PI/2.0)) {\\n discard;\\n }\\n }\\n\\n // Special case for triangle caps (in & out) and square\\n // We make sure the cap stop at crossing frontier\\n if( (dash_caps.x != 1.0) && (dash_caps.x != 5.0) ) {\\n if( (dash_start < segment_start ) && (abs(v_angles.x) < PI/2.0) ) {\\n float a = v_angles.x/2.0;\\n float x = (segment_start-dx)*cos(a) - dy*sin(a);\\n float y = (segment_start-dx)*sin(a) + dy*cos(a);\\n if( x > 0.0 ) discard;\\n // We transform the cap into square to avoid holes\\n dash_caps.x = 4.0;\\n }\\n }\\n\\n // Special case for triangle caps (in & out) and square\\n // We make sure the cap stop at crossing frontier\\n if( (dash_caps.y != 1.0) && (dash_caps.y != 5.0) ) {\\n if( (dash_stop > segment_stop ) && (abs(v_angles.y) < PI/2.0) ) {\\n float a = v_angles.y/2.0;\\n float x = (dx-segment_stop)*cos(a) - dy*sin(a);\\n float y = (dx-segment_stop)*sin(a) + dy*cos(a);\\n if( x > 0.0 ) discard;\\n // We transform the caps into square to avoid holes\\n dash_caps.y = 4.0;\\n }\\n }\\n }\\n\\n // Line cap at start\\n if( (dx < line_start) && (dash_start < line_start) && (dash_stop > line_start) ) {\\n d = cap( int(linecaps.x), dx-line_start, dy, t, v_linewidth);\\n }\\n // Line cap at stop\\n else if( (dx > line_stop) && (dash_stop > line_stop) && (dash_start < line_stop) ) {\\n d = cap( int(linecaps.y), dx-line_stop, dy, t, v_linewidth);\\n }\\n // Dash cap left - dash_type = -1, 0 or 1, but there may be roundoff errors\\n else if( dash_type < -0.5 ) {\\n d = cap( int(dash_caps.y), abs(u-dash_center), dy, t, v_linewidth);\\n if( (dx > line_start) && (dx < line_stop) )\\n d = max(d,d_join);\\n }\\n // Dash cap right\\n else if( dash_type > 0.5 ) {\\n d = cap( int(dash_caps.x), abs(dash_center-u), dy, t, v_linewidth);\\n if( (dx > line_start) && (dx < line_stop) )\\n d = max(d,d_join);\\n }\\n // Dash body (plain)\\n else {// if( dash_type > -0.5 && dash_type < 0.5) {\\n d = abs(dy);\\n }\\n\\n // Line join\\n if( (dx > line_start) && (dx < line_stop)) {\\n if( (dx <= segment_start) && (dash_start <= segment_start)\\n && (dash_stop >= segment_start) ) {\\n d = d_join;\\n // Antialias at outer border\\n float angle = PI/2.+v_angles.x;\\n float f = abs( (segment_start - dx)*cos(angle) - dy*sin(angle));\\n d = max(f,d);\\n }\\n else if( (dx > segment_stop) && (dash_start <= segment_stop)\\n && (dash_stop >= segment_stop) ) {\\n d = d_join;\\n // Antialias at outer border\\n float angle = PI/2.+v_angles.y;\\n float f = abs((dx - segment_stop)*cos(angle) - dy*sin(angle));\\n d = max(f,d);\\n }\\n else if( dx < (segment_start - v_linewidth/2.)) {\\n discard;\\n }\\n else if( dx > (segment_stop + v_linewidth/2.)) {\\n discard;\\n }\\n }\\n else if( dx < (segment_start - v_linewidth/2.)) {\\n discard;\\n }\\n else if( dx > (segment_stop + v_linewidth/2.)) {\\n discard;\\n }\\n }\\n\\n // Distance to border ------------------------------------------------------\\n d = d - t;\\n if( d < 0.0 ) {\\n gl_FragColor = color;\\n } else {\\n d /= u_antialias;\\n gl_FragColor = vec4(color.rgb, exp(-d*d)*color.a);\\n }\\n}\\n\"},\n", + " function _(i,t,s,e,l){e();const a=i(1),n=i(64),_=i(106),o=a.__importStar(i(107)),h=a.__importStar(i(48)),c=i(59);class r extends n.XYGlyphView{_inner_loop(i,t,s,e,l){for(const a of t){const t=s[a],n=e[a];0!=a?isNaN(t+n)?(i.closePath(),l.apply(i),i.beginPath()):i.lineTo(t,n):(i.beginPath(),i.moveTo(t,n))}i.closePath(),l.call(i)}_render(i,t,s){const{sx:e,sy:l}=null!=s?s:this;this.visuals.fill.doit&&(this.visuals.fill.set_value(i),this._inner_loop(i,t,e,l,i.fill)),this.visuals.hatch.doit&&(this.visuals.hatch.set_value(i),this._inner_loop(i,t,e,l,i.fill)),this.visuals.line.doit&&(this.visuals.line.set_value(i),this._inner_loop(i,t,e,l,i.stroke))}draw_legend_for_index(i,t,s){_.generic_area_scalar_legend(this.visuals,i,t)}_hit_point(i){const t=new c.Selection;return o.point_in_poly(i.sx,i.sy,this.sx,this.sy)&&(t.add_to_selected_glyphs(this.model),t.view=this),t}}s.PatchView=r,r.__name__=\"PatchView\";class p extends n.XYGlyph{constructor(i){super(i)}static init_Patch(){this.prototype.default_view=r,this.mixins([h.LineScalar,h.FillScalar,h.HatchScalar])}}s.Patch=p,p.__name__=\"Patch\",p.init_Patch()},\n", + " function _(t,e,s,i,n){i();const a=t(1),r=t(24),h=t(118),_=a.__importStar(t(107)),l=a.__importStar(t(18)),o=t(59);class c extends h.AreaView{_index_data(t){const{min:e,max:s}=Math,{data_size:i}=this;for(let n=0;n=0;e--)t.lineTo(s[e],i[e]);t.closePath(),n.call(t)}_render(t,e,s){const{sx1:i,sx2:n,sy:a}=null!=s?s:this;this.visuals.fill.doit&&(this.visuals.fill.set_value(t),this._inner(t,i,n,a,t.fill)),this.visuals.hatch.doit&&(this.visuals.hatch.set_value(t),this._inner(t,i,n,a,t.fill))}_hit_point(t){const e=this.sy.length,s=new r.ScreenArray(2*e),i=new r.ScreenArray(2*e);for(let t=0,n=e;t({x1:[l.XCoordinateSpec,{field:\"x1\"}],x2:[l.XCoordinateSpec,{field:\"x2\"}],y:[l.YCoordinateSpec,{field:\"y\"}]})))}}s.HArea=d,d.__name__=\"HArea\",d.init_HArea()},\n", + " function _(e,a,_,i,r){i();const s=e(1),n=e(98),t=e(106),c=s.__importStar(e(48));class l extends n.GlyphView{draw_legend_for_index(e,a,_){t.generic_area_scalar_legend(this.visuals,e,a)}}_.AreaView=l,l.__name__=\"AreaView\";class d extends n.Glyph{constructor(e){super(e)}static init_Area(){this.mixins([c.FillScalar,c.HatchScalar])}}_.Area=d,d.__name__=\"Area\",d.init_Area()},\n", + " function _(t,e,s,i,n){i();const a=t(1),r=t(24),h=t(118),_=a.__importStar(t(107)),l=a.__importStar(t(18)),o=t(59);class c extends h.AreaView{_index_data(t){const{min:e,max:s}=Math,{data_size:i}=this;for(let n=0;n=0;s--)t.lineTo(e[s],i[s]);t.closePath(),n.call(t)}_render(t,e,s){const{sx:i,sy1:n,sy2:a}=null!=s?s:this;this.visuals.fill.doit&&(this.visuals.fill.set_value(t),this._inner(t,i,n,a,t.fill)),this.visuals.hatch.doit&&(this.visuals.hatch.set_value(t),this._inner(t,i,n,a,t.fill))}scenterxy(t){return[this.sx[t],(this.sy1[t]+this.sy2[t])/2]}_hit_point(t){const e=this.sx.length,s=new r.ScreenArray(2*e),i=new r.ScreenArray(2*e);for(let t=0,n=e;t({x:[l.XCoordinateSpec,{field:\"x\"}],y1:[l.YCoordinateSpec,{field:\"y1\"}],y2:[l.YCoordinateSpec,{field:\"y2\"}]})))}}s.VArea=d,d.__name__=\"VArea\",d.init_VArea()},\n", + " function _(i,e,s,t,n){t();const c=i(53),o=i(59),r=i(24),a=i(121),u=i(57);class _ extends c.Model{constructor(i){super(i)}static init_CDSView(){this.define((({Array:i,Ref:e})=>({filters:[i(e(a.Filter)),[]],source:[e(u.ColumnarDataSource)]}))),this.internal((({Int:i,Dict:e,Ref:s,Nullable:t})=>({indices:[s(r.Indices)],indices_map:[e(i),{}],masked:[t(s(r.Indices)),null]})))}initialize(){super.initialize(),this.compute_indices()}connect_signals(){super.connect_signals(),this.connect(this.properties.filters.change,(()=>this.compute_indices()));const i=()=>{const i=()=>this.compute_indices();null!=this.source&&(this.connect(this.source.change,i),this.source instanceof u.ColumnarDataSource&&(this.connect(this.source.streaming,i),this.connect(this.source.patching,i)))};let e=null!=this.source;e?i():this.connect(this.properties.source.change,(()=>{e||(i(),e=!0)}))}compute_indices(){var i;const{source:e}=this;if(null==e)return;const s=null!==(i=e.get_length())&&void 0!==i?i:1,t=r.Indices.all_set(s);for(const i of this.filters)t.intersect(i.compute_indices(e));this.indices=t,this._indices=[...t],this.indices_map_to_subset()}indices_map_to_subset(){this.indices_map={};for(let i=0;ithis._indices[i]));return new o.Selection(Object.assign(Object.assign({},i.attributes),{indices:e}))}convert_selection_to_subset(i){const e=i.indices.map((i=>this.indices_map[i]));return new o.Selection(Object.assign(Object.assign({},i.attributes),{indices:e}))}convert_indices_from_subset(i){return i.map((i=>this._indices[i]))}}s.CDSView=_,_.__name__=\"CDSView\",_.init_CDSView()},\n", + " function _(e,t,n,s,c){s();const o=e(53);class r extends o.Model{constructor(e){super(e)}}n.Filter=r,r.__name__=\"Filter\"},\n", + " function _(n,e,t,i,o){i();const s=n(9);async function c(n,e,t){const i=new n(Object.assign(Object.assign({},t),{model:e}));return i.initialize(),await i.lazy_initialize(),i}t.build_view=async function(n,e={parent:null},t=(n=>n.default_view)){const i=await c(t(n),n,e);return i.connect_signals(),i},t.build_views=async function(n,e,t={parent:null},i=(n=>n.default_view)){const o=s.difference([...n.keys()],e);for(const e of o)n.get(e).remove(),n.delete(e);const a=[],f=e.filter((e=>!n.has(e)));for(const e of f){const o=await c(i(e),e,t);n.set(e,o),a.push(o)}for(const n of a)n.connect_signals();return a},t.remove_views=function(n){for(const[e,t]of n)t.remove(),n.delete(e)}},\n", + " function _(e,r,n,t,i){t();const s=e(62),o=e(61),l=e(124),d=e(125),a=e(126),p=e(122),_=e(64),h=e(127),c=e(128),u=e(11);class y extends s.DataRendererView{get glyph_view(){return this.node_view.glyph}async lazy_initialize(){await super.lazy_initialize();const e=this.model;let r=null,n=null;const t=new class extends l.Expression{_v_compute(n){u.assert(null==r);const[t]=r=e.layout_provider.get_edge_coordinates(n);return t}},i=new class extends l.Expression{_v_compute(e){u.assert(null!=r);const[,n]=r;return r=null,n}},s=new class extends l.Expression{_v_compute(r){u.assert(null==n);const[t]=n=e.layout_provider.get_node_coordinates(r);return t}},o=new class extends l.Expression{_v_compute(e){u.assert(null!=n);const[,r]=n;return n=null,r}},{edge_renderer:d,node_renderer:a}=this.model;if(!(d.glyph instanceof h.MultiLine||d.glyph instanceof c.Patches))throw new Error(`${this}.edge_renderer.glyph must be a MultiLine glyph`);if(!(a.glyph instanceof _.XYGlyph))throw new Error(`${this}.node_renderer.glyph must be a XYGlyph glyph`);d.glyph.properties.xs.internal=!0,d.glyph.properties.ys.internal=!0,a.glyph.properties.x.internal=!0,a.glyph.properties.y.internal=!0,d.glyph.xs={expr:t},d.glyph.ys={expr:i},a.glyph.x={expr:s},a.glyph.y={expr:o};const{parent:y}=this;this.edge_view=await p.build_view(d,{parent:y}),this.node_view=await p.build_view(a,{parent:y})}connect_signals(){super.connect_signals(),this.connect(this.model.layout_provider.change,(()=>{this.edge_view.set_data(),this.node_view.set_data(),this.request_render()}))}remove(){this.edge_view.remove(),this.node_view.remove(),super.remove()}_render(){this.edge_view.render(),this.node_view.render()}renderer_view(e){if(e instanceof o.GlyphRenderer){if(e==this.edge_view.model)return this.edge_view;if(e==this.node_view.model)return this.node_view}return super.renderer_view(e)}}n.GraphRendererView=y,y.__name__=\"GraphRendererView\";class g extends s.DataRenderer{constructor(e){super(e)}static init_GraphRenderer(){this.prototype.default_view=y,this.define((({Ref:e})=>({layout_provider:[e(d.LayoutProvider)],node_renderer:[e(o.GlyphRenderer)],edge_renderer:[e(o.GlyphRenderer)],selection_policy:[e(a.GraphHitTestPolicy),()=>new a.NodesOnly],inspection_policy:[e(a.GraphHitTestPolicy),()=>new a.NodesOnly]})))}get_selection_manager(){return this.node_renderer.data_source.selection_manager}}n.GraphRenderer=g,g.__name__=\"GraphRenderer\",g.init_GraphRenderer()},\n", + " function _(e,t,s,n,i){n();const c=e(53);class l extends c.Model{constructor(e){super(e)}initialize(){super.initialize(),this._connected=new Set,this._result=new Map}v_compute(e){this._connected.has(e)||(this.connect(e.change,(()=>this._result.delete(e))),this.connect(e.patching,(()=>this._result.delete(e))),this.connect(e.streaming,(()=>this._result.delete(e))),this._connected.add(e));let t=this._result.get(e);return null==t&&(t=this._v_compute(e),this._result.set(e,t)),t}}s.Expression=l,l.__name__=\"Expression\";class h extends c.Model{constructor(e){super(e)}initialize(){super.initialize(),this._connected=new Set,this._result=new Map}compute(e){this._connected.has(e)||(this.connect(e.change,(()=>this._result.delete(e))),this.connect(e.patching,(()=>this._result.delete(e))),this.connect(e.streaming,(()=>this._result.delete(e))),this._connected.add(e));let t=this._result.get(e);return null==t&&(t=this._compute(e),this._result.set(e,t)),t}}s.ScalarExpression=h,h.__name__=\"ScalarExpression\"},\n", + " function _(o,e,r,t,n){t();const s=o(53);class c extends s.Model{constructor(o){super(o)}}r.LayoutProvider=c,c.__name__=\"LayoutProvider\"},\n", + " function _(e,t,d,n,s){n();const o=e(53),r=e(12),_=e(9),i=e(59);class c extends o.Model{constructor(e){super(e)}_hit_test(e,t,d){if(!t.model.visible)return null;const n=d.glyph.hit_test(e);return null==n?null:d.model.view.convert_selection_from_subset(n)}}d.GraphHitTestPolicy=c,c.__name__=\"GraphHitTestPolicy\";class a extends c{constructor(e){super(e)}hit_test(e,t){return this._hit_test(e,t,t.edge_view)}do_selection(e,t,d,n){if(null==e)return!1;const s=t.edge_renderer.data_source.selected;return s.update(e,d,n),t.edge_renderer.data_source._select.emit(),!s.is_empty()}do_inspection(e,t,d,n,s){if(null==e)return!1;const{edge_renderer:o}=d.model,r=o.get_selection_manager().get_or_create_inspector(d.edge_view.model);return r.update(e,n,s),d.edge_view.model.data_source.setv({inspected:r},{silent:!0}),d.edge_view.model.data_source.inspect.emit([d.edge_view.model,{geometry:t}]),!r.is_empty()}}d.EdgesOnly=a,a.__name__=\"EdgesOnly\";class l extends c{constructor(e){super(e)}hit_test(e,t){return this._hit_test(e,t,t.node_view)}do_selection(e,t,d,n){if(null==e)return!1;const s=t.node_renderer.data_source.selected;return s.update(e,d,n),t.node_renderer.data_source._select.emit(),!s.is_empty()}do_inspection(e,t,d,n,s){if(null==e)return!1;const{node_renderer:o}=d.model,r=o.get_selection_manager().get_or_create_inspector(d.node_view.model);return r.update(e,n,s),d.node_view.model.data_source.setv({inspected:r},{silent:!0}),d.node_view.model.data_source.inspect.emit([d.node_view.model,{geometry:t}]),!r.is_empty()}}d.NodesOnly=l,l.__name__=\"NodesOnly\";class u extends c{constructor(e){super(e)}hit_test(e,t){return this._hit_test(e,t,t.node_view)}get_linked_edges(e,t,d){let n=[];\"selection\"==d?n=e.selected.indices.map((t=>e.data.index[t])):\"inspection\"==d&&(n=e.inspected.indices.map((t=>e.data.index[t])));const s=[];for(let e=0;er.indexOf(e.data.index,t)));return new i.Selection({indices:o})}do_selection(e,t,d,n){if(null==e)return!1;const s=t.edge_renderer.data_source.selected;s.update(e,d,n);const o=t.node_renderer.data_source.selected,r=this.get_linked_nodes(t.node_renderer.data_source,t.edge_renderer.data_source,\"selection\");return o.update(r,d,n),t.edge_renderer.data_source._select.emit(),!s.is_empty()}do_inspection(e,t,d,n,s){if(null==e)return!1;const o=d.edge_view.model.data_source.selection_manager.get_or_create_inspector(d.edge_view.model);o.update(e,n,s),d.edge_view.model.data_source.setv({inspected:o},{silent:!0});const r=d.node_view.model.data_source.selection_manager.get_or_create_inspector(d.node_view.model),_=this.get_linked_nodes(d.node_view.model.data_source,d.edge_view.model.data_source,\"inspection\");return r.update(_,n,s),d.node_view.model.data_source.setv({inspected:r},{silent:!0}),d.edge_view.model.data_source.inspect.emit([d.edge_view.model,{geometry:t}]),!o.is_empty()}}d.EdgesAndLinkedNodes=m,m.__name__=\"EdgesAndLinkedNodes\"},\n", + " function _(t,e,i,n,s){n();const o=t(1),l=t(65),r=t(48),_=o.__importStar(t(107)),c=o.__importStar(t(18)),h=t(12),a=t(13),d=t(98),x=t(106),y=t(59);class g extends d.GlyphView{_project_data(){l.inplace.project_xy(this._xs.array,this._ys.array)}_index_data(t){const{data_size:e}=this;for(let i=0;i0&&o.set(t,i)}return new y.Selection({indices:[...o.keys()],multiline_indices:a.to_object(o)})}get_interpolation_hit(t,e,i){const n=this._xs.get(t),s=this._ys.get(t),o=n[e],l=s[e],r=n[e+1],_=s[e+1];return x.line_interpolation(this.renderer,i,o,l,r,_)}draw_legend_for_index(t,e,i){x.generic_line_vector_legend(this.visuals,t,e,i)}scenterxy(){throw new Error(`${this}.scenterxy() is not implemented`)}}i.MultiLineView=g,g.__name__=\"MultiLineView\";class u extends d.Glyph{constructor(t){super(t)}static init_MultiLine(){this.prototype.default_view=g,this.define((({})=>({xs:[c.XCoordinateSeqSpec,{field:\"xs\"}],ys:[c.YCoordinateSeqSpec,{field:\"ys\"}]}))),this.mixins(r.LineVector)}}i.MultiLine=u,u.__name__=\"MultiLine\",u.init_MultiLine()},\n", + " function _(e,t,s,i,n){i();const r=e(1),o=e(98),a=e(106),_=e(12),c=e(48),l=r.__importStar(e(107)),h=r.__importStar(e(18)),d=e(59),y=e(11),p=e(65);class x extends o.GlyphView{_project_data(){p.inplace.project_xy(this._xs.array,this._ys.array)}_index_data(e){const{data_size:t}=this;for(let s=0;s({xs:[h.XCoordinateSeqSpec,{field:\"xs\"}],ys:[h.YCoordinateSeqSpec,{field:\"ys\"}]}))),this.mixins([c.LineVector,c.FillVector,c.HatchVector])}}s.Patches=f,f.__name__=\"Patches\",f.init_Patches()},\n", + " function _(e,t,n,s,o){s();const r=e(53);class c extends r.Model{do_selection(e,t,n,s){return null!=e&&(t.selected.update(e,n,s),t._select.emit(),!t.selected.is_empty())}}n.SelectionPolicy=c,c.__name__=\"SelectionPolicy\";class l extends c{hit_test(e,t){const n=[];for(const s of t){const t=s.hit_test(e);null!=t&&n.push(t)}if(n.length>0){const e=n[0];for(const t of n)e.update_through_intersection(t);return e}return null}}n.IntersectRenderers=l,l.__name__=\"IntersectRenderers\";class _ extends c{hit_test(e,t){const n=[];for(const s of t){const t=s.hit_test(e);null!=t&&n.push(t)}if(n.length>0){const e=n[0];for(const t of n)e.update_through_union(t);return e}return null}}n.UnionRenderers=_,_.__name__=\"UnionRenderers\"},\n", + " function _(t,n,e,s,o){s();const r=t(1),i=t(57),l=t(8),c=t(13),a=r.__importStar(t(131)),u=t(132),h=t(35);function d(t,n,e){if(l.isArray(t)){const s=t.concat(n);return null!=e&&s.length>e?s.slice(-e):s}if(l.isTypedArray(t)){const s=t.length+n.length;if(null!=e&&s>e){const o=s-e,r=t.length;let i;t.length({data:[t(n),{}]})))}stream(t,n,e){const{data:s}=this;for(const[e,o]of c.entries(t))s[e]=d(s[e],o,n);if(this.setv({data:s},{silent:!0}),this.streaming.emit(),null!=this.document){const s=new h.ColumnsStreamedEvent(this.document,this.ref(),t,n);this.document._notify_change(this,\"data\",null,null,{setter_id:e,hint:s})}}patch(t,n){const{data:e}=this;let s=new Set;for(const[n,o]of c.entries(t))s=u.union(s,m(e[n],o));if(this.setv({data:e},{silent:!0}),this.patching.emit([...s]),null!=this.document){const e=new h.ColumnsPatchedEvent(this.document,this.ref(),t);this.document._notify_change(this,\"data\",null,null,{setter_id:n,hint:e})}}}e.ColumnDataSource=_,_.__name__=\"ColumnDataSource\",_.init_ColumnDataSource()},\n", + " function _(t,n,o,e,c){e(),o.concat=function(t,...n){let o=t.length;for(const t of n)o+=t.length;const e=new t.constructor(o);e.set(t,0);let c=t.length;for(const t of n)e.set(t,c),c+=t.length;return e}},\n", + " function _(n,o,t,e,f){function c(...n){const o=new Set;for(const t of n)for(const n of t)o.add(n);return o}e(),t.union=c,t.intersection=function(n,...o){const t=new Set;n:for(const e of n){for(const n of o)if(!n.has(e))continue n;t.add(e)}return t},t.difference=function(n,...o){const t=new Set(n);for(const n of c(...o))t.delete(n);return t}},\n", + " function _(e,i,t,s,o){s();const n=e(1),a=e(53),l=e(42),r=n.__importStar(e(45)),_=e(48),c=n.__importStar(e(18));class d extends l.View{initialize(){super.initialize(),this.visuals=new r.Visuals(this)}request_render(){this.parent.request_render()}get canvas(){return this.parent.canvas}set_data(e){const i=this;for(const t of this.model){if(!(t instanceof c.VectorSpec||t instanceof c.ScalarSpec))continue;const s=t.uniform(e);i[`${t.attr}`]=s}}}t.ArrowHeadView=d,d.__name__=\"ArrowHeadView\";class h extends a.Model{constructor(e){super(e)}static init_ArrowHead(){this.define((()=>({size:[c.NumberSpec,25]})))}}t.ArrowHead=h,h.__name__=\"ArrowHead\",h.init_ArrowHead();class v extends d{clip(e,i){this.visuals.line.set_vectorize(e,i);const t=this.size.get(i);e.moveTo(.5*t,t),e.lineTo(.5*t,-2),e.lineTo(-.5*t,-2),e.lineTo(-.5*t,t),e.lineTo(0,0),e.lineTo(.5*t,t)}render(e,i){if(this.visuals.line.doit){this.visuals.line.set_vectorize(e,i);const t=this.size.get(i);e.beginPath(),e.moveTo(.5*t,t),e.lineTo(0,0),e.lineTo(-.5*t,t),e.stroke()}}}t.OpenHeadView=v,v.__name__=\"OpenHeadView\";class u extends h{constructor(e){super(e)}static init_OpenHead(){this.prototype.default_view=v,this.mixins(_.LineVector)}}t.OpenHead=u,u.__name__=\"OpenHead\",u.init_OpenHead();class m extends d{clip(e,i){this.visuals.line.set_vectorize(e,i);const t=this.size.get(i);e.moveTo(.5*t,t),e.lineTo(.5*t,-2),e.lineTo(-.5*t,-2),e.lineTo(-.5*t,t),e.lineTo(.5*t,t)}render(e,i){this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(e,i),this._normal(e,i),e.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(e,i),this._normal(e,i),e.stroke())}_normal(e,i){const t=this.size.get(i);e.beginPath(),e.moveTo(.5*t,t),e.lineTo(0,0),e.lineTo(-.5*t,t),e.closePath()}}t.NormalHeadView=m,m.__name__=\"NormalHeadView\";class T extends h{constructor(e){super(e)}static init_NormalHead(){this.prototype.default_view=m,this.mixins([_.LineVector,_.FillVector]),this.override({fill_color:\"black\"})}}t.NormalHead=T,T.__name__=\"NormalHead\",T.init_NormalHead();class p extends d{clip(e,i){this.visuals.line.set_vectorize(e,i);const t=this.size.get(i);e.moveTo(.5*t,t),e.lineTo(.5*t,-2),e.lineTo(-.5*t,-2),e.lineTo(-.5*t,t),e.lineTo(0,.5*t),e.lineTo(.5*t,t)}render(e,i){this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(e,i),this._vee(e,i),e.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(e,i),this._vee(e,i),e.stroke())}_vee(e,i){const t=this.size.get(i);e.beginPath(),e.moveTo(.5*t,t),e.lineTo(0,0),e.lineTo(-.5*t,t),e.lineTo(0,.5*t),e.closePath()}}t.VeeHeadView=p,p.__name__=\"VeeHeadView\";class H extends h{constructor(e){super(e)}static init_VeeHead(){this.prototype.default_view=p,this.mixins([_.LineVector,_.FillVector]),this.override({fill_color:\"black\"})}}t.VeeHead=H,H.__name__=\"VeeHead\",H.init_VeeHead();class V extends d{render(e,i){if(this.visuals.line.doit){this.visuals.line.set_vectorize(e,i);const t=this.size.get(i);e.beginPath(),e.moveTo(.5*t,0),e.lineTo(-.5*t,0),e.stroke()}}clip(e,i){}}t.TeeHeadView=V,V.__name__=\"TeeHeadView\";class f extends h{constructor(e){super(e)}static init_TeeHead(){this.prototype.default_view=V,this.mixins(_.LineVector)}}t.TeeHead=f,f.__name__=\"TeeHead\",f.init_TeeHead()},\n", + " function _(s,e,i,t,l){t();const _=s(1),o=s(135),r=_.__importStar(s(48));class h extends o.UpperLowerView{paint(s){s.beginPath(),s.moveTo(this._lower_sx[0],this._lower_sy[0]);for(let e=0,i=this._lower_sx.length;e=0;e--)s.lineTo(this._upper_sx[e],this._upper_sy[e]);s.closePath(),this.visuals.fill.doit&&(this.visuals.fill.set_value(s),s.fill()),s.beginPath(),s.moveTo(this._lower_sx[0],this._lower_sy[0]);for(let e=0,i=this._lower_sx.length;e({dimension:[n.Dimension,\"height\"],lower:[h,{field:\"lower\"}],upper:[h,{field:\"upper\"}],base:[h,{field:\"base\"}]})))}}i.UpperLower=d,d.__name__=\"UpperLower\",d.init_UpperLower()},\n", + " function _(t,i,o,n,e){n();const s=t(1),l=t(40),a=s.__importStar(t(48)),r=t(20),h=t(99);o.EDGE_TOLERANCE=2.5;class c extends l.AnnotationView{constructor(){super(...arguments),this.bbox=new h.BBox}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.request_render()))}_render(){const{left:t,right:i,top:o,bottom:n}=this.model;if(null==t&&null==i&&null==o&&null==n)return;const{frame:e}=this.plot_view,s=this.coordinates.x_scale,l=this.coordinates.y_scale,a=(t,i,o,n,e)=>{let s;return s=null!=t?this.model.screen?t:\"data\"==i?o.compute(t):n.compute(t):e,s};this.bbox=h.BBox.from_rect({left:a(t,this.model.left_units,s,e.bbox.xview,e.bbox.left),right:a(i,this.model.right_units,s,e.bbox.xview,e.bbox.right),top:a(o,this.model.top_units,l,e.bbox.yview,e.bbox.top),bottom:a(n,this.model.bottom_units,l,e.bbox.yview,e.bbox.bottom)}),this._paint_box()}_paint_box(){const{ctx:t}=this.layer;t.save();const{left:i,top:o,width:n,height:e}=this.bbox;t.beginPath(),t.rect(i,o,n,e),this.visuals.fill.doit&&(this.visuals.fill.set_value(t),t.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_value(t),t.fill()),this.visuals.line.doit&&(this.visuals.line.set_value(t),t.stroke()),t.restore()}interactive_bbox(){const t=this.model.line_width+o.EDGE_TOLERANCE;return this.bbox.grow_by(t)}interactive_hit(t,i){if(null==this.model.in_cursor)return!1;return this.interactive_bbox().contains(t,i)}cursor(t,i){const{left:o,right:n,bottom:e,top:s}=this.bbox;return Math.abs(t-o)<3||Math.abs(t-n)<3?this.model.ew_cursor:Math.abs(i-e)<3||Math.abs(i-s)<3?this.model.ns_cursor:this.bbox.contains(t,i)?this.model.in_cursor:null}}o.BoxAnnotationView=c,c.__name__=\"BoxAnnotationView\";class u extends l.Annotation{constructor(t){super(t)}static init_BoxAnnotation(){this.prototype.default_view=c,this.mixins([a.Line,a.Fill,a.Hatch]),this.define((({Number:t,Nullable:i})=>({top:[i(t),null],top_units:[r.SpatialUnits,\"data\"],bottom:[i(t),null],bottom_units:[r.SpatialUnits,\"data\"],left:[i(t),null],left_units:[r.SpatialUnits,\"data\"],right:[i(t),null],right_units:[r.SpatialUnits,\"data\"],render_mode:[r.RenderMode,\"canvas\"]}))),this.internal((({Boolean:t,String:i,Nullable:o})=>({screen:[t,!1],ew_cursor:[o(i),null],ns_cursor:[o(i),null],in_cursor:[o(i),null]}))),this.override({fill_color:\"#fff9ba\",fill_alpha:.4,line_color:\"#cccccc\",line_alpha:.3})}update({left:t,right:i,top:o,bottom:n}){this.setv({left:t,right:i,top:o,bottom:n,screen:!0})}}o.BoxAnnotation=u,u.__name__=\"BoxAnnotation\",u.init_BoxAnnotation()},\n", + " function _(t,e,i,o,n){o();const a=t(1),r=t(40),s=t(138),l=t(144),_=t(162),c=t(165),h=t(198),u=t(166),p=t(205),m=t(169),g=t(203),d=t(202),f=t(209),w=t(217),b=t(220),v=t(20),x=a.__importStar(t(48)),y=t(9),k=t(221),C=t(222),z=t(225),j=t(140),B=t(11),L=t(122),S=t(99),M=t(8);class T extends r.AnnotationView{get orientation(){return this._orientation}initialize(){super.initialize();const{ticker:t,formatter:e,color_mapper:i}=this.model;this._ticker=\"auto\"!=t?t:(()=>{switch(!0){case i instanceof f.LogColorMapper:return new h.LogTicker;case i instanceof f.ScanningColorMapper:return new h.BinnedTicker({mapper:i});case i instanceof f.CategoricalColorMapper:return new h.CategoricalTicker;default:return new h.BasicTicker}})(),this._formatter=\"auto\"!=e?e:(()=>{switch(!0){case this._ticker instanceof h.LogTicker:return new p.LogTickFormatter;case i instanceof f.CategoricalColorMapper:return new p.CategoricalTickFormatter;default:return new p.BasicTickFormatter}})(),this._major_range=(()=>{if(i instanceof f.CategoricalColorMapper){const{factors:t}=i;return new b.FactorRange({factors:t})}if(i instanceof d.ContinuousColorMapper){const{min:t,max:e}=i.metrics;return new b.Range1d({start:t,end:e})}B.unreachable()})(),this._major_scale=(()=>{if(i instanceof f.LinearColorMapper)return new w.LinearScale;if(i instanceof f.LogColorMapper)return new w.LogScale;if(i instanceof f.ScanningColorMapper){const{binning:t}=i.metrics;return new w.LinearInterpolationScale({binning:t})}if(i instanceof f.CategoricalColorMapper)return new w.CategoricalScale;B.unreachable()})(),this._minor_range=new b.Range1d({start:0,end:1}),this._minor_scale=new w.LinearScale;const o=x.attrs_of(this.model,\"major_label_\",x.Text,!0),n=x.attrs_of(this.model,\"major_tick_\",x.Line,!0),a=x.attrs_of(this.model,\"minor_tick_\",x.Line,!0),r=x.attrs_of(this.model,\"title_\",x.Text),l=i instanceof f.CategoricalColorMapper?_.CategoricalAxis:i instanceof f.LogColorMapper?_.LogAxis:_.LinearAxis;this._axis=new l(Object.assign(Object.assign(Object.assign({ticker:this._ticker,formatter:this._formatter,major_tick_in:this.model.major_tick_in,major_tick_out:this.model.major_tick_out,minor_tick_in:this.model.minor_tick_in,minor_tick_out:this.model.minor_tick_out,major_label_standoff:this.model.label_standoff,major_label_overrides:this.model.major_label_overrides,major_label_policy:this.model.major_label_policy,axis_line_color:null},o),n),a));const{title:c}=this.model;c&&(this._title=new s.Title(Object.assign({text:c,standoff:this.model.title_standoff},r)))}async lazy_initialize(){await super.lazy_initialize();const t=this,e={get parent(){return t.parent},get root(){return t.root},get frame(){return t._frame},get canvas_view(){return t.parent.canvas_view},request_layout(){t.parent.request_layout()}};this._axis_view=await L.build_view(this._axis,{parent:e}),null!=this._title&&(this._title_view=await L.build_view(this._title,{parent:e}))}remove(){var t;null===(t=this._title_view)||void 0===t||t.remove(),this._axis_view.remove(),super.remove()}connect_signals(){super.connect_signals(),this.connect(this._ticker.change,(()=>this.request_render())),this.connect(this._formatter.change,(()=>this.request_render())),this.connect(this.model.color_mapper.metrics_change,(()=>{const t=this._major_range,e=this._major_scale,{color_mapper:i}=this.model;if(i instanceof d.ContinuousColorMapper&&t instanceof b.Range1d){const{min:e,max:o}=i.metrics;t.setv({start:e,end:o})}if(i instanceof f.ScanningColorMapper&&e instanceof w.LinearInterpolationScale){const{binning:t}=i.metrics;e.binning=t}this._set_canvas_image(),this.plot_view.request_layout()}))}_set_canvas_image(){const{orientation:t}=this,e=(()=>{const{palette:e}=this.model.color_mapper;return\"vertical\"==t?y.reversed(e):e})(),[i,o]=\"vertical\"==t?[1,e.length]:[e.length,1],n=this._image=document.createElement(\"canvas\");n.width=i,n.height=o;const a=n.getContext(\"2d\"),r=a.getImageData(0,0,i,o),s=new f.LinearColorMapper({palette:e}).rgba_mapper.v_compute(y.range(0,e.length));r.data.set(s),a.putImageData(r,0,0)}update_layout(){const{location:t,width:e,height:i,padding:o,margin:n}=this.model,[a,r]=(()=>{if(!M.isString(t))return[\"end\",\"start\"];switch(t){case\"top_left\":return[\"start\",\"start\"];case\"top\":case\"top_center\":return[\"start\",\"center\"];case\"top_right\":return[\"start\",\"end\"];case\"bottom_left\":return[\"end\",\"start\"];case\"bottom\":case\"bottom_center\":return[\"end\",\"center\"];case\"bottom_right\":return[\"end\",\"end\"];case\"left\":case\"center_left\":return[\"center\",\"start\"];case\"center\":case\"center_center\":return[\"center\",\"center\"];case\"right\":case\"center_right\":return[\"center\",\"end\"]}})(),s=this._orientation=(()=>{const{orientation:t}=this.model;return\"auto\"==t?null!=this.panel?this.panel.is_horizontal?\"horizontal\":\"vertical\":\"start\"==r||\"end\"==r||\"center\"==r&&\"center\"==a?\"vertical\":\"horizontal\":t})(),_=new C.NodeLayout,c=new C.VStack,h=new C.VStack,u=new C.HStack,p=new C.HStack;_.absolute=!0,c.absolute=!0,h.absolute=!0,u.absolute=!0,p.absolute=!0;const[m,g,d,f]=(()=>\"horizontal\"==s?[this._major_scale,this._minor_scale,this._major_range,this._minor_range]:[this._minor_scale,this._major_scale,this._minor_range,this._major_range])();this._frame=new l.CartesianFrame(m,g,d,f),_.on_resize((t=>this._frame.set_geometry(t)));const w=new z.BorderLayout;this._inner_layout=w,w.absolute=!0,w.center_panel=_,w.top_panel=c,w.bottom_panel=h,w.left_panel=u,w.right_panel=p;const b={left:o,right:o,top:o,bottom:o},v=(()=>{if(null==this.panel){if(M.isString(t))return{left:n,right:n,top:n,bottom:n};{const[e,i]=t;return{left:e,right:n,top:n,bottom:i}}}if(!M.isString(t)){const[e,i]=t;return w.fixup_geometry=(t,o)=>{const n=t,a=this.layout.bbox,{width:r,height:s}=t;if(t=new S.BBox({left:a.left+e,bottom:a.bottom-i,width:r,height:s}),null!=o){const e=t.left-n.left,i=t.top-n.top,{left:a,top:r,width:s,height:l}=o;o=new S.BBox({left:a+e,top:r+i,width:s,height:l})}return[t,o]},{left:e,right:0,top:0,bottom:i}}w.fixup_geometry=(t,e)=>{const i=t;if(\"horizontal\"==s){const{top:e,width:i,height:o}=t;if(\"end\"==r){const{right:n}=this.layout.bbox;t=new S.BBox({right:n,top:e,width:i,height:o})}else if(\"center\"==r){const{hcenter:n}=this.layout.bbox;t=new S.BBox({hcenter:Math.round(n),top:e,width:i,height:o})}}else{const{left:e,width:i,height:o}=t;if(\"end\"==a){const{bottom:n}=this.layout.bbox;t=new S.BBox({left:e,bottom:n,width:i,height:o})}else if(\"center\"==a){const{vcenter:n}=this.layout.bbox;t=new S.BBox({left:e,vcenter:Math.round(n),width:i,height:o})}}if(null!=e){const o=t.left-i.left,n=t.top-i.top,{left:a,top:r,width:s,height:l}=e;e=new S.BBox({left:a+o,top:r+n,width:s,height:l})}return[t,e]}})();let x,y,B,L;if(w.padding=b,null!=this.panel?(x=\"max\",y=void 0,B=void 0,L=void 0):\"auto\"==(\"horizontal\"==s?e:i)?(x=\"fixed\",y=25*this.model.color_mapper.palette.length,B={percent:.3},L={percent:.8}):(x=\"fit\",y=void 0),\"horizontal\"==s){const t=\"auto\"==e?void 0:e,o=\"auto\"==i?25:i;w.set_sizing({width_policy:x,height_policy:\"min\",width:y,min_width:B,max_width:L,halign:r,valign:a,margin:v}),w.center_panel.set_sizing({width_policy:\"auto\"==e?\"fit\":\"fixed\",height_policy:\"fixed\",width:t,height:o})}else{const t=\"auto\"==e?25:e,o=\"auto\"==i?void 0:i;w.set_sizing({width_policy:\"min\",height_policy:x,height:y,min_height:B,max_height:L,halign:r,valign:a,margin:v}),w.center_panel.set_sizing({width_policy:\"fixed\",height_policy:\"auto\"==i?\"fit\":\"fixed\",width:t,height:o})}c.set_sizing({width_policy:\"fit\",height_policy:\"min\"}),h.set_sizing({width_policy:\"fit\",height_policy:\"min\"}),u.set_sizing({width_policy:\"min\",height_policy:\"fit\"}),p.set_sizing({width_policy:\"min\",height_policy:\"fit\"});const{_title_view:T}=this;null!=T&&(\"horizontal\"==s?(T.panel=new j.Panel(\"above\"),T.update_layout(),c.children.push(T.layout)):(T.panel=new j.Panel(\"left\"),T.update_layout(),u.children.push(T.layout)));const{panel:A}=this,O=null!=A&&s==A.orientation?A.side:\"horizontal\"==s?\"below\":\"right\",R=(()=>{switch(O){case\"above\":return c;case\"below\":return h;case\"left\":return u;case\"right\":return p}})(),{_axis_view:F}=this;if(F.panel=new j.Panel(O),F.update_layout(),R.children.push(F.layout),null!=this.panel){const t=new k.Grid([{layout:w,row:0,col:0}]);t.absolute=!0,\"horizontal\"==s?t.set_sizing({width_policy:\"max\",height_policy:\"min\"}):t.set_sizing({width_policy:\"min\",height_policy:\"max\"}),this.layout=t}else this.layout=this._inner_layout;const{visible:I}=this.model;this.layout.sizing.visible=I,this._set_canvas_image()}_render(){var t;const{ctx:e}=this.layer;e.save(),this._paint_bbox(e,this._inner_layout.bbox),this._paint_image(e,this._inner_layout.center_panel.bbox),null===(t=this._title_view)||void 0===t||t.render(),this._axis_view.render(),e.restore()}_paint_bbox(t,e){const{x:i,y:o}=e;let{width:n,height:a}=e;i+n>=this.parent.canvas_view.bbox.width&&(n-=1),o+a>=this.parent.canvas_view.bbox.height&&(a-=1),t.save(),this.visuals.background_fill.doit&&(this.visuals.background_fill.set_value(t),t.fillRect(i,o,n,a)),this.visuals.border_line.doit&&(this.visuals.border_line.set_value(t),t.strokeRect(i,o,n,a)),t.restore()}_paint_image(t,e){const{x:i,y:o,width:n,height:a}=e;t.save(),t.setImageSmoothingEnabled(!1),t.globalAlpha=this.model.scale_alpha,t.drawImage(this._image,i,o,n,a),this.visuals.bar_line.doit&&(this.visuals.bar_line.set_value(t),t.strokeRect(i,o,n,a)),t.restore()}serializable_state(){const t=super.serializable_state(),{children:e=[]}=t,i=a.__rest(t,[\"children\"]);return null!=this._title_view&&e.push(this._title_view.serializable_state()),e.push(this._axis_view.serializable_state()),Object.assign(Object.assign({},i),{children:e})}}i.ColorBarView=T,T.__name__=\"ColorBarView\";class A extends r.Annotation{constructor(t){super(t)}static init_ColorBar(){this.prototype.default_view=T,this.mixins([[\"major_label_\",x.Text],[\"title_\",x.Text],[\"major_tick_\",x.Line],[\"minor_tick_\",x.Line],[\"border_\",x.Line],[\"bar_\",x.Line],[\"background_\",x.Fill]]),this.define((({Alpha:t,Number:e,String:i,Tuple:o,Dict:n,Or:a,Ref:r,Auto:s,Nullable:l})=>({location:[a(v.Anchor,o(e,e)),\"top_right\"],orientation:[a(v.Orientation,s),\"auto\"],title:[l(i),null],title_standoff:[e,2],width:[a(e,s),\"auto\"],height:[a(e,s),\"auto\"],scale_alpha:[t,1],ticker:[a(r(c.Ticker),s),\"auto\"],formatter:[a(r(u.TickFormatter),s),\"auto\"],major_label_overrides:[n(i),{}],major_label_policy:[r(m.LabelingPolicy),()=>new m.NoOverlap],color_mapper:[r(g.ColorMapper)],label_standoff:[e,5],margin:[e,30],padding:[e,10],major_tick_in:[e,5],major_tick_out:[e,0],minor_tick_in:[e,0],minor_tick_out:[e,0]}))),this.override({background_fill_color:\"#ffffff\",background_fill_alpha:.95,bar_line_color:null,border_line_color:null,major_label_text_font_size:\"11px\",major_tick_line_color:\"#ffffff\",minor_tick_line_color:null,title_text_font_size:\"13px\",title_text_font_style:\"italic\"})}}i.ColorBar=A,A.__name__=\"ColorBar\",A.init_ColorBar()},\n", + " function _(t,e,i,s,l){s();const o=t(1),a=t(139),n=t(20),r=t(143),c=o.__importStar(t(48));class h extends a.TextAnnotationView{_get_location(){const t=this.model.offset,e=this.model.standoff/2;let i,s;const{bbox:l}=this.layout;switch(this.panel.side){case\"above\":case\"below\":switch(this.model.vertical_align){case\"top\":s=l.top+e;break;case\"middle\":s=l.vcenter;break;case\"bottom\":s=l.bottom-e}switch(this.model.align){case\"left\":i=l.left+t;break;case\"center\":i=l.hcenter;break;case\"right\":i=l.right-t}break;case\"left\":switch(this.model.vertical_align){case\"top\":i=l.left+e;break;case\"middle\":i=l.hcenter;break;case\"bottom\":i=l.right-e}switch(this.model.align){case\"left\":s=l.bottom-t;break;case\"center\":s=l.vcenter;break;case\"right\":s=l.top+t}break;case\"right\":switch(this.model.vertical_align){case\"top\":i=l.right-e;break;case\"middle\":i=l.hcenter;break;case\"bottom\":i=l.left+e}switch(this.model.align){case\"left\":s=l.top+t;break;case\"center\":s=l.vcenter;break;case\"right\":s=l.bottom-t}}return[i,s]}_render(){const{text:t}=this.model;if(null==t||0==t.length)return;this.model.text_baseline=this.model.vertical_align,this.model.text_align=this.model.align;const[e,i]=this._get_location(),s=this.panel.get_label_angle_heuristic(\"parallel\");(\"canvas\"==this.model.render_mode?this._canvas_text.bind(this):this._css_text.bind(this))(this.layer.ctx,t,e,i,s)}_get_size(){const{text:t}=this.model;if(null==t||0==t.length)return{width:0,height:0};{const{ctx:e}=this.layer;this.visuals.text.set_value(e);const{width:i}=this.layer.ctx.measureText(t),{height:s}=r.font_metrics(e.font);return{width:i,height:2+s*this.model.text_line_height+this.model.standoff}}}}i.TitleView=h,h.__name__=\"TitleView\";class _ extends a.TextAnnotation{constructor(t){super(t)}static init_Title(){this.prototype.default_view=h,this.mixins([c.Text,[\"border_\",c.Line],[\"background_\",c.Fill]]),this.define((({Number:t,String:e})=>({text:[e,\"\"],vertical_align:[n.VerticalAlign,\"bottom\"],align:[n.TextAlign,\"left\"],offset:[t,0],standoff:[t,10]}))),this.prototype._props.text_align.options.internal=!0,this.prototype._props.text_baseline.options.internal=!0,this.override({text_font_size:\"13px\",text_font_style:\"bold\",text_line_height:1,background_fill_color:null,border_line_color:null})}}i.Title=_,_.__name__=\"Title\",_.init_Title()},\n", + " function _(e,t,s,i,n){i();const l=e(40),a=e(43),o=e(20),r=e(140),d=e(143),c=e(11);class _ extends l.AnnotationView{update_layout(){const{panel:e}=this;this.layout=null!=e?new r.SideLayout(e,(()=>this.get_size()),!0):void 0}initialize(){super.initialize(),\"css\"==this.model.render_mode&&(this.el=a.div(),this.plot_view.canvas_view.add_overlay(this.el))}remove(){null!=this.el&&a.remove(this.el),super.remove()}connect_signals(){super.connect_signals(),\"css\"==this.model.render_mode?this.connect(this.model.change,(()=>this.render())):this.connect(this.model.change,(()=>this.request_render()))}render(){this.model.visible||\"css\"!=this.model.render_mode||a.undisplay(this.el),super.render()}_calculate_text_dimensions(e,t){const{width:s}=e.measureText(t),{height:i}=d.font_metrics(this.visuals.text.font_value());return[s,i]}_calculate_bounding_box_dimensions(e,t){const[s,i]=this._calculate_text_dimensions(e,t);let n,l;switch(e.textAlign){case\"left\":n=0;break;case\"center\":n=-s/2;break;case\"right\":n=-s;break;default:c.unreachable()}switch(e.textBaseline){case\"top\":l=0;break;case\"middle\":l=-.5*i;break;case\"bottom\":l=-1*i;break;case\"alphabetic\":l=-.8*i;break;case\"hanging\":l=-.17*i;break;case\"ideographic\":l=-.83*i;break;default:c.unreachable()}return[n,l,s,i]}_canvas_text(e,t,s,i,n){this.visuals.text.set_value(e);const l=this._calculate_bounding_box_dimensions(e,t);e.save(),e.beginPath(),e.translate(s,i),n&&e.rotate(n),e.rect(l[0],l[1],l[2],l[3]),this.visuals.background_fill.doit&&(this.visuals.background_fill.set_value(e),e.fill()),this.visuals.border_line.doit&&(this.visuals.border_line.set_value(e),e.stroke()),this.visuals.text.doit&&(this.visuals.text.set_value(e),e.fillText(t,0,0)),e.restore()}_css_text(e,t,s,i,n){const{el:l}=this;c.assert(null!=l),a.undisplay(l),this.visuals.text.set_value(e);const[o,r]=this._calculate_bounding_box_dimensions(e,t);l.style.position=\"absolute\",l.style.left=`${s+o}px`,l.style.top=`${i+r}px`,l.style.color=e.fillStyle,l.style.font=e.font,l.style.lineHeight=\"normal\",n&&(l.style.transform=`rotate(${n}rad)`),this.visuals.background_fill.doit&&(this.visuals.background_fill.set_value(e),l.style.backgroundColor=e.fillStyle),this.visuals.border_line.doit&&(this.visuals.border_line.set_value(e),l.style.borderStyle=e.lineDash.length<2?\"solid\":\"dashed\",l.style.borderWidth=`${e.lineWidth}px`,l.style.borderColor=e.strokeStyle),l.textContent=t,a.display(l)}}s.TextAnnotationView=_,_.__name__=\"TextAnnotationView\";class u extends l.Annotation{constructor(e){super(e)}static init_TextAnnotation(){this.define((()=>({render_mode:[o.RenderMode,\"canvas\"]})))}}s.TextAnnotation=u,u.__name__=\"TextAnnotation\",u.init_TextAnnotation()},\n", + " function _(t,e,i,l,r){l();const a=t(141),o=t(142),n=t(8),h=Math.PI/2,s={above:{parallel:0,normal:-h,horizontal:0,vertical:-h},below:{parallel:0,normal:h,horizontal:0,vertical:h},left:{parallel:-h,normal:0,horizontal:0,vertical:-h},right:{parallel:h,normal:0,horizontal:0,vertical:h}},c={above:{parallel:\"bottom\",normal:\"center\",horizontal:\"bottom\",vertical:\"center\"},below:{parallel:\"top\",normal:\"center\",horizontal:\"top\",vertical:\"center\"},left:{parallel:\"bottom\",normal:\"center\",horizontal:\"center\",vertical:\"bottom\"},right:{parallel:\"bottom\",normal:\"center\",horizontal:\"center\",vertical:\"bottom\"}},g={above:{parallel:\"center\",normal:\"left\",horizontal:\"center\",vertical:\"left\"},below:{parallel:\"center\",normal:\"left\",horizontal:\"center\",vertical:\"left\"},left:{parallel:\"center\",normal:\"right\",horizontal:\"right\",vertical:\"center\"},right:{parallel:\"center\",normal:\"left\",horizontal:\"left\",vertical:\"center\"}},_={above:\"right\",below:\"left\",left:\"right\",right:\"left\"},b={above:\"left\",below:\"right\",left:\"right\",right:\"left\"};class z{constructor(t){this.side=t}get dimension(){return\"above\"==this.side||\"below\"==this.side?0:1}get normals(){switch(this.side){case\"above\":return[0,-1];case\"below\":return[0,1];case\"left\":return[-1,0];case\"right\":return[1,0]}}get orientation(){return this.is_horizontal?\"horizontal\":\"vertical\"}get is_horizontal(){return 0==this.dimension}get is_vertical(){return 1==this.dimension}get_label_text_heuristics(t){const{side:e}=this;return n.isString(t)?{vertical_align:c[e][t],align:g[e][t]}:{vertical_align:\"center\",align:(t<0?_:b)[e]}}get_label_angle_heuristic(t){return n.isString(t)?s[this.side][t]:-t}}i.Panel=z,z.__name__=\"Panel\";class m extends o.ContentLayoutable{constructor(t,e,i=!1){super(),this.panel=t,this.get_size=e,this.rotate=i,this.panel.is_horizontal?this.set_sizing({width_policy:\"max\",height_policy:\"fixed\"}):this.set_sizing({width_policy:\"fixed\",height_policy:\"max\"})}_content_size(){const{width:t,height:e}=this.get_size();return!this.rotate||this.panel.is_horizontal?new a.Sizeable({width:t,height:e}):new a.Sizeable({width:e,height:t})}has_size_changed(){const{width:t,height:e}=this._content_size();return this.panel.is_horizontal?this.bbox.height!=e:this.bbox.width!=t}}i.SideLayout=m,m.__name__=\"SideLayout\"},\n", + " function _(h,t,i,e,w){e();const n=h(21),{min:d,max:s}=Math;class g{constructor(h={}){this.width=null!=h.width?h.width:0,this.height=null!=h.height?h.height:0}bounded_to({width:h,height:t}){return new g({width:this.width==1/0&&null!=h?h:this.width,height:this.height==1/0&&null!=t?t:this.height})}expanded_to({width:h,height:t}){return new g({width:h!=1/0?s(this.width,h):this.width,height:t!=1/0?s(this.height,t):this.height})}expand_to({width:h,height:t}){this.width=s(this.width,h),this.height=s(this.height,t)}narrowed_to({width:h,height:t}){return new g({width:d(this.width,h),height:d(this.height,t)})}narrow_to({width:h,height:t}){this.width=d(this.width,h),this.height=d(this.height,t)}grow_by({left:h,right:t,top:i,bottom:e}){const w=this.width+h+t,n=this.height+i+e;return new g({width:w,height:n})}shrink_by({left:h,right:t,top:i,bottom:e}){const w=s(this.width-h-t,0),n=s(this.height-i-e,0);return new g({width:w,height:n})}map(h,t){return new g({width:h(this.width),height:(null!=t?t:h)(this.height)})}}i.Sizeable=g,g.__name__=\"Sizeable\",i.SizingPolicy=n.Enum(\"fixed\",\"fit\",\"min\",\"max\")},\n", + " function _(i,t,h,e,n){e();const s=i(141),r=i(99),g=i(8),{min:l,max:a,round:_}=Math;class o{constructor(){this.absolute=!1,this._bbox=new r.BBox,this._inner_bbox=new r.BBox,this._dirty=!1,this._handlers=[]}*[Symbol.iterator](){}get bbox(){return this._bbox}get inner_bbox(){return this._inner_bbox}get sizing(){return this._sizing}set visible(i){this._sizing.visible=i,this._dirty=!0}set_sizing(i){var t,h,e,n,s;const r=null!==(t=i.width_policy)&&void 0!==t?t:\"fit\",g=i.width,l=i.min_width,a=i.max_width,_=null!==(h=i.height_policy)&&void 0!==h?h:\"fit\",o=i.height,d=i.min_height,u=i.max_height,c=i.aspect,w=null!==(e=i.margin)&&void 0!==e?e:{top:0,right:0,bottom:0,left:0},m=!1!==i.visible,x=null!==(n=i.halign)&&void 0!==n?n:\"start\",b=null!==(s=i.valign)&&void 0!==s?s:\"start\";this._sizing={width_policy:r,min_width:l,width:g,max_width:a,height_policy:_,min_height:d,height:o,max_height:u,aspect:c,margin:w,visible:m,halign:x,valign:b,size:{width:g,height:o}},this._init()}_init(){}_set_geometry(i,t){this._bbox=i,this._inner_bbox=t}set_geometry(i,t){const{fixup_geometry:h}=this;null!=h&&([i,t]=h(i,t)),this._set_geometry(i,null!=t?t:i);for(const i of this._handlers)i(this._bbox,this._inner_bbox)}on_resize(i){this._handlers.push(i)}is_width_expanding(){return\"max\"==this.sizing.width_policy}is_height_expanding(){return\"max\"==this.sizing.height_policy}apply_aspect(i,{width:t,height:h}){const{aspect:e}=this.sizing;if(null!=e){const{width_policy:n,height_policy:s}=this.sizing,r=(i,t)=>{const h={max:4,fit:3,min:2,fixed:1};return h[i]>h[t]};if(\"fixed\"!=n&&\"fixed\"!=s)if(n==s){const n=t,s=_(t/e),r=_(h*e),g=h;Math.abs(i.width-n)+Math.abs(i.height-s)<=Math.abs(i.width-r)+Math.abs(i.height-g)?(t=n,h=s):(t=r,h=g)}else r(n,s)?h=_(t/e):t=_(h*e);else\"fixed\"==n?h=_(t/e):\"fixed\"==s&&(t=_(h*e))}return{width:t,height:h}}measure(i){if(!this.sizing.visible)return{width:0,height:0};const t=i=>\"fixed\"==this.sizing.width_policy&&null!=this.sizing.width?this.sizing.width:i,h=i=>\"fixed\"==this.sizing.height_policy&&null!=this.sizing.height?this.sizing.height:i,e=new s.Sizeable(i).shrink_by(this.sizing.margin).map(t,h),n=this._measure(e),r=this.clip_size(n,e),g=t(r.width),l=h(r.height),a=this.apply_aspect(e,{width:g,height:l});return Object.assign(Object.assign({},n),a)}compute(i={}){const t=this.measure({width:null!=i.width&&this.is_width_expanding()?i.width:1/0,height:null!=i.height&&this.is_height_expanding()?i.height:1/0}),{width:h,height:e}=t,n=new r.BBox({left:0,top:0,width:h,height:e});let s;if(null!=t.inner){const{left:i,top:n,right:g,bottom:l}=t.inner;s=new r.BBox({left:i,top:n,right:h-g,bottom:e-l})}this.set_geometry(n,s)}get xview(){return this.bbox.xview}get yview(){return this.bbox.yview}clip_size(i,t){function h(i,t,h,e){return null==h?h=0:g.isNumber(h)||(h=Math.round(h.percent*t)),null==e?e=1/0:g.isNumber(e)||(e=Math.round(e.percent*t)),a(h,l(i,e))}return{width:h(i.width,t.width,this.sizing.min_width,this.sizing.max_width),height:h(i.height,t.height,this.sizing.min_height,this.sizing.max_height)}}has_size_changed(){const{_dirty:i}=this;return this._dirty=!1,i}}h.Layoutable=o,o.__name__=\"Layoutable\";class d extends o{_measure(i){const{width_policy:t,height_policy:h}=this.sizing;return{width:(()=>{const{width:h}=this.sizing;if(i.width==1/0)return null!=h?h:0;switch(t){case\"fixed\":return null!=h?h:0;case\"min\":return null!=h?l(i.width,h):0;case\"fit\":return null!=h?l(i.width,h):i.width;case\"max\":return null!=h?a(i.width,h):i.width}})(),height:(()=>{const{height:t}=this.sizing;if(i.height==1/0)return null!=t?t:0;switch(h){case\"fixed\":return null!=t?t:0;case\"min\":return null!=t?l(i.height,t):0;case\"fit\":return null!=t?l(i.height,t):i.height;case\"max\":return null!=t?a(i.height,t):i.height}})()}}}h.LayoutItem=d,d.__name__=\"LayoutItem\";class u extends o{_measure(i){const t=this._content_size(),h=i.bounded_to(this.sizing.size).bounded_to(t);return{width:(()=>{switch(this.sizing.width_policy){case\"fixed\":return null!=this.sizing.width?this.sizing.width:t.width;case\"min\":return t.width;case\"fit\":return h.width;case\"max\":return Math.max(t.width,h.width)}})(),height:(()=>{switch(this.sizing.height_policy){case\"fixed\":return null!=this.sizing.height?this.sizing.height:t.height;case\"min\":return t.height;case\"fit\":return h.height;case\"max\":return Math.max(t.height,h.height)}})()}}}h.ContentLayoutable=u,u.__name__=\"ContentLayoutable\"},\n", + " function _(t,e,n,r,l){r();const a=t(11),c=(()=>{try{return\"undefined\"!=typeof OffscreenCanvas&&null!=new OffscreenCanvas(0,0).getContext(\"2d\")}catch(t){return!1}})()?(t,e)=>new OffscreenCanvas(t,e):(t,e)=>{const n=document.createElement(\"canvas\");return n.width=t,n.height=e,n},o=(()=>{const t=c(0,0).getContext(\"2d\");return e=>{t.font=e;const n=t.measureText(\"M\"),r=t.measureText(\"x\"),l=t.measureText(\"ÅŚg|\"),c=l.fontBoundingBoxAscent,o=l.fontBoundingBoxDescent;if(null!=c&&null!=o)return{height:c+o,ascent:c,descent:o,cap_height:n.actualBoundingBoxAscent,x_height:r.actualBoundingBoxAscent};const s=l.actualBoundingBoxAscent,u=l.actualBoundingBoxDescent;if(null!=s&&null!=u)return{height:s+u,ascent:s,descent:u,cap_height:n.actualBoundingBoxAscent,x_height:r.actualBoundingBoxAscent};a.unreachable()}})(),s=(()=>{const t=c(0,0).getContext(\"2d\");return(e,n)=>{t.font=n;const r=t.measureText(e),l=r.actualBoundingBoxAscent,c=r.actualBoundingBoxDescent;if(null!=l&&null!=c)return{width:r.width,height:l+c,ascent:l,descent:c};a.unreachable()}})(),u=(()=>{const t=document.createElement(\"canvas\"),e=t.getContext(\"2d\");let n=-1,r=-1;return(l,a=1)=>{e.font=l;const{width:c}=e.measureText(\"M\"),o=c*a,s=Math.ceil(o),u=Math.ceil(2*o),i=Math.ceil(1.5*o);n{let e=0;for(let n=0;n<=i;n++)for(let r=0;r{let e=t.length-4;for(let n=u;n>=i;n--)for(let r=0;r{const t=document.createElement(\"canvas\"),e=t.getContext(\"2d\");let n=-1,r=-1;return(l,a,c=1)=>{e.font=a;const{width:o}=e.measureText(\"M\"),s=o*c,u=Math.ceil(s),i=Math.ceil(2*s),f=Math.ceil(1.5*s);(n{let e=0;for(let n=0;n<=f;n++)for(let r=0;r{let e=t.length-4;for(let n=i;n>=f;n--)for(let r=0;r{try{return o(\"normal 10px sans-serif\"),o}catch(t){return u}})(),h=(()=>{try{return s(\"A\",\"normal 10px sans-serif\"),s}catch(t){return i}})(),g=new Map;function d(t){let e=g.get(t);return null==e&&(e={font:f(t),glyphs:new Map},g.set(t,e)),e.font}n.font_metrics=d,n.glyph_metrics=function(t,e){let n=g.get(e);null==n&&(d(e),n=g.get(e));let r=n.glyphs.get(t);return null==r&&(r=h(t,e),n.glyphs.set(t,r)),r},n.parse_css_font_size=function(t){const e=t.match(/^\\s*(\\d+(\\.\\d+)?)(\\w+)\\s*$/);if(null!=e){const[,t,,n]=e,r=Number(t);if(isFinite(r))return{value:r,unit:n}}return null}},\n", + " function _(e,t,s,_,a){_();const r=e(145),n=e(157),g=e(156),i=e(159),c=e(104),h=e(99),o=e(13),l=e(11);class x{constructor(e,t,s,_,a={},r={}){this.in_x_scale=e,this.in_y_scale=t,this.x_range=s,this.y_range=_,this.extra_x_ranges=a,this.extra_y_ranges=r,this._bbox=new h.BBox,l.assert(null==e.source_range&&null==e.target_range),l.assert(null==t.source_range&&null==t.target_range),this._configure_scales()}get bbox(){return this._bbox}_get_ranges(e,t){return new Map(o.entries(Object.assign(Object.assign({},t),{default:e})))}_get_scales(e,t,s){const _=new Map;for(const[a,g]of t){if(g instanceof c.FactorRange!=e instanceof r.CategoricalScale)throw new Error(`Range ${g.type} is incompatible is Scale ${e.type}`);e instanceof n.LogScale&&g instanceof i.DataRange1d&&(g.scale_hint=\"log\");const t=e.clone();t.setv({source_range:g,target_range:s}),_.set(a,t)}return _}_configure_frame_ranges(){const{bbox:e}=this;this._x_target=new g.Range1d({start:e.left,end:e.right}),this._y_target=new g.Range1d({start:e.bottom,end:e.top})}_configure_scales(){this._configure_frame_ranges(),this._x_ranges=this._get_ranges(this.x_range,this.extra_x_ranges),this._y_ranges=this._get_ranges(this.y_range,this.extra_y_ranges),this._x_scales=this._get_scales(this.in_x_scale,this._x_ranges,this._x_target),this._y_scales=this._get_scales(this.in_y_scale,this._y_ranges,this._y_target)}_update_scales(){this._configure_frame_ranges();for(const[,e]of this._x_scales)e.target_range=this._x_target;for(const[,e]of this._y_scales)e.target_range=this._y_target}set_geometry(e){this._bbox=e,this._update_scales()}get x_target(){return this._x_target}get y_target(){return this._y_target}get x_ranges(){return this._x_ranges}get y_ranges(){return this._y_ranges}get x_scales(){return this._x_scales}get y_scales(){return this._y_scales}get x_scale(){return this._x_scales.get(\"default\")}get y_scale(){return this._y_scales.get(\"default\")}get xscales(){return o.to_object(this.x_scales)}get yscales(){return o.to_object(this.y_scales)}}s.CartesianFrame=x,x.__name__=\"CartesianFrame\"},\n", + " function _(e,t,r,n,_){n();const c=e(146);class s extends c.Scale{constructor(e){super(e)}get s_compute(){const[e,t]=this._linear_compute_state(),r=this.source_range;return n=>e*r.synthetic(n)+t}compute(e){return super._linear_compute(this.source_range.synthetic(e))}v_compute(e){return super._linear_v_compute(this.source_range.v_synthetic(e))}invert(e){return this._linear_invert(e)}v_invert(e){return this._linear_v_invert(e)}}r.CategoricalScale=s,s.__name__=\"CategoricalScale\"},\n", + " function _(t,e,r,n,s){n();const i=t(147),_=t(105),a=t(156),c=t(24);class o extends i.Transform{constructor(t){super(t)}static init_Scale(){this.internal((({Ref:t})=>({source_range:[t(_.Range)],target_range:[t(a.Range1d)]})))}r_compute(t,e){return this.target_range.is_reversed?[this.compute(e),this.compute(t)]:[this.compute(t),this.compute(e)]}r_invert(t,e){return this.target_range.is_reversed?[this.invert(e),this.invert(t)]:[this.invert(t),this.invert(e)]}_linear_compute(t){const[e,r]=this._linear_compute_state();return e*t+r}_linear_v_compute(t){const[e,r]=this._linear_compute_state(),n=new c.ScreenArray(t.length);for(let s=0;s({args:[s(t),{}],func:[r,\"\"],v_func:[r,\"\"]})))}get names(){return o.keys(this.args)}get values(){return o.values(this.args)}_make_transform(t,r){return new Function(...this.names,t,u.use_strict(r))}get scalar_transform(){return this._make_transform(\"x\",this.func)}get vector_transform(){return this._make_transform(\"xs\",this.v_func)}compute(t){return this.scalar_transform(...this.values,t)}v_compute(t){return this.vector_transform(...this.values,t)}}s.CustomJSTransform=m,m.__name__=\"CustomJSTransform\",m.init_CustomJSTransform()},\n", + " function _(n,s,o,r,c){r();const e=n(53);class t extends e.Model{constructor(n){super(n)}}o.Transform=t,t.__name__=\"Transform\"},\n", + " function _(e,t,n,o,s){o();const i=e(151);class r extends i.RangeTransform{constructor(e){super(e)}static init_Dodge(){this.define((({Number:e})=>({value:[e,0]})))}_compute(e){return e+this.value}}n.Dodge=r,r.__name__=\"Dodge\",r.init_Dodge()},\n", + " function _(e,n,t,r,s){r();const a=e(149),i=e(105),o=e(104),c=e(24),f=e(8);class u extends a.Transform{constructor(e){super(e)}static init_RangeTransform(){this.define((({Ref:e,Nullable:n})=>({range:[n(e(i.Range)),null]})))}v_compute(e){let n;if(this.range instanceof o.FactorRange)n=this.range.v_synthetic(e);else{if(!f.isArrayableOf(e,f.isNumber))throw new Error(\"unexpected\");n=e}const t=new(c.infer_type(n))(n.length);for(let e=0;e({x:[s(r,o(e))],y:[s(r,o(e))],data:[a(n(i.ColumnarDataSource)),null],clip:[t,!0]})))}connect_signals(){super.connect_signals(),this.connect(this.change,(()=>this._sorted_dirty=!0))}v_compute(t){const e=new(a.infer_type(t))(t.length);for(let r=0;rs*(e[t]-e[r]))),this._x_sorted=new(a.infer_type(e))(n),this._y_sorted=new(a.infer_type(r))(n);for(let t=0;t({mean:[t,0],width:[t,1],distribution:[o.Distribution,\"uniform\"]})))}v_compute(t){return null!=this.previous_values&&this.previous_values.length==t.length||(this.previous_values=super.v_compute(t)),this.previous_values}_compute(t){switch(this.distribution){case\"uniform\":return t+this.mean+(a.random()-.5)*this.width;case\"normal\":return t+a.rnorm(this.mean,this.width)}}}e.Jitter=h,h.__name__=\"Jitter\",h.init_Jitter()},\n", + " function _(t,s,_,r,e){r();const i=t(9),o=t(152);class n extends o.Interpolator{constructor(t){super(t)}compute(t){if(this.sort(!1),this.clip){if(tthis._x_sorted[this._x_sorted.length-1])return NaN}else{if(tthis._x_sorted[this._x_sorted.length-1])return this._y_sorted[this._y_sorted.length-1]}if(t==this._x_sorted[0])return this._y_sorted[0];const s=i.find_last_index(this._x_sorted,(s=>s({mode:[_.StepMode,\"after\"]})))}compute(t){if(this.sort(!1),this.clip){if(tthis._x_sorted[this._x_sorted.length-1])return NaN}else{if(tthis._x_sorted[this._x_sorted.length-1])return this._y_sorted[this._y_sorted.length-1]}let e;switch(this.mode){case\"after\":e=n.find_last_index(this._x_sorted,(e=>t>=e));break;case\"before\":e=n.find_index(this._x_sorted,(e=>t<=e));break;case\"center\":{const s=n.map(this._x_sorted,(e=>Math.abs(e-t))),r=n.min(s);e=n.find_index(s,(t=>r===t));break}default:throw new Error(`unknown mode: ${this.mode}`)}return-1!=e?this._y_sorted[e]:NaN}}s.StepInterpolator=d,d.__name__=\"StepInterpolator\",d.init_StepInterpolator()},\n", + " function _(t,e,s,n,i){n();const a=t(105);class r extends a.Range{constructor(t){super(t)}static init_Range1d(){this.define((({Number:t,Nullable:e})=>({start:[t,0],end:[t,1],reset_start:[e(t),null,{on_update(t,e){e._reset_start=null!=t?t:e.start}}],reset_end:[e(t),null,{on_update(t,e){e._reset_end=null!=t?t:e.end}}]})))}_set_auto_bounds(){if(\"auto\"==this.bounds){const t=Math.min(this._reset_start,this._reset_end),e=Math.max(this._reset_start,this._reset_end);this.setv({bounds:[t,e]},{silent:!0})}}initialize(){super.initialize(),this._set_auto_bounds()}get min(){return Math.min(this.start,this.end)}get max(){return Math.max(this.start,this.end)}reset(){this._set_auto_bounds();const{_reset_start:t,_reset_end:e}=this;this.start!=t||this.end!=e?this.setv({start:t,end:e}):this.change.emit()}map(t){return new r({start:t(this.start),end:t(this.end)})}widen(t){let{start:e,end:s}=this;return this.is_reversed?(e+=t,s-=t):(e-=t,s+=t),new r({start:e,end:s})}}s.Range1d=r,r.__name__=\"Range1d\",r.init_Range1d()},\n", + " function _(t,e,o,n,s){n();const a=t(158),r=t(24);class c extends a.ContinuousScale{constructor(t){super(t)}get s_compute(){const[t,e,o,n]=this._compute_state();return s=>{if(0==o)return 0;{const a=(Math.log(s)-n)/o;return isFinite(a)?a*t+e:NaN}}}compute(t){const[e,o,n,s]=this._compute_state();let a;if(0==n)a=0;else{const r=(Math.log(t)-s)/n;a=isFinite(r)?r*e+o:NaN}return a}v_compute(t){const[e,o,n,s]=this._compute_state(),a=new r.ScreenArray(t.length);if(0==n)for(let e=0;e({start:[i],end:[i],range_padding:[i,.1],range_padding_units:[_.PaddingUnits,\"percent\"],flipped:[t,!1],follow:[n(_.StartEnd),null],follow_interval:[n(i),null],default_span:[i,2],only_visible:[t,!1]}))),this.internal((({Enum:t})=>({scale_hint:[t(\"log\",\"auto\"),\"auto\"]})))}initialize(){super.initialize(),this._initial_start=this.start,this._initial_end=this.end,this._initial_range_padding=this.range_padding,this._initial_range_padding_units=this.range_padding_units,this._initial_follow=this.follow,this._initial_follow_interval=this.follow_interval,this._initial_default_span=this.default_span,this._plot_bounds=new Map}get min(){return Math.min(this.start,this.end)}get max(){return Math.max(this.start,this.end)}computed_renderers(){const{renderers:t,names:i}=this,n=o.concat(this.plots.map((t=>t.data_renderers)));return d.compute_renderers(0==t.length?\"auto\":t,n,i)}_compute_plot_bounds(t,i){let n=r.empty();for(const a of t){const t=i.get(a);null==t||!a.visible&&this.only_visible||(n=r.union(n,t))}return n}adjust_bounds_for_aspect(t,i){const n=r.empty();let a=t.x1-t.x0;a<=0&&(a=1);let e=t.y1-t.y0;e<=0&&(e=1);const s=.5*(t.x1+t.x0),l=.5*(t.y1+t.y0);return al&&(\"start\"==this.follow?e=a+s*l:\"end\"==this.follow&&(a=e-s*l)),[a,e]}update(t,i,n,a){if(this.have_updated_interactively)return;const e=this.computed_renderers();let s=this._compute_plot_bounds(e,t);null!=a&&(s=this.adjust_bounds_for_aspect(s,a)),this._plot_bounds.set(n,s);const[l,_]=this._compute_min_max(this._plot_bounds.values(),i);let[o,h]=this._compute_range(l,_);null!=this._initial_start&&(\"log\"==this.scale_hint?this._initial_start>0&&(o=this._initial_start):o=this._initial_start),null!=this._initial_end&&(\"log\"==this.scale_hint?this._initial_end>0&&(h=this._initial_end):h=this._initial_end);let r=!1;\"auto\"==this.bounds&&(this.setv({bounds:[o,h]},{silent:!0}),r=!0);const[d,u]=[this.start,this.end];if(o!=d||h!=u){const t={};o!=d&&(t.start=o),h!=u&&(t.end=h),this.setv(t),r=!1}r&&this.change.emit()}reset(){this.have_updated_interactively=!1,this.setv({range_padding:this._initial_range_padding,range_padding_units:this._initial_range_padding_units,follow:this._initial_follow,follow_interval:this._initial_follow_interval,default_span:this._initial_default_span},{silent:!0}),this.change.emit()}}n.DataRange1d=u,u.__name__=\"DataRange1d\",u.init_DataRange1d()},\n", + " function _(a,e,n,t,r){t();const s=a(105),i=a(62);class R extends s.Range{constructor(a){super(a)}static init_DataRange(){this.define((({String:a,Array:e,Ref:n})=>({names:[e(a),[]],renderers:[e(n(i.DataRenderer)),[]]})))}}n.DataRange=R,R.__name__=\"DataRange\",R.init_DataRange()},\n", + " function _(n,e,t,r,u){r();const l=n(9);t.compute_renderers=function(n,e,t){if(null==n)return[];let r=\"auto\"==n?e:n;return t.length>0&&(r=r.filter((n=>l.includes(t,n.name)))),r}},\n", + " function _(i,s,x,A,o){A(),o(\"Axis\",i(163).Axis),o(\"CategoricalAxis\",i(170).CategoricalAxis),o(\"ContinuousAxis\",i(173).ContinuousAxis),o(\"DatetimeAxis\",i(174).DatetimeAxis),o(\"LinearAxis\",i(175).LinearAxis),o(\"LogAxis\",i(192).LogAxis),o(\"MercatorAxis\",i(195).MercatorAxis)},\n", + " function _(t,e,i,s,o){s();const n=t(1),a=t(164),l=t(165),r=t(166),_=t(169),h=n.__importStar(t(48)),c=t(20),b=t(24),m=t(140),d=t(9),u=t(8),x=t(167),g=t(104),{abs:f}=Math;class p extends a.GuideRendererView{update_layout(){this.layout=new m.SideLayout(this.panel,(()=>this.get_size()),!0),this.layout.on_resize((()=>this._coordinates=void 0))}get_size(){const{visible:t,fixed_location:e}=this.model;if(t&&null==e&&this.is_renderable){const{extents:t}=this;return{width:0,height:Math.round(t.tick+t.tick_label+t.axis_label)}}return{width:0,height:0}}get is_renderable(){const[t,e]=this.ranges;return t.is_valid&&e.is_valid}_render(){var t;if(!this.is_renderable)return;const{tick_coords:e,extents:i}=this,s=this.layer.ctx;s.save(),this._draw_rule(s,i),this._draw_major_ticks(s,i,e),this._draw_minor_ticks(s,i,e),this._draw_major_labels(s,i,e),this._draw_axis_label(s,i,e),null===(t=this._paint)||void 0===t||t.call(this,s,i,e),s.restore()}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.plot_view.request_layout()))}get needs_clip(){return null!=this.model.fixed_location}_draw_rule(t,e){if(!this.visuals.axis_line.doit)return;const[i,s]=this.rule_coords,[o,n]=this.coordinates.map_to_screen(i,s),[a,l]=this.normals,[r,_]=this.offsets;this.visuals.axis_line.set_value(t),t.beginPath();for(let e=0;e0?o+s+3:0}_draw_axis_label(t,e,i){const s=this.model.axis_label;if(!s||null!=this.model.fixed_location)return;const o=new x.TextBox({text:s});o.visuals=this.visuals.axis_label_text,o.angle=this.panel.get_label_angle_heuristic(\"parallel\"),o.base_font_size=this.plot_view.base_font_size;const[n,a]=(()=>{const{bbox:t}=this.layout;switch(this.panel.side){case\"above\":return[t.hcenter,t.bottom];case\"below\":return[t.hcenter,t.top];case\"left\":return[t.right,t.vcenter];case\"right\":return[t.left,t.vcenter]}})(),[l,r]=this.normals,_=e.tick+e.tick_label+this.model.axis_label_standoff,{vertical_align:h,align:c}=this.panel.get_label_text_heuristics(\"parallel\");o.position={sx:n+l*_,sy:a+r*_,x_anchor:c,y_anchor:h},o.align=c,o.paint(t)}_draw_ticks(t,e,i,s,o){if(!o.doit)return;const[n,a]=e,[l,r]=this.coordinates.map_to_screen(n,a),[_,h]=this.normals,[c,b]=this.offsets,[m,d]=[_*(c-i),h*(b-i)],[u,x]=[_*(c+s),h*(b+s)];o.set_value(t),t.beginPath();for(let e=0;et.bbox())),T=(()=>{const[t]=this.ranges;return t.is_reversed?0==this.dimension?(t,e)=>z[t].left-z[e].right:(t,e)=>z[e].top-z[t].bottom:0==this.dimension?(t,e)=>z[e].left-z[t].right:(t,e)=>z[t].top-z[e].bottom})(),{major_label_policy:O}=this.model,A=O.filter(v,z,T),M=[...A.ones()];if(0!=M.length){const t=this.parent.canvas_view.bbox,e=e=>{const i=z[e];if(i.left<0){const t=-i.left,{position:s}=y[e];y[e].position=Object.assign(Object.assign({},s),{sx:s.sx+t})}else if(i.right>t.width){const s=i.right-t.width,{position:o}=y[e];y[e].position=Object.assign(Object.assign({},o),{sx:o.sx-s})}},i=e=>{const i=z[e];if(i.top<0){const t=-i.top,{position:s}=y[e];y[e].position=Object.assign(Object.assign({},s),{sy:s.sy+t})}else if(i.bottom>t.height){const s=i.bottom-t.height,{position:o}=y[e];y[e].position=Object.assign(Object.assign({},o),{sy:o.sy-s})}},s=M[0],o=M[M.length-1];0==this.dimension?(e(s),e(o)):(i(s),i(o))}for(const e of A){y[e].paint(t)}}_tick_extent(){return this.model.major_tick_out}_tick_label_extents(){const t=this.tick_coords.major,e=this.compute_labels(t[this.dimension]),i=this.model.major_label_orientation,s=this.model.major_label_standoff,o=this.visuals.major_label_text;return[this._oriented_labels_extent(e,i,s,o)]}get extents(){const t=this._tick_label_extents();return{tick:this._tick_extent(),tick_labels:t,tick_label:d.sum(t),axis_label:this._axis_label_extent()}}_oriented_labels_extent(t,e,i,s){if(0==t.length)return 0;const o=this.panel.get_label_angle_heuristic(e);t.visuals=s,t.angle=o,t.base_font_size=this.plot_view.base_font_size;const n=t.max_size(),a=0==this.dimension?n.height:n.width;return a>0?i+a+3:0}get normals(){return this.panel.normals}get dimension(){return this.panel.dimension}compute_labels(t){const e=this.model.formatter.format_graphics(t,this),{major_label_overrides:i}=this.model;for(let s=0;sf(a-l)?(t=_(r(o,n),a),s=r(_(o,n),l)):(t=r(o,n),s=_(o,n)),[t,s]}}get rule_coords(){const t=this.dimension,e=(t+1)%2,[i]=this.ranges,[s,o]=this.computed_bounds,n=[new Array(2),new Array(2)];return n[t][0]=Math.max(s,i.min),n[t][1]=Math.min(o,i.max),n[t][0]>n[t][1]&&(n[t][0]=n[t][1]=NaN),n[e][0]=this.loc,n[e][1]=this.loc,n}get tick_coords(){const t=this.dimension,e=(t+1)%2,[i]=this.ranges,[s,o]=this.computed_bounds,n=this.model.ticker.get_ticks(s,o,i,this.loc),a=n.major,l=n.minor,r=[[],[]],_=[[],[]],[h,c]=[i.min,i.max];for(let i=0;ic||(r[t].push(a[i]),r[e].push(this.loc));for(let i=0;ic||(_[t].push(l[i]),_[e].push(this.loc));return{major:r,minor:_}}get loc(){const{fixed_location:t}=this.model;if(null!=t){if(u.isNumber(t))return t;const[,e]=this.ranges;if(e instanceof g.FactorRange)return e.synthetic(t);throw new Error(\"unexpected\")}const[,e]=this.ranges;switch(this.panel.side){case\"left\":case\"below\":return e.start;case\"right\":case\"above\":return e.end}}serializable_state(){return Object.assign(Object.assign({},super.serializable_state()),{bbox:this.layout.bbox.box})}}i.AxisView=p,p.__name__=\"AxisView\";class k extends a.GuideRenderer{constructor(t){super(t)}static init_Axis(){this.prototype.default_view=p,this.mixins([[\"axis_\",h.Line],[\"major_tick_\",h.Line],[\"minor_tick_\",h.Line],[\"major_label_\",h.Text],[\"axis_label_\",h.Text]]),this.define((({Any:t,Int:e,Number:i,String:s,Ref:o,Dict:n,Tuple:a,Or:h,Nullable:b,Auto:m})=>({bounds:[h(a(i,i),m),\"auto\"],ticker:[o(l.Ticker)],formatter:[o(r.TickFormatter)],axis_label:[b(s),\"\"],axis_label_standoff:[e,5],major_label_standoff:[e,5],major_label_orientation:[h(c.TickLabelOrientation,i),\"horizontal\"],major_label_overrides:[n(s),{}],major_label_policy:[o(_.LabelingPolicy),()=>new _.AllLabels],major_tick_in:[i,2],major_tick_out:[i,6],minor_tick_in:[i,0],minor_tick_out:[i,4],fixed_location:[b(h(i,t)),null]}))),this.override({axis_line_color:\"black\",major_tick_line_color:\"black\",minor_tick_line_color:\"black\",major_label_text_font_size:\"11px\",major_label_text_align:\"center\",major_label_text_baseline:\"alphabetic\",axis_label_text_font_size:\"13px\",axis_label_text_font_style:\"italic\"})}}i.Axis=k,k.__name__=\"Axis\",k.init_Axis()},\n", + " function _(e,r,d,i,n){i();const s=e(41);class t extends s.RendererView{}d.GuideRendererView=t,t.__name__=\"GuideRendererView\";class _ extends s.Renderer{constructor(e){super(e)}static init_GuideRenderer(){this.override({level:\"guide\"})}}d.GuideRenderer=_,_.__name__=\"GuideRenderer\",_.init_GuideRenderer()},\n", + " function _(c,e,n,s,o){s();const r=c(53);class t extends r.Model{constructor(c){super(c)}}n.Ticker=t,t.__name__=\"Ticker\"},\n", + " function _(t,o,r,e,c){e();const n=t(53),a=t(167);class m extends n.Model{constructor(t){super(t)}format_graphics(t,o){return this.doFormat(t,o).map((t=>new a.TextBox({text:t})))}compute(t,o){return this.doFormat([t],null!=o?o:{loc:0})[0]}v_compute(t,o){return this.doFormat(t,null!=o?o:{loc:0})}}r.TickFormatter=m,m.__name__=\"TickFormatter\"},\n", + " function _(t,e,s,i,n){i();const h=t(99),o=t(143),a=t(9),r=t(8),c=t(168),_=t(22);s.text_width=(()=>{const t=document.createElement(\"canvas\").getContext(\"2d\");let e=\"\";return(s,i)=>(i!=e&&(e=i,t.font=i),t.measureText(s).width)})();class l{constructor(){this._position={sx:0,sy:0},this.font_size_scale=1,this._base_font_size=13}set base_font_size(t){this._base_font_size=t}get base_font_size(){return this._base_font_size}set position(t){this._position=t}get position(){return this._position}infer_text_height(){return\"ascent_descent\"}bbox(){const{p0:t,p1:e,p2:s,p3:i}=this.rect(),n=Math.min(t.x,e.x,s.x,i.x),o=Math.min(t.y,e.y,s.y,i.y),a=Math.max(t.x,e.x,s.x,i.x),r=Math.max(t.y,e.y,s.y,i.y);return new h.BBox({left:n,right:a,top:o,bottom:r})}size(){const{width:t,height:e}=this._size(),{angle:s}=this;if(s){const i=Math.cos(Math.abs(s)),n=Math.sin(Math.abs(s));return{width:Math.abs(t*i+e*n),height:Math.abs(t*n+e*i)}}return{width:t,height:e}}rect(){const t=this._rect(),{angle:e}=this;if(e){const{sx:s,sy:i}=this.position,n=new c.AffineTransform;return n.translate(s,i),n.rotate(e),n.translate(-s,-i),n.apply_rect(t)}return t}paint_rect(t){const{p0:e,p1:s,p2:i,p3:n}=this.rect();t.save(),t.strokeStyle=\"red\",t.lineWidth=1,t.beginPath();const{round:h}=Math;t.moveTo(h(e.x),h(e.y)),t.lineTo(h(s.x),h(s.y)),t.lineTo(h(i.x),h(i.y)),t.lineTo(h(n.x),h(n.y)),t.closePath(),t.stroke(),t.restore()}paint_bbox(t){const{x:e,y:s,width:i,height:n}=this.bbox();t.save(),t.strokeStyle=\"blue\",t.lineWidth=1,t.beginPath();const{round:h}=Math;t.moveTo(h(e),h(s)),t.lineTo(h(e),h(s+n)),t.lineTo(h(e+i),h(s+n)),t.lineTo(h(e+i),h(s)),t.closePath(),t.stroke(),t.restore()}}s.GraphicsBox=l,l.__name__=\"GraphicsBox\";class x extends l{constructor({text:t}){super(),this.align=\"left\",this.text=t}set visuals(t){const e=t.text_color.get_value(),s=t.text_alpha.get_value(),i=t.text_font_style.get_value();let n=t.text_font_size.get_value();const h=t.text_font.get_value(),{font_size_scale:a,base_font_size:r}=this,c=o.parse_css_font_size(n);if(null!=c){let{value:t,unit:e}=c;t*=a,\"em\"==e&&r&&(t*=r,e=\"px\"),n=`${t}${e}`}const l=`${i} ${n} ${h}`;this.font=l,this.color=_.color2css(e,s),this.line_height=t.text_line_height.get_value()}infer_text_height(){if(this.text.includes(\"\\n\"))return\"ascent_descent\";return function(t){for(const e of new Set(t))if(!(\"0\"<=e&&e<=\"9\"))switch(e){case\",\":case\".\":case\"+\":case\"-\":case\"−\":case\"e\":continue;default:return!1}return!0}(this.text)?\"cap\":\"ascent_descent\"}_text_line(t){var e;const s=null!==(e=this.text_height_metric)&&void 0!==e?e:this.infer_text_height(),i=(()=>{switch(s){case\"x\":case\"x_descent\":return t.x_height;case\"cap\":case\"cap_descent\":return t.cap_height;case\"ascent\":case\"ascent_descent\":return t.ascent}})(),n=(()=>{switch(s){case\"x\":case\"cap\":case\"ascent\":return 0;case\"x_descent\":case\"cap_descent\":case\"ascent_descent\":return t.descent}})();return{height:i+n,ascent:i,descent:n}}get nlines(){return this.text.split(\"\\n\").length}_size(){var t,e;const{font:i}=this,n=o.font_metrics(i),h=(this.line_height-1)*n.height,r=\"\"==this.text,c=this.text.split(\"\\n\"),_=c.length,l=c.map((t=>s.text_width(t,i))),x=this._text_line(n).height*_,u=\"%\"==(null===(t=this.width)||void 0===t?void 0:t.unit)?this.width.value:1,p=\"%\"==(null===(e=this.height)||void 0===e?void 0:e.unit)?this.height.value:1;return{width:a.max(l)*u,height:r?0:(x+h*(_-1))*p,metrics:n}}_computed_position(t,e,s){const{width:i,height:n}=t,{sx:h,sy:o,x_anchor:a=\"left\",y_anchor:c=\"center\"}=this.position;return{x:h-(()=>{if(r.isNumber(a))return a*i;switch(a){case\"left\":return 0;case\"center\":return.5*i;case\"right\":return i}})(),y:o-(()=>{var t;if(r.isNumber(c))return c*n;switch(c){case\"top\":return 0;case\"center\":return.5*n;case\"bottom\":return n;case\"baseline\":if(1!=s)return.5*n;switch(null!==(t=this.text_height_metric)&&void 0!==t?t:this.infer_text_height()){case\"x\":case\"x_descent\":return e.x_height;case\"cap\":case\"cap_descent\":return e.cap_height;case\"ascent\":case\"ascent_descent\":return e.ascent}}})()}}_rect(){const{width:t,height:e,metrics:s}=this._size(),i=this.text.split(\"\\n\").length,{x:n,y:o}=this._computed_position({width:t,height:e},s,i);return new h.BBox({x:n,y:o,width:t,height:e}).rect}paint(t){var e,i;const{font:n}=this,h=o.font_metrics(n),r=(this.line_height-1)*h.height,c=this.text.split(\"\\n\"),_=c.length,l=c.map((t=>s.text_width(t,n))),x=this._text_line(h),u=x.height*_,p=\"%\"==(null===(e=this.width)||void 0===e?void 0:e.unit)?this.width.value:1,f=\"%\"==(null===(i=this.height)||void 0===i?void 0:i.unit)?this.height.value:1,g=a.max(l)*p,d=(u+r*(_-1))*f;t.save(),t.fillStyle=this.color,t.font=this.font,t.textAlign=\"left\",t.textBaseline=\"alphabetic\";const{sx:b,sy:m}=this.position,{align:y}=this,{angle:v}=this;v&&(t.translate(b,m),t.rotate(v),t.translate(-b,-m));let{x:w,y:z}=this._computed_position({width:g,height:d},h,_);if(\"justify\"==y)for(let e=0;e<_;e++){let i=w;const h=c[e].split(\" \"),o=h.length,_=h.map((t=>s.text_width(t,n))),l=(g-a.sum(_))/(o-1);for(let e=0;e{switch(y){case\"left\":return 0;case\"center\":return.5*(g-l[e]);case\"right\":return g-l[e]}})();t.fillStyle=this.color,t.fillText(c[e],s,z+x.ascent),z+=x.height+r}t.restore()}}s.TextBox=x,x.__name__=\"TextBox\";class u extends l{constructor(t,e){super(),this.base=t,this.expo=e}get children(){return[this.base,this.expo]}set base_font_size(t){super.base_font_size=t,this.base.base_font_size=t,this.expo.base_font_size=t}set position(t){this._position=t;const e=this.base.size(),s=this.expo.size(),i=this._shift_scale()*e.height,n=Math.max(e.height,i+s.height);this.base.position={sx:0,x_anchor:\"left\",sy:n,y_anchor:\"bottom\"},this.expo.position={sx:e.width,x_anchor:\"left\",sy:i,y_anchor:\"bottom\"}}get position(){return this._position}set visuals(t){this.expo.font_size_scale=.7,this.base.visuals=t,this.expo.visuals=t}_shift_scale(){if(this.base instanceof x&&1==this.base.nlines){const{x_height:t,cap_height:e}=o.font_metrics(this.base.font);return t/e}return 2/3}infer_text_height(){return this.base.infer_text_height()}_rect(){const t=this.base.bbox(),e=this.expo.bbox(),s=t.union(e),{x:i,y:n}=this._computed_position();return s.translate(i,n).rect}_size(){const t=this.base.size(),e=this.expo.size();return{width:t.width+e.width,height:Math.max(t.height,this._shift_scale()*t.height+e.height)}}paint(t){t.save();const{angle:e}=this;if(e){const{sx:s,sy:i}=this.position;t.translate(s,i),t.rotate(e),t.translate(-s,-i)}const{x:s,y:i}=this._computed_position();t.translate(s,i),this.base.paint(t),this.expo.paint(t),t.restore()}paint_bbox(t){super.paint_bbox(t);const{x:e,y:s}=this._computed_position();t.save(),t.translate(e,s);for(const e of this.children)e.paint_bbox(t);t.restore()}_computed_position(){const{width:t,height:e}=this._size(),{sx:s,sy:i,x_anchor:n=\"left\",y_anchor:h=\"center\"}=this.position;return{x:s-(()=>{if(r.isNumber(n))return n*t;switch(n){case\"left\":return 0;case\"center\":return.5*t;case\"right\":return t}})(),y:i-(()=>{if(r.isNumber(h))return h*e;switch(h){case\"top\":return 0;case\"center\":return.5*e;case\"bottom\":return e;case\"baseline\":return.5*e}})()}}}s.BaseExpo=u,u.__name__=\"BaseExpo\";class p{constructor(t){this.items=t}set base_font_size(t){for(const e of this.items)e.base_font_size=t}get length(){return this.items.length}set visuals(t){for(const e of this.items)e.visuals=t;const e={x:0,cap:1,ascent:2,x_descent:3,cap_descent:4,ascent_descent:5},s=a.max_by(this.items.map((t=>t.infer_text_height())),(t=>e[t]));for(const t of this.items)t.text_height_metric=s}set angle(t){for(const e of this.items)e.angle=t}max_size(){let t=0,e=0;for(const s of this.items){const i=s.size();t=Math.max(t,i.width),e=Math.max(e,i.height)}return{width:t,height:e}}}s.GraphicsBoxes=p,p.__name__=\"GraphicsBoxes\"},\n", + " function _(t,s,r,n,i){n();const{sin:e,cos:a}=Math;class h{constructor(t=1,s=0,r=0,n=1,i=0,e=0){this.a=t,this.b=s,this.c=r,this.d=n,this.e=i,this.f=e}toString(){const{a:t,b:s,c:r,d:n,e:i,f:e}=this;return`matrix(${t}, ${s}, ${r}, ${n}, ${i}, ${e})`}clone(){const{a:t,b:s,c:r,d:n,e:i,f:e}=this;return new h(t,s,r,n,i,e)}get is_identity(){const{a:t,b:s,c:r,d:n,e:i,f:e}=this;return 1==t&&0==s&&0==r&&1==n&&0==i&&0==e}apply_point(t){const[s,r]=this.apply(t.x,t.y);return{x:s,y:r}}apply_rect(t){return{p0:this.apply_point(t.p0),p1:this.apply_point(t.p1),p2:this.apply_point(t.p2),p3:this.apply_point(t.p3)}}apply(t,s){const{a:r,b:n,c:i,d:e,e:a,f:h}=this;return[r*t+i*s+a,n*t+e*s+h]}iv_apply(t,s){const{a:r,b:n,c:i,d:e,e:a,f:h}=this,p=t.length;for(let o=0;o({min_distance:[e,5]})))}filter(e,n,s){const{min_distance:t}=this;let i=null;for(const n of e)null!=i&&s(i,n)({args:[s(e),{}],code:[n,\"\"]})))}get names(){return c.keys(this.args)}get values(){return c.values(this.args)}get func(){const e=o.use_strict(this.code);return new a.GeneratorFunction(\"indices\",\"bboxes\",\"distance\",...this.names,e)}filter(e,n,s){const t=Object.create(null),i=this.func.call(t,e,n,s,...this.values);let l=i.next();if(l.done&&void 0!==l.value){const{value:n}=l;return n instanceof a.Indices?n:void 0===n?e:r.isIterable(n)?a.Indices.from_indices(e.size,n):a.Indices.all_unset(e.size)}{const n=[];do{n.push(l.value),l=i.next()}while(!l.done);return a.Indices.from_indices(e.size,n)}}}s.CustomLabelingPolicy=m,m.__name__=\"CustomLabelingPolicy\",m.init_CustomLabelingPolicy()},\n", + " function _(t,s,e,o,i){o();const a=t(1),r=t(163),l=t(171),_=t(172),n=a.__importStar(t(48)),c=t(20),p=t(167),h=t(8);class m extends r.AxisView{_paint(t,s,e){this._draw_group_separators(t,s,e)}_draw_group_separators(t,s,e){const[o]=this.ranges,[i,a]=this.computed_bounds;if(!o.tops||o.tops.length<2||!this.visuals.separator_line.doit)return;const r=this.dimension,l=(r+1)%2,_=[[],[]];let n=0;for(let t=0;ti&&cnew p.GraphicsBoxes(t.map((t=>h.isString(t)?new p.TextBox({text:t}):t))),_=t=>l(this.model.formatter.doFormat(t,this));if(1==t.levels){const t=_(i.major);r.push([t,a.major,this.model.major_label_orientation,this.visuals.major_label_text])}else if(2==t.levels){const t=_(i.major.map((t=>t[1])));r.push([t,a.major,this.model.major_label_orientation,this.visuals.major_label_text]),r.push([l(i.tops),a.tops,this.model.group_label_orientation,this.visuals.group_text])}else if(3==t.levels){const t=_(i.major.map((t=>t[2]))),s=i.mids.map((t=>t[1]));r.push([t,a.major,this.model.major_label_orientation,this.visuals.major_label_text]),r.push([l(s),a.mids,this.model.subgroup_label_orientation,this.visuals.subgroup_text]),r.push([l(i.tops),a.tops,this.model.group_label_orientation,this.visuals.group_text])}return r}get tick_coords(){const t=this.dimension,s=(t+1)%2,[e]=this.ranges,[o,i]=this.computed_bounds,a=this.model.ticker.get_ticks(o,i,e,this.loc),r={major:[[],[]],mids:[[],[]],tops:[[],[]],minor:[[],[]]};return r.major[t]=a.major,r.major[s]=a.major.map((()=>this.loc)),3==e.levels&&(r.mids[t]=a.mids,r.mids[s]=a.mids.map((()=>this.loc))),e.levels>1&&(r.tops[t]=a.tops,r.tops[s]=a.tops.map((()=>this.loc))),r}}e.CategoricalAxisView=m,m.__name__=\"CategoricalAxisView\";class u extends r.Axis{constructor(t){super(t)}static init_CategoricalAxis(){this.prototype.default_view=m,this.mixins([[\"separator_\",n.Line],[\"group_\",n.Text],[\"subgroup_\",n.Text]]),this.define((({Number:t,Or:s})=>({group_label_orientation:[s(c.TickLabelOrientation,t),\"parallel\"],subgroup_label_orientation:[s(c.TickLabelOrientation,t),\"parallel\"]}))),this.override({ticker:()=>new l.CategoricalTicker,formatter:()=>new _.CategoricalTickFormatter,separator_line_color:\"lightgrey\",separator_line_width:2,group_text_font_style:\"bold\",group_text_font_size:\"11px\",group_text_color:\"grey\",subgroup_text_font_style:\"bold\",subgroup_text_font_size:\"11px\"})}}e.CategoricalAxis=u,u.__name__=\"CategoricalAxis\",u.init_CategoricalAxis()},\n", + " function _(t,c,o,s,e){s();const r=t(165);class i extends r.Ticker{constructor(t){super(t)}get_ticks(t,c,o,s){var e,r;return{major:this._collect(o.factors,o,t,c),minor:[],tops:this._collect(null!==(e=o.tops)&&void 0!==e?e:[],o,t,c),mids:this._collect(null!==(r=o.mids)&&void 0!==r?r:[],o,t,c)}}_collect(t,c,o,s){const e=[];for(const r of t){const t=c.synthetic(r);t>o&&tnew m.DatetimeTicker,formatter:()=>new r.DatetimeTickFormatter})}}i.DatetimeAxis=c,c.__name__=\"DatetimeAxis\",c.init_DatetimeAxis()},\n", + " function _(i,e,s,n,t){n();const r=i(173),a=i(176),o=i(177);class c extends r.ContinuousAxisView{}s.LinearAxisView=c,c.__name__=\"LinearAxisView\";class _ extends r.ContinuousAxis{constructor(i){super(i)}static init_LinearAxis(){this.prototype.default_view=c,this.override({ticker:()=>new o.BasicTicker,formatter:()=>new a.BasicTickFormatter})}}s.LinearAxis=_,_.__name__=\"LinearAxis\",_.init_LinearAxis()},\n", + " function _(i,t,e,n,o){n();const s=i(166),r=i(34);function c(i){let t=\"\";for(const e of i)t+=\"-\"==e?\"−\":e;return t}e.unicode_replace=c;class _ extends s.TickFormatter{constructor(i){super(i),this.last_precision=3}static init_BasicTickFormatter(){this.define((({Boolean:i,Int:t,Auto:e,Or:n})=>({precision:[n(t,e),\"auto\"],use_scientific:[i,!0],power_limit_high:[t,5],power_limit_low:[t,-3]})))}get scientific_limit_low(){return 10**this.power_limit_low}get scientific_limit_high(){return 10**this.power_limit_high}_need_sci(i){if(!this.use_scientific)return!1;const{scientific_limit_high:t}=this,{scientific_limit_low:e}=this,n=i.length<2?0:Math.abs(i[1]-i[0])/1e4;for(const o of i){const i=Math.abs(o);if(!(i<=n)&&(i>=t||i<=e))return!0}return!1}_format_with_precision(i,t,e){return t?i.map((i=>c(i.toExponential(e)))):i.map((i=>c(r.to_fixed(i,e))))}_auto_precision(i,t){const e=new Array(i.length),n=this.last_precision<=15;i:for(let o=this.last_precision;n?o<=15:o>=1;n?o++:o--){if(t){e[0]=i[0].toExponential(o);for(let t=1;t({base:[t,10],mantissas:[i(t),[1,2,5]],min_interval:[t,0],max_interval:[a(t),null]})))}get_min_interval(){return this.min_interval}get_max_interval(){var t;return null!==(t=this.max_interval)&&void 0!==t?t:1/0}initialize(){super.initialize();const t=r.nth(this.mantissas,-1)/this.base,i=r.nth(this.mantissas,0)*this.base;this.extended_mantissas=[t,...this.mantissas,i],this.base_factor=0===this.get_min_interval()?1:this.get_min_interval()}get_interval(t,i,a){const e=i-t,s=this.get_ideal_interval(t,i,a),n=Math.floor(_.log(s/this.base_factor,this.base)),l=this.base**n*this.base_factor,h=this.extended_mantissas,m=h.map((t=>Math.abs(a-e/(t*l)))),v=h[r.argmin(m)]*l;return _.clamp(v,this.get_min_interval(),this.get_max_interval())}}a.AdaptiveTicker=l,l.__name__=\"AdaptiveTicker\",l.init_AdaptiveTicker()},\n", + " function _(t,i,n,s,e){s();const o=t(165),r=t(9);class c extends o.Ticker{constructor(t){super(t)}static init_ContinuousTicker(){this.define((({Int:t})=>({num_minor_ticks:[t,5],desired_num_ticks:[t,6]})))}get_ticks(t,i,n,s){return this.get_ticks_no_defaults(t,i,s,this.desired_num_ticks)}get_ticks_no_defaults(t,i,n,s){const e=this.get_interval(t,i,s),o=Math.floor(t/e),c=Math.ceil(i/e);let _;_=isFinite(o)&&isFinite(c)?r.range(o,c+1):[];const u=_.map((t=>t*e)).filter((n=>t<=n&&n<=i)),a=this.num_minor_ticks,f=[];if(a>0&&u.length>0){const n=e/a,s=r.range(0,a).map((t=>t*n));for(const n of s.slice(1)){const s=u[0]-n;t<=s&&s<=i&&f.push(s)}for(const n of u)for(const e of s){const s=n+e;t<=s&&s<=i&&f.push(s)}}return{major:u,minor:f}}get_ideal_interval(t,i,n){return(i-t)/n}}n.ContinuousTicker=c,c.__name__=\"ContinuousTicker\",c.init_ContinuousTicker()},\n", + " function _(t,s,e,i,n){i();const r=t(1).__importDefault(t(181)),o=t(166),a=t(19),c=t(182),m=t(9),u=t(8);function h(t){return r.default(t,\"%Y %m %d %H %M %S\").split(/\\s+/).map((t=>parseInt(t,10)))}function d(t,s){if(u.isFunction(s))return s(t);{const e=c.sprintf(\"$1%06d\",function(t){return Math.round(t/1e3%1*1e6)}(t));return-1==(s=s.replace(/((^|[^%])(%%)*)%f/,e)).indexOf(\"%\")?s:r.default(t,s)}}const l=[\"microseconds\",\"milliseconds\",\"seconds\",\"minsec\",\"minutes\",\"hourmin\",\"hours\",\"days\",\"months\",\"years\"];class f extends o.TickFormatter{constructor(t){super(t),this.strip_leading_zeros=!0}static init_DatetimeTickFormatter(){this.define((({String:t,Array:s})=>({microseconds:[s(t),[\"%fus\"]],milliseconds:[s(t),[\"%3Nms\",\"%S.%3Ns\"]],seconds:[s(t),[\"%Ss\"]],minsec:[s(t),[\":%M:%S\"]],minutes:[s(t),[\":%M\",\"%Mm\"]],hourmin:[s(t),[\"%H:%M\"]],hours:[s(t),[\"%Hh\",\"%H:%M\"]],days:[s(t),[\"%m/%d\",\"%a%d\"]],months:[s(t),[\"%m/%Y\",\"%b %Y\"]],years:[s(t),[\"%Y\"]]})))}initialize(){super.initialize(),this._update_width_formats()}_update_width_formats(){const t=+r.default(new Date),s=function(s){const e=s.map((s=>d(t,s).length)),i=m.sort_by(m.zip(e,s),(([t])=>t));return m.unzip(i)};this._width_formats={microseconds:s(this.microseconds),milliseconds:s(this.milliseconds),seconds:s(this.seconds),minsec:s(this.minsec),minutes:s(this.minutes),hourmin:s(this.hourmin),hours:s(this.hours),days:s(this.days),months:s(this.months),years:s(this.years)}}_get_resolution_str(t,s){const e=1.1*t;switch(!1){case!(e<.001):return\"microseconds\";case!(e<1):return\"milliseconds\";case!(e<60):return s>=60?\"minsec\":\"seconds\";case!(e<3600):return s>=3600?\"hourmin\":\"minutes\";case!(e<86400):return\"hours\";case!(e<2678400):return\"days\";case!(e<31536e3):return\"months\";default:return\"years\"}}doFormat(t,s){if(0==t.length)return[];const e=Math.abs(t[t.length-1]-t[0])/1e3,i=e/(t.length-1),n=this._get_resolution_str(i,e),[,[r]]=this._width_formats[n],o=[],c=l.indexOf(n),m={};for(const t of l)m[t]=0;m.seconds=5,m.minsec=4,m.minutes=4,m.hourmin=3,m.hours=3;for(const s of t){let t,e;try{e=h(s),t=d(s,r)}catch(t){a.logger.warn(`unable to format tick for timestamp value ${s}`),a.logger.warn(` - ${t}`),o.push(\"ERR\");continue}let i=!1,u=c;for(;0==e[m[l[u]]];){let r;if(u+=1,u==l.length)break;if((\"minsec\"==n||\"hourmin\"==n)&&!i){if(\"minsec\"==n&&0==e[4]&&0!=e[5]||\"hourmin\"==n&&0==e[3]&&0!=e[4]){r=this._width_formats[l[c-1]][1][0],t=d(s,r);break}i=!0}r=this._width_formats[l[u]][1][0],t=d(s,r)}if(this.strip_leading_zeros){let s=t.replace(/^0+/g,\"\");s!=t&&isNaN(parseInt(s))&&(s=`0${s}`),o.push(s)}else o.push(t)}return o}}e.DatetimeTickFormatter=f,f.__name__=\"DatetimeTickFormatter\",f.init_DatetimeTickFormatter()},\n", + " function _(e,t,n,r,o){!function(e){\"object\"==typeof t&&t.exports?t.exports=e():\"function\"==typeof define?define(e):this.tz=e()}((function(){function e(e,t,n){var r,o=t.day[1];do{r=new Date(Date.UTC(n,t.month,Math.abs(o++)))}while(t.day[0]<7&&r.getUTCDay()!=t.day[0]);return(r={clock:t.clock,sort:r.getTime(),rule:t,save:6e4*t.save,offset:e.offset})[r.clock]=r.sort+6e4*t.time,r.posix?r.wallclock=r[r.clock]+(e.offset+t.saved):r.posix=r[r.clock]-(e.offset+t.saved),r}function t(t,n,r){var o,a,u,i,l,s,c,f=t[t.zone],h=[],T=new Date(r).getUTCFullYear(),g=1;for(o=1,a=f.length;o=T-g;--c)for(o=0,a=s.length;o=h[o][n]&&h[o][h[o].clock]>u[h[o].clock]&&(i=h[o])}return i&&((l=/^(.*)\\/(.*)$/.exec(u.format))?i.abbrev=l[i.save?2:1]:i.abbrev=u.format.replace(/%s/,i.rule.letter)),i||u}function n(e,n){return\"UTC\"==e.zone?n:(e.entry=t(e,\"posix\",n),n+e.entry.offset+e.entry.save)}function r(e,n){return\"UTC\"==e.zone?n:(e.entry=r=t(e,\"wallclock\",n),0<(o=n-r.wallclock)&&o9)t+=s*l[c-10];else{if(a=new Date(n(e,t)),c<7)for(;s;)a.setUTCDate(a.getUTCDate()+i),a.getUTCDay()==c&&(s-=i);else 7==c?a.setUTCFullYear(a.getUTCFullYear()+s):8==c?a.setUTCMonth(a.getUTCMonth()+s):a.setUTCDate(a.getUTCDate()+s);null==(t=r(e,a.getTime()))&&(t=r(e,a.getTime()+864e5*i)-864e5*i)}return t}var a={clock:function(){return+new Date},zone:\"UTC\",entry:{abbrev:\"UTC\",offset:0,save:0},UTC:1,z:function(e,t,n,r){var o,a,u=this.entry.offset+this.entry.save,i=Math.abs(u/1e3),l=[],s=3600;for(o=0;o<3;o++)l.push((\"0\"+Math.floor(i/s)).slice(-2)),i%=s,s/=60;return\"^\"!=n||u?(\"^\"==n&&(r=3),3==r?(a=(a=l.join(\":\")).replace(/:00$/,\"\"),\"^\"!=n&&(a=a.replace(/:00$/,\"\"))):r?(a=l.slice(0,r+1).join(\":\"),\"^\"==n&&(a=a.replace(/:00$/,\"\"))):a=l.slice(0,2).join(\"\"),a=(a=(u<0?\"-\":\"+\")+a).replace(/([-+])(0)/,{_:\" $1\",\"-\":\"$1\"}[n]||\"$1$2\")):\"Z\"},\"%\":function(e){return\"%\"},n:function(e){return\"\\n\"},t:function(e){return\"\\t\"},U:function(e){return s(e,0)},W:function(e){return s(e,1)},V:function(e){return c(e)[0]},G:function(e){return c(e)[1]},g:function(e){return c(e)[1]%100},j:function(e){return Math.floor((e.getTime()-Date.UTC(e.getUTCFullYear(),0))/864e5)+1},s:function(e){return Math.floor(e.getTime()/1e3)},C:function(e){return Math.floor(e.getUTCFullYear()/100)},N:function(e){return e.getTime()%1e3*1e6},m:function(e){return e.getUTCMonth()+1},Y:function(e){return e.getUTCFullYear()},y:function(e){return e.getUTCFullYear()%100},H:function(e){return e.getUTCHours()},M:function(e){return e.getUTCMinutes()},S:function(e){return e.getUTCSeconds()},e:function(e){return e.getUTCDate()},d:function(e){return e.getUTCDate()},u:function(e){return e.getUTCDay()||7},w:function(e){return e.getUTCDay()},l:function(e){return e.getUTCHours()%12||12},I:function(e){return e.getUTCHours()%12||12},k:function(e){return e.getUTCHours()},Z:function(e){return this.entry.abbrev},a:function(e){return this[this.locale].day.abbrev[e.getUTCDay()]},A:function(e){return this[this.locale].day.full[e.getUTCDay()]},h:function(e){return this[this.locale].month.abbrev[e.getUTCMonth()]},b:function(e){return this[this.locale].month.abbrev[e.getUTCMonth()]},B:function(e){return this[this.locale].month.full[e.getUTCMonth()]},P:function(e){return this[this.locale].meridiem[Math.floor(e.getUTCHours()/12)].toLowerCase()},p:function(e){return this[this.locale].meridiem[Math.floor(e.getUTCHours()/12)]},R:function(e,t){return this.convert([t,\"%H:%M\"])},T:function(e,t){return this.convert([t,\"%H:%M:%S\"])},D:function(e,t){return this.convert([t,\"%m/%d/%y\"])},F:function(e,t){return this.convert([t,\"%Y-%m-%d\"])},x:function(e,t){return this.convert([t,this[this.locale].date])},r:function(e,t){return this.convert([t,this[this.locale].time12||\"%I:%M:%S\"])},X:function(e,t){return this.convert([t,this[this.locale].time24])},c:function(e,t){return this.convert([t,this[this.locale].dateTime])},convert:function(e){if(!e.length)return\"1.0.23\";var t,a,u,l,s,c=Object.create(this),f=[];for(t=0;t=o?Math.floor((n-o)/7)+1:0}function c(e){var t,n,r;return n=e.getUTCFullYear(),t=new Date(Date.UTC(n,0)).getUTCDay(),(r=s(e,1)+(t>1&&t<=4?1:0))?53!=r||4==t||3==t&&29==new Date(n,1,29).getDate()?[r,e.getUTCFullYear()]:[1,e.getUTCFullYear()+1]:(n=e.getUTCFullYear()-1,[r=4==(t=new Date(Date.UTC(n,0)).getUTCDay())||3==t&&29==new Date(n,1,29).getDate()?53:52,e.getUTCFullYear()-1])}return u=u.toLowerCase().split(\"|\"),\"delmHMSUWVgCIky\".replace(/./g,(function(e){a[e].pad=2})),a.N.pad=9,a.j.pad=3,a.k.style=\"_\",a.l.style=\"_\",a.e.style=\"_\",function(){return a.convert(arguments)}}))},\n", + " function _(r,t,n,e,i){e();const u=r(1),a=u.__importStar(r(183)),f=r(184),o=u.__importDefault(r(181)),l=r(21),s=r(8);function c(r,...t){return f.sprintf(r,...t)}function m(r,t,n){if(s.isNumber(r)){return c((()=>{switch(!1){case Math.floor(r)!=r:return\"%d\";case!(Math.abs(r)>.1&&Math.abs(r)<1e3):return\"%0.3f\";default:return\"%0.3e\"}})(),r)}return`${r}`}function p(r,t,e){if(null==t)return m;if(null!=e&&r in e){const t=e[r];if(s.isString(t)){if(t in n.DEFAULT_FORMATTERS)return n.DEFAULT_FORMATTERS[t];throw new Error(`Unknown tooltip field formatter type '${t}'`)}return function(r,n,e){return t.format(r,n,e)}}return n.DEFAULT_FORMATTERS.numeral}function d(r,t,n,e){if(\"$\"==r[0]){return function(r,t){if(r in t)return t[r];throw new Error(`Unknown special variable '$${r}'`)}(r.substring(1),e)}return function(r,t,n){const e=t.get_column(r);if(null==e)return null;if(s.isNumber(n))return e[n];const i=e[n.index];if(s.isTypedArray(i)||s.isArray(i))return s.isArray(i[0])?i[n.dim2][n.dim1]:i[n.flat_index];return i}(r.substring(1).replace(/[{}]/g,\"\"),t,n)}n.FormatterType=l.Enum(\"numeral\",\"printf\",\"datetime\"),n.DEFAULT_FORMATTERS={numeral:(r,t,n)=>a.format(r,t),datetime:(r,t,n)=>o.default(r,t),printf:(r,t,n)=>c(t,r)},n.sprintf=c,n.basic_formatter=m,n.get_formatter=p,n.get_value=d,n.replace_placeholders=function(r,t,n,e,i={},u){let a,f;if(s.isString(r)?(a=r,f=!1):(a=r.html,f=!0),a=a.replace(/@\\$name/g,(r=>`@{${i.name}}`)),a=a.replace(/((?:\\$\\w+)|(?:@\\w+)|(?:@{(?:[^{}]+)}))(?:{([^{}]+)})?/g,((r,a,o)=>{const l=d(a,t,n,i);if(null==l)return u?u(\"???\"):\"???\";if(\"safe\"==o)return f=!0,`${l}`;const s=`${p(a,o,e)(l,o,i)}`;return u?u(s):s})),f){return[...(new DOMParser).parseFromString(a,\"text/html\").body.childNodes]}return a}},\n", + " function _(e,n,t,r,i){\n", + " /*!\n", + " * numbro.js\n", + " * version : 1.6.2\n", + " * author : Företagsplatsen AB\n", + " * license : MIT\n", + " * http://www.foretagsplatsen.se\n", + " */\n", + " var a,o={},l=o,u=\"en-US\",c=null,s=\"0,0\";void 0!==n&&n.exports;function f(e){this._value=e}function d(e){var n,t=\"\";for(n=0;n-1?function(e,n){var t,r,i,a;return t=(a=e.toString()).split(\"e\")[0],i=a.split(\"e\")[1],a=t.split(\".\")[0]+(r=t.split(\".\")[1]||\"\")+d(i-r.length),n>0&&(a+=\".\"+d(n)),a}(e,n):(t(e*o)/o).toFixed(n),r&&(i=new RegExp(\"0{1,\"+r+\"}$\"),a=a.replace(i,\"\")),a}function p(e,n,t){return n.indexOf(\"$\")>-1?function(e,n,t){var r,i,a=n,l=a.indexOf(\"$\"),c=a.indexOf(\"(\"),s=a.indexOf(\"+\"),f=a.indexOf(\"-\"),d=\"\",h=\"\";-1===a.indexOf(\"$\")?\"infix\"===o[u].currency.position?(h=o[u].currency.symbol,o[u].currency.spaceSeparated&&(h=\" \"+h+\" \")):o[u].currency.spaceSeparated&&(d=\" \"):a.indexOf(\" $\")>-1?(d=\" \",a=a.replace(\" $\",\"\")):a.indexOf(\"$ \")>-1?(d=\" \",a=a.replace(\"$ \",\"\")):a=a.replace(\"$\",\"\");if(i=m(e,a,t,h),-1===n.indexOf(\"$\"))switch(o[u].currency.position){case\"postfix\":i.indexOf(\")\")>-1?((i=i.split(\"\")).splice(-1,0,d+o[u].currency.symbol),i=i.join(\"\")):i=i+d+o[u].currency.symbol;break;case\"infix\":break;case\"prefix\":i.indexOf(\"(\")>-1||i.indexOf(\"-\")>-1?(i=i.split(\"\"),r=Math.max(c,f)+1,i.splice(r,0,o[u].currency.symbol+d),i=i.join(\"\")):i=o[u].currency.symbol+d+i;break;default:throw Error('Currency position should be among [\"prefix\", \"infix\", \"postfix\"]')}else l<=1?i.indexOf(\"(\")>-1||i.indexOf(\"+\")>-1||i.indexOf(\"-\")>-1?(r=1,(l-1?((i=i.split(\"\")).splice(-1,0,d+o[u].currency.symbol),i=i.join(\"\")):i=i+d+o[u].currency.symbol;return i}(e,n,t):n.indexOf(\"%\")>-1?function(e,n,t){var r,i=\"\";e*=100,n.indexOf(\" %\")>-1?(i=\" \",n=n.replace(\" %\",\"\")):n=n.replace(\"%\",\"\");(r=m(e,n,t)).indexOf(\")\")>-1?((r=r.split(\"\")).splice(-1,0,i+\"%\"),r=r.join(\"\")):r=r+i+\"%\";return r}(e,n,t):n.indexOf(\":\")>-1?function(e){var n=Math.floor(e/60/60),t=Math.floor((e-60*n*60)/60),r=Math.round(e-60*n*60-60*t);return n+\":\"+(t<10?\"0\"+t:t)+\":\"+(r<10?\"0\"+r:r)}(e):m(e,n,t)}function m(e,n,t,r){var i,a,l,s,f,d,p,m,x,g,O,b,w,y,M,v,$,B=!1,E=!1,F=!1,k=\"\",U=!1,N=!1,S=!1,j=!1,D=!1,C=\"\",L=\"\",T=Math.abs(e),K=[\"B\",\"KiB\",\"MiB\",\"GiB\",\"TiB\",\"PiB\",\"EiB\",\"ZiB\",\"YiB\"],G=[\"B\",\"KB\",\"MB\",\"GB\",\"TB\",\"PB\",\"EB\",\"ZB\",\"YB\"],I=\"\",P=!1,R=!1;if(0===e&&null!==c)return c;if(!isFinite(e))return\"\"+e;if(0===n.indexOf(\"{\")){var W=n.indexOf(\"}\");if(-1===W)throw Error('Format should also contain a \"}\"');b=n.slice(1,W),n=n.slice(W+1)}else b=\"\";if(n.indexOf(\"}\")===n.length-1){var Y=n.indexOf(\"{\");if(-1===Y)throw Error('Format should also contain a \"{\"');w=n.slice(Y+1,-1),n=n.slice(0,Y+1)}else w=\"\";if(v=null===($=-1===n.indexOf(\".\")?n.match(/([0-9]+).*/):n.match(/([0-9]+)\\..*/))?-1:$[1].length,-1!==n.indexOf(\"-\")&&(P=!0),n.indexOf(\"(\")>-1?(B=!0,n=n.slice(1,-1)):n.indexOf(\"+\")>-1&&(E=!0,n=n.replace(/\\+/g,\"\")),n.indexOf(\"a\")>-1){if(g=n.split(\".\")[0].match(/[0-9]+/g)||[\"0\"],g=parseInt(g[0],10),U=n.indexOf(\"aK\")>=0,N=n.indexOf(\"aM\")>=0,S=n.indexOf(\"aB\")>=0,j=n.indexOf(\"aT\")>=0,D=U||N||S||j,n.indexOf(\" a\")>-1?(k=\" \",n=n.replace(\" a\",\"\")):n=n.replace(\"a\",\"\"),p=0===(p=(f=Math.floor(Math.log(T)/Math.LN10)+1)%3)?3:p,g&&0!==T&&(d=Math.floor(Math.log(T)/Math.LN10)+1-g,m=3*~~((Math.min(g,f)-p)/3),T/=Math.pow(10,m),-1===n.indexOf(\".\")&&g>3))for(n+=\"[.]\",M=(M=0===d?0:3*~~(d/3)-d)<0?M+3:M,i=0;i=Math.pow(10,12)&&!D||j?(k+=o[u].abbreviations.trillion,e/=Math.pow(10,12)):T=Math.pow(10,9)&&!D||S?(k+=o[u].abbreviations.billion,e/=Math.pow(10,9)):T=Math.pow(10,6)&&!D||N?(k+=o[u].abbreviations.million,e/=Math.pow(10,6)):(T=Math.pow(10,3)&&!D||U)&&(k+=o[u].abbreviations.thousand,e/=Math.pow(10,3)))}if(n.indexOf(\"b\")>-1)for(n.indexOf(\" b\")>-1?(C=\" \",n=n.replace(\" b\",\"\")):n=n.replace(\"b\",\"\"),s=0;s<=K.length;s++)if(a=Math.pow(1024,s),l=Math.pow(1024,s+1),e>=a&&e0&&(e/=a);break}if(n.indexOf(\"d\")>-1)for(n.indexOf(\" d\")>-1?(C=\" \",n=n.replace(\" d\",\"\")):n=n.replace(\"d\",\"\"),s=0;s<=G.length;s++)if(a=Math.pow(1e3,s),l=Math.pow(1e3,s+1),e>=a&&e0&&(e/=a);break}if(n.indexOf(\"o\")>-1&&(n.indexOf(\" o\")>-1?(L=\" \",n=n.replace(\" o\",\"\")):n=n.replace(\"o\",\"\"),o[u].ordinal&&(L+=o[u].ordinal(e))),n.indexOf(\"[.]\")>-1&&(F=!0,n=n.replace(\"[.]\",\".\")),x=e.toString().split(\".\")[0],O=n.split(\".\")[1],y=n.indexOf(\",\"),O){if(x=(I=-1!==O.indexOf(\"*\")?h(e,e.toString().split(\".\")[1].length,t):O.indexOf(\"[\")>-1?h(e,(O=(O=O.replace(\"]\",\"\")).split(\"[\"))[0].length+O[1].length,t,O[1].length):h(e,O.length,t)).split(\".\")[0],I.split(\".\")[1].length)I=(r?k+r:o[u].delimiters.decimal)+I.split(\".\")[1];else I=\"\";F&&0===Number(I.slice(1))&&(I=\"\")}else x=h(e,null,t);return x.indexOf(\"-\")>-1&&(x=x.slice(1),R=!0),x.length-1&&(x=x.toString().replace(/(\\d)(?=(\\d{3})+(?!\\d))/g,\"$1\"+o[u].delimiters.thousands)),0===n.indexOf(\".\")&&(x=\"\"),b+(n.indexOf(\"(\")2)&&(o.length<2?!!o[0].match(/^\\d+.*\\d$/)&&!o[0].match(u):1===o[0].length?!!o[0].match(/^\\d+$/)&&!o[0].match(u)&&!!o[1].match(/^\\d+$/):!!o[0].match(/^\\d+.*\\d$/)&&!o[0].match(u)&&!!o[1].match(/^\\d+$/)))))},n.exports={format:function(e,n,t,r){return null!=t&&t!==a.culture()&&a.setCulture(t),p(Number(e),null!=n?n:s,null==r?Math.round:r)}}},\n", + " function _(e,n,t,r,i){!function(){\"use strict\";var e={not_string:/[^s]/,not_bool:/[^t]/,not_type:/[^T]/,not_primitive:/[^v]/,number:/[diefg]/,numeric_arg:/[bcdiefguxX]/,json:/[j]/,not_json:/[^j]/,text:/^[^\\x25]+/,modulo:/^\\x25{2}/,placeholder:/^\\x25(?:([1-9]\\d*)\\$|\\(([^)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/,key:/^([a-z_][a-z_\\d]*)/i,key_access:/^\\.([a-z_][a-z_\\d]*)/i,index_access:/^\\[(\\d+)\\]/,sign:/^[+-]/};function n(e){return i(a(e),arguments)}function r(e,t){return n.apply(null,[e].concat(t||[]))}function i(t,r){var i,s,a,o,p,c,l,u,f,d=1,g=t.length,y=\"\";for(s=0;s=0),o.type){case\"b\":i=parseInt(i,10).toString(2);break;case\"c\":i=String.fromCharCode(parseInt(i,10));break;case\"d\":case\"i\":i=parseInt(i,10);break;case\"j\":i=JSON.stringify(i,null,o.width?parseInt(o.width):0);break;case\"e\":i=o.precision?parseFloat(i).toExponential(o.precision):parseFloat(i).toExponential();break;case\"f\":i=o.precision?parseFloat(i).toFixed(o.precision):parseFloat(i);break;case\"g\":i=o.precision?String(Number(i.toPrecision(o.precision))):parseFloat(i);break;case\"o\":i=(parseInt(i,10)>>>0).toString(8);break;case\"s\":i=String(i),i=o.precision?i.substring(0,o.precision):i;break;case\"t\":i=String(!!i),i=o.precision?i.substring(0,o.precision):i;break;case\"T\":i=Object.prototype.toString.call(i).slice(8,-1).toLowerCase(),i=o.precision?i.substring(0,o.precision):i;break;case\"u\":i=parseInt(i,10)>>>0;break;case\"v\":i=i.valueOf(),i=o.precision?i.substring(0,o.precision):i;break;case\"x\":i=(parseInt(i,10)>>>0).toString(16);break;case\"X\":i=(parseInt(i,10)>>>0).toString(16).toUpperCase()}e.json.test(o.type)?y+=i:(!e.number.test(o.type)||u&&!o.sign?f=\"\":(f=u?\"+\":\"-\",i=i.toString().replace(e.sign,\"\")),c=o.pad_char?\"0\"===o.pad_char?\"0\":o.pad_char.charAt(1):\" \",l=o.width-(f+i).length,p=o.width&&l>0?c.repeat(l):\"\",y+=o.align?f+i+p:\"0\"===c?f+p+i:p+f+i)}return y}var s=Object.create(null);function a(n){if(s[n])return s[n];for(var t,r=n,i=[],a=0;r;){if(null!==(t=e.text.exec(r)))i.push(t[0]);else if(null!==(t=e.modulo.exec(r)))i.push(\"%\");else{if(null===(t=e.placeholder.exec(r)))throw new SyntaxError(\"[sprintf] unexpected placeholder\");if(t[2]){a|=1;var o=[],p=t[2],c=[];if(null===(c=e.key.exec(p)))throw new SyntaxError(\"[sprintf] failed to parse named argument key\");for(o.push(c[1]);\"\"!==(p=p.substring(c[0].length));)if(null!==(c=e.key_access.exec(p)))o.push(c[1]);else{if(null===(c=e.index_access.exec(p)))throw new SyntaxError(\"[sprintf] failed to parse named argument key\");o.push(c[1])}t[2]=o}else a|=2;if(3===a)throw new Error(\"[sprintf] mixing positional and named placeholders is not (yet) supported\");i.push({placeholder:t[0],param_no:t[1],keys:t[2],sign:t[3],pad_char:t[4],align:t[5],width:t[6],precision:t[7],type:t[8]})}r=r.substring(t[0].length)}return s[n]=i}void 0!==t&&(t.sprintf=n,t.vsprintf=r),\"undefined\"!=typeof window&&(window.sprintf=n,window.vsprintf=r,\"function\"==typeof define&&define.amd&&define((function(){return{sprintf:n,vsprintf:r}})))}()},\n", + " function _(e,i,n,t,a){t();const s=e(9),r=e(178),c=e(186),m=e(187),_=e(190),k=e(191),o=e(189);class T extends c.CompositeTicker{constructor(e){super(e)}static init_DatetimeTicker(){this.override({num_minor_ticks:0,tickers:()=>[new r.AdaptiveTicker({mantissas:[1,2,5],base:10,min_interval:0,max_interval:500*o.ONE_MILLI,num_minor_ticks:0}),new r.AdaptiveTicker({mantissas:[1,2,5,10,15,20,30],base:60,min_interval:o.ONE_SECOND,max_interval:30*o.ONE_MINUTE,num_minor_ticks:0}),new r.AdaptiveTicker({mantissas:[1,2,4,6,8,12],base:24,min_interval:o.ONE_HOUR,max_interval:12*o.ONE_HOUR,num_minor_ticks:0}),new m.DaysTicker({days:s.range(1,32)}),new m.DaysTicker({days:s.range(1,31,3)}),new m.DaysTicker({days:[1,8,15,22]}),new m.DaysTicker({days:[1,15]}),new _.MonthsTicker({months:s.range(0,12,1)}),new _.MonthsTicker({months:s.range(0,12,2)}),new _.MonthsTicker({months:s.range(0,12,4)}),new _.MonthsTicker({months:s.range(0,12,6)}),new k.YearsTicker({})]})}}n.DatetimeTicker=T,T.__name__=\"DatetimeTicker\",T.init_DatetimeTicker()},\n", + " function _(t,e,i,s,r){s();const n=t(179),_=t(9);class a extends n.ContinuousTicker{constructor(t){super(t)}static init_CompositeTicker(){this.define((({Array:t,Ref:e})=>({tickers:[t(e(n.ContinuousTicker)),[]]})))}get min_intervals(){return this.tickers.map((t=>t.get_min_interval()))}get max_intervals(){return this.tickers.map((t=>t.get_max_interval()))}get_min_interval(){return this.min_intervals[0]}get_max_interval(){return this.max_intervals[0]}get_best_ticker(t,e,i){const s=e-t,r=this.get_ideal_interval(t,e,i),n=[_.sorted_index(this.min_intervals,r)-1,_.sorted_index(this.max_intervals,r)],a=[this.min_intervals[n[0]],this.max_intervals[n[1]]].map((t=>Math.abs(i-s/t)));let c;if(_.is_empty(a.filter((t=>!isNaN(t)))))c=this.tickers[0];else{const t=n[_.argmin(a)];c=this.tickers[t]}return c}get_interval(t,e,i){return this.get_best_ticker(t,e,i).get_interval(t,e,i)}get_ticks_no_defaults(t,e,i,s){return this.get_best_ticker(t,e,s).get_ticks_no_defaults(t,e,i,s)}}i.CompositeTicker=a,a.__name__=\"CompositeTicker\",a.init_CompositeTicker()},\n", + " function _(t,e,n,i,s){i();const a=t(188),o=t(189),r=t(9);class c extends a.SingleIntervalTicker{constructor(t){super(t)}static init_DaysTicker(){this.define((({Int:t,Array:e})=>({days:[e(t),[]]}))),this.override({num_minor_ticks:0})}initialize(){super.initialize();const t=this.days;t.length>1?this.interval=(t[1]-t[0])*o.ONE_DAY:this.interval=31*o.ONE_DAY}get_ticks_no_defaults(t,e,n,i){const s=function(t,e){const n=o.last_month_no_later_than(new Date(t)),i=o.last_month_no_later_than(new Date(e));i.setUTCMonth(i.getUTCMonth()+1);const s=[],a=n;for(;s.push(o.copy_date(a)),a.setUTCMonth(a.getUTCMonth()+1),!(a>i););return s}(t,e),a=this.days,c=this.interval;return{major:r.concat(s.map((t=>((t,e)=>{const n=t.getUTCMonth(),i=[];for(const s of a){const a=o.copy_date(t);a.setUTCDate(s),new Date(a.getTime()+e/2).getUTCMonth()==n&&i.push(a)}return i})(t,c)))).map((t=>t.getTime())).filter((n=>t<=n&&n<=e)),minor:[]}}}n.DaysTicker=c,c.__name__=\"DaysTicker\",c.init_DaysTicker()},\n", + " function _(e,t,n,i,r){i();const l=e(179);class a extends l.ContinuousTicker{constructor(e){super(e)}static init_SingleIntervalTicker(){this.define((({Number:e})=>({interval:[e]})))}get_interval(e,t,n){return this.interval}get_min_interval(){return this.interval}get_max_interval(){return this.interval}}n.SingleIntervalTicker=a,a.__name__=\"SingleIntervalTicker\",a.init_SingleIntervalTicker()},\n", + " function _(t,n,e,_,E){function N(t){return new Date(t.getTime())}function O(t){const n=N(t);return n.setUTCDate(1),n.setUTCHours(0),n.setUTCMinutes(0),n.setUTCSeconds(0),n.setUTCMilliseconds(0),n}_(),e.ONE_MILLI=1,e.ONE_SECOND=1e3,e.ONE_MINUTE=60*e.ONE_SECOND,e.ONE_HOUR=60*e.ONE_MINUTE,e.ONE_DAY=24*e.ONE_HOUR,e.ONE_MONTH=30*e.ONE_DAY,e.ONE_YEAR=365*e.ONE_DAY,e.copy_date=N,e.last_month_no_later_than=O,e.last_year_no_later_than=function(t){const n=O(t);return n.setUTCMonth(0),n}},\n", + " function _(t,e,n,i,s){i();const r=t(188),a=t(189),o=t(9);class c extends r.SingleIntervalTicker{constructor(t){super(t)}static init_MonthsTicker(){this.define((({Int:t,Array:e})=>({months:[e(t),[]]})))}initialize(){super.initialize();const t=this.months;t.length>1?this.interval=(t[1]-t[0])*a.ONE_MONTH:this.interval=12*a.ONE_MONTH}get_ticks_no_defaults(t,e,n,i){const s=function(t,e){const n=a.last_year_no_later_than(new Date(t)),i=a.last_year_no_later_than(new Date(e));i.setUTCFullYear(i.getUTCFullYear()+1);const s=[],r=n;for(;s.push(a.copy_date(r)),r.setUTCFullYear(r.getUTCFullYear()+1),!(r>i););return s}(t,e),r=this.months;return{major:o.concat(s.map((t=>r.map((e=>{const n=a.copy_date(t);return n.setUTCMonth(e),n}))))).map((t=>t.getTime())).filter((n=>t<=n&&n<=e)),minor:[]}}}n.MonthsTicker=c,c.__name__=\"MonthsTicker\",c.init_MonthsTicker()},\n", + " function _(e,t,a,i,r){i();const n=e(177),_=e(188),s=e(189);class c extends _.SingleIntervalTicker{constructor(e){super(e)}initialize(){super.initialize(),this.interval=s.ONE_YEAR,this.basic_ticker=new n.BasicTicker({num_minor_ticks:0})}get_ticks_no_defaults(e,t,a,i){const r=s.last_year_no_later_than(new Date(e)).getUTCFullYear(),n=s.last_year_no_later_than(new Date(t)).getUTCFullYear();return{major:this.basic_ticker.get_ticks_no_defaults(r,n,a,i).major.map((e=>Date.UTC(e,0,1))).filter((a=>e<=a&&a<=t)),minor:[]}}}a.YearsTicker=c,c.__name__=\"YearsTicker\"},\n", + " function _(i,s,t,e,o){e();const n=i(173),r=i(193),_=i(194);class c extends n.ContinuousAxisView{}t.LogAxisView=c,c.__name__=\"LogAxisView\";class x extends n.ContinuousAxis{constructor(i){super(i)}static init_LogAxis(){this.prototype.default_view=c,this.override({ticker:()=>new _.LogTicker,formatter:()=>new r.LogTickFormatter})}}t.LogAxis=x,x.__name__=\"LogAxis\",x.init_LogAxis()},\n", + " function _(t,e,r,i,n){i();const o=t(166),a=t(176),s=t(194),c=t(167),{log:l,round:u}=Math;class _ extends o.TickFormatter{constructor(t){super(t)}static init_LogTickFormatter(){this.define((({Ref:t,Nullable:e})=>({ticker:[e(t(s.LogTicker)),null]})))}initialize(){super.initialize(),this.basic_formatter=new a.BasicTickFormatter}format_graphics(t,e){var r,i;if(0==t.length)return[];const n=null!==(i=null===(r=this.ticker)||void 0===r?void 0:r.base)&&void 0!==i?i:10,o=this._exponents(t,n);return null==o?this.basic_formatter.format_graphics(t,e):o.map((t=>{const e=new c.TextBox({text:a.unicode_replace(`${n}`)}),r=new c.TextBox({text:a.unicode_replace(`${t}`)});return new c.BaseExpo(e,r)}))}_exponents(t,e){let r=null;const i=[];for(const n of t){const t=u(l(n)/l(e));if(r==t)return null;r=t,i.push(t)}return i}doFormat(t,e){var r,i;if(0==t.length)return[];const n=null!==(i=null===(r=this.ticker)||void 0===r?void 0:r.base)&&void 0!==i?i:10,o=this._exponents(t,n);return null==o?this.basic_formatter.doFormat(t,e):o.map((t=>a.unicode_replace(`${n}^${t}`)))}}r.LogTickFormatter=_,_.__name__=\"LogTickFormatter\",_.init_LogTickFormatter()},\n", + " function _(t,o,e,i,s){i();const n=t(178),r=t(9);class c extends n.AdaptiveTicker{constructor(t){super(t)}static init_LogTicker(){this.override({mantissas:[1,5]})}get_ticks_no_defaults(t,o,e,i){const s=this.num_minor_ticks,n=[],c=this.base,a=Math.log(t)/Math.log(c),f=Math.log(o)/Math.log(c),l=f-a;let h;if(isFinite(l))if(l<2){const e=this.get_interval(t,o,i),c=Math.floor(t/e),a=Math.ceil(o/e);if(h=r.range(c,a+1).filter((t=>0!=t)).map((t=>t*e)).filter((e=>t<=e&&e<=o)),s>0&&h.length>0){const t=e/s,o=r.range(0,s).map((o=>o*t));for(const t of o.slice(1))n.push(h[0]-t);for(const t of h)for(const e of o)n.push(t+e)}}else{const t=Math.ceil(.999999*a),o=Math.floor(1.000001*f),e=Math.ceil((o-t)/9);if(h=r.range(t-1,o+1,e).map((t=>c**t)),s>0&&h.length>0){const t=c**e/s,o=r.range(1,s+1).map((o=>o*t));for(const t of o)n.push(h[0]/t);n.push(h[0]);for(const t of h)for(const e of o)n.push(t*e)}}else h=[];return{major:h.filter((e=>t<=e&&e<=o)),minor:n.filter((e=>t<=e&&e<=o))}}}e.LogTicker=c,c.__name__=\"LogTicker\",c.init_LogTicker()},\n", + " function _(e,t,i,r,s){r();const a=e(163),o=e(175),c=e(196),n=e(197);class _ extends a.AxisView{}i.MercatorAxisView=_,_.__name__=\"MercatorAxisView\";class x extends o.LinearAxis{constructor(e){super(e)}static init_MercatorAxis(){this.prototype.default_view=_,this.override({ticker:()=>new n.MercatorTicker({dimension:\"lat\"}),formatter:()=>new c.MercatorTickFormatter({dimension:\"lat\"})})}}i.MercatorAxis=x,x.__name__=\"MercatorAxis\",x.init_MercatorAxis()},\n", + " function _(r,t,e,o,n){o();const i=r(176),c=r(20),a=r(65);class s extends i.BasicTickFormatter{constructor(r){super(r)}static init_MercatorTickFormatter(){this.define((({Nullable:r})=>({dimension:[r(c.LatLon),null]})))}doFormat(r,t){if(null==this.dimension)throw new Error(\"MercatorTickFormatter.dimension not configured\");if(0==r.length)return[];const e=r.length,o=new Array(e);if(\"lon\"==this.dimension)for(let n=0;n({dimension:[t(e.LatLon),null]})))}get_ticks_no_defaults(t,o,n,r){if(null==this.dimension)throw new Error(`${this}.dimension wasn't configured`);return[t,o]=c.clip_mercator(t,o,this.dimension),\"lon\"==this.dimension?this._get_ticks_lon(t,o,n,r):this._get_ticks_lat(t,o,n,r)}_get_ticks_lon(t,o,n,r){const[s]=c.wgs84_mercator.invert(t,n),[i,e]=c.wgs84_mercator.invert(o,n),_=super.get_ticks_no_defaults(s,i,n,r),a=[];for(const t of _.major)if(c.in_bounds(t,\"lon\")){const[o]=c.wgs84_mercator.compute(t,e);a.push(o)}const m=[];for(const t of _.minor)if(c.in_bounds(t,\"lon\")){const[o]=c.wgs84_mercator.compute(t,e);m.push(o)}return{major:a,minor:m}}_get_ticks_lat(t,o,n,r){const[,s]=c.wgs84_mercator.invert(n,t),[i,e]=c.wgs84_mercator.invert(n,o),_=super.get_ticks_no_defaults(s,e,n,r),a=[];for(const t of _.major)if(c.in_bounds(t,\"lat\")){const[,o]=c.wgs84_mercator.compute(i,t);a.push(o)}const m=[];for(const t of _.minor)if(c.in_bounds(t,\"lat\")){const[,o]=c.wgs84_mercator.compute(i,t);m.push(o)}return{major:a,minor:m}}}n.MercatorTicker=_,_.__name__=\"MercatorTicker\",_.init_MercatorTicker()},\n", + " function _(e,i,r,c,k){c(),k(\"AdaptiveTicker\",e(178).AdaptiveTicker),k(\"BasicTicker\",e(177).BasicTicker),k(\"CategoricalTicker\",e(171).CategoricalTicker),k(\"CompositeTicker\",e(186).CompositeTicker),k(\"ContinuousTicker\",e(179).ContinuousTicker),k(\"DatetimeTicker\",e(185).DatetimeTicker),k(\"DaysTicker\",e(187).DaysTicker),k(\"FixedTicker\",e(199).FixedTicker),k(\"LogTicker\",e(194).LogTicker),k(\"MercatorTicker\",e(197).MercatorTicker),k(\"MonthsTicker\",e(190).MonthsTicker),k(\"SingleIntervalTicker\",e(188).SingleIntervalTicker),k(\"Ticker\",e(165).Ticker),k(\"YearsTicker\",e(191).YearsTicker),k(\"BinnedTicker\",e(200).BinnedTicker)},\n", + " function _(i,t,e,r,n){r();const s=i(179);class _ extends s.ContinuousTicker{constructor(i){super(i)}static init_FixedTicker(){this.define((({Number:i,Array:t})=>({ticks:[t(i),[]],minor_ticks:[t(i),[]]})))}get_ticks_no_defaults(i,t,e,r){return{major:this.ticks,minor:this.minor_ticks}}get_interval(i,t,e){return 0}get_min_interval(){return 0}get_max_interval(){return 0}}e.FixedTicker=_,_.__name__=\"FixedTicker\",_.init_FixedTicker()},\n", + " function _(e,n,t,i,r){i();const c=e(165),o=e(201),s=e(12);class a extends c.Ticker{constructor(e){super(e)}static init_BinnedTicker(){this.define((({Number:e,Ref:n,Or:t,Auto:i})=>({mapper:[n(o.ScanningColorMapper)],num_major_ticks:[t(e,i),8]})))}get_ticks(e,n,t,i){const{binning:r}=this.mapper.metrics,c=Math.max(0,s.left_edge_index(e,r)),o=Math.min(s.left_edge_index(n,r)+1,r.length-1),a=[];for(let e=c;e<=o;e++)a.push(r[e]);const{num_major_ticks:_}=this,m=[],h=\"auto\"==_?a.length:_,l=Math.max(1,Math.floor(a.length/h));for(let e=0;eo.binning[o.binning.length-1])return r;return e[a.left_edge_index(n,o.binning)]}}i.ScanningColorMapper=c,c.__name__=\"ScanningColorMapper\"},\n", + " function _(t,o,e,n,s){n();const l=t(203),i=t(61),c=t(9),a=t(8);class r extends l.ColorMapper{constructor(t){super(t),this._scan_data=null}static init_ContinuousColorMapper(){this.define((({Number:t,String:o,Ref:e,Color:n,Or:s,Tuple:l,Array:c,Nullable:a})=>({high:[a(t),null],low:[a(t),null],high_color:[a(n),null],low_color:[a(n),null],domain:[c(l(e(i.GlyphRenderer),s(o,c(o)))),[]]})))}connect_signals(){super.connect_signals();const t=()=>{for(const[t]of this.domain)this.connect(t.view.change,(()=>this.update_data())),this.connect(t.data_source.selected.change,(()=>this.update_data()))};this.connect(this.properties.domain.change,(()=>t())),t()}update_data(){const{domain:t,palette:o}=this,e=[...this._collect(t)];this._scan_data=this.scan(e,o.length),this.metrics_change.emit(),this.change.emit()}get metrics(){return null==this._scan_data&&this.update_data(),this._scan_data}*_collect(t){for(const[o,e]of t)for(const t of a.isArray(e)?e:[e]){let e=o.data_source.get_column(t);e=o.view.indices.select(e);const n=o.view.masked,s=o.data_source.selected.indices;let l;if(null!=n&&s.length>0?l=c.intersection([...n],s):null!=n?l=[...n]:s.length>0&&(l=s),null!=l&&(e=c.map(l,(t=>e[t]))),e.length>0&&!a.isNumber(e[0]))for(const t of e)yield*t;else yield*e}}_v_compute(t,o,e,n){const{nan_color:s}=n;let{low_color:l,high_color:i}=n;null==l&&(l=e[0]),null==i&&(i=e[e.length-1]);const{domain:a}=this,r=c.is_empty(a)?t:[...this._collect(a)];this._scan_data=this.scan(r,e.length),this.metrics_change.emit();for(let n=0,c=t.length;n({palette:[r(t)],nan_color:[t,\"gray\"]})))}v_compute(t){const r=new Array(t.length);return this._v_compute(t,r,this.palette,this._colors((t=>t))),r}get rgba_mapper(){const t=this,r=p(this.palette),e=this._colors(s);return{v_compute(n){const o=new c.ColorArray(n.length);return t._v_compute(n,o,r,e),new Uint8ClampedArray(l.to_big_endian(o).buffer)}}}_colors(t){return{nan_color:t(this.nan_color)}}}e.ColorMapper=u,u.__name__=\"ColorMapper\",u.init_ColorMapper()},\n", + " function _(r,e,n,s,o){s();const p=r(149);class t extends p.Transform{constructor(r){super(r)}compute(r){throw new Error(\"mapping single values is not supported\")}}n.Mapper=t,t.__name__=\"Mapper\"},\n", + " function _(t,r,a,e,c){e(),c(\"BasicTickFormatter\",t(176).BasicTickFormatter),c(\"CategoricalTickFormatter\",t(172).CategoricalTickFormatter),c(\"DatetimeTickFormatter\",t(180).DatetimeTickFormatter),c(\"FuncTickFormatter\",t(206).FuncTickFormatter),c(\"LogTickFormatter\",t(193).LogTickFormatter),c(\"MercatorTickFormatter\",t(196).MercatorTickFormatter),c(\"NumeralTickFormatter\",t(207).NumeralTickFormatter),c(\"PrintfTickFormatter\",t(208).PrintfTickFormatter),c(\"TickFormatter\",t(166).TickFormatter)},\n", + " function _(t,n,e,s,i){s();const r=t(166),c=t(13),a=t(34);class u extends r.TickFormatter{constructor(t){super(t)}static init_FuncTickFormatter(){this.define((({Unknown:t,String:n,Dict:e})=>({args:[e(t),{}],code:[n,\"\"]})))}get names(){return c.keys(this.args)}get values(){return c.values(this.args)}_make_func(){const t=a.use_strict(this.code);return new Function(\"tick\",\"index\",\"ticks\",...this.names,t)}doFormat(t,n){const e=this._make_func().bind({});return t.map(((t,n,s)=>`${e(t,n,s,...this.values)}`))}}e.FuncTickFormatter=u,u.__name__=\"FuncTickFormatter\",u.init_FuncTickFormatter()},\n", + " function _(r,t,n,e,a){e();const o=r(1).__importStar(r(183)),i=r(166),u=r(20);class c extends i.TickFormatter{constructor(r){super(r)}static init_NumeralTickFormatter(){this.define((({String:r})=>({format:[r,\"0,0\"],language:[r,\"en\"],rounding:[u.RoundingFunction,\"round\"]})))}get _rounding_fn(){switch(this.rounding){case\"round\":case\"nearest\":return Math.round;case\"floor\":case\"rounddown\":return Math.floor;case\"ceil\":case\"roundup\":return Math.ceil}}doFormat(r,t){const{format:n,language:e,_rounding_fn:a}=this;return r.map((r=>o.format(r,n,e,a)))}}n.NumeralTickFormatter=c,c.__name__=\"NumeralTickFormatter\",c.init_NumeralTickFormatter()},\n", + " function _(t,r,i,n,o){n();const a=t(166),e=t(182);class c extends a.TickFormatter{constructor(t){super(t)}static init_PrintfTickFormatter(){this.define((({String:t})=>({format:[t,\"%s\"]})))}doFormat(t,r){return t.map((t=>e.sprintf(this.format,t)))}}i.PrintfTickFormatter=c,c.__name__=\"PrintfTickFormatter\",c.init_PrintfTickFormatter()},\n", + " function _(r,o,a,p,e){p(),e(\"CategoricalColorMapper\",r(210).CategoricalColorMapper),e(\"CategoricalMarkerMapper\",r(212).CategoricalMarkerMapper),e(\"CategoricalPatternMapper\",r(213).CategoricalPatternMapper),e(\"ContinuousColorMapper\",r(202).ContinuousColorMapper),e(\"ColorMapper\",r(203).ColorMapper),e(\"LinearColorMapper\",r(214).LinearColorMapper),e(\"LogColorMapper\",r(215).LogColorMapper),e(\"ScanningColorMapper\",r(201).ScanningColorMapper),e(\"EqHistColorMapper\",r(216).EqHistColorMapper)},\n", + " function _(t,o,a,r,e){r();const c=t(211),l=t(203),i=t(104);class s extends l.ColorMapper{constructor(t){super(t)}static init_CategoricalColorMapper(){this.define((({Number:t,Nullable:o})=>({factors:[i.FactorSeq],start:[t,0],end:[o(t),null]})))}_v_compute(t,o,a,{nan_color:r}){c.cat_v_compute(t,this.factors,a,o,this.start,this.end,r)}}a.CategoricalColorMapper=s,s.__name__=\"CategoricalColorMapper\",s.init_CategoricalColorMapper()},\n", + " function _(n,t,e,l,i){l();const c=n(12),u=n(8);function f(n,t){if(n.length!=t.length)return!1;for(let e=0,l=n.length;ef(n,h)))),s=_<0||_>=e.length?r:e[_],l[g]=s}}},\n", + " function _(r,e,a,t,s){t();const c=r(211),i=r(104),l=r(204),n=r(20);class p extends l.Mapper{constructor(r){super(r)}static init_CategoricalMarkerMapper(){this.define((({Number:r,Array:e,Nullable:a})=>({factors:[i.FactorSeq],markers:[e(n.MarkerType)],start:[r,0],end:[a(r),null],default_value:[n.MarkerType,\"circle\"]})))}v_compute(r){const e=new Array(r.length);return c.cat_v_compute(r,this.factors,this.markers,e,this.start,this.end,this.default_value),e}}a.CategoricalMarkerMapper=p,p.__name__=\"CategoricalMarkerMapper\",p.init_CategoricalMarkerMapper()},\n", + " function _(t,a,e,r,n){r();const s=t(211),c=t(104),i=t(204),p=t(20);class l extends i.Mapper{constructor(t){super(t)}static init_CategoricalPatternMapper(){this.define((({Number:t,Array:a,Nullable:e})=>({factors:[c.FactorSeq],patterns:[a(p.HatchPatternType)],start:[t,0],end:[e(t),null],default_value:[p.HatchPatternType,\" \"]})))}v_compute(t){const a=new Array(t.length);return s.cat_v_compute(t,this.factors,this.patterns,a,this.start,this.end,this.default_value),a}}e.CategoricalPatternMapper=l,l.__name__=\"CategoricalPatternMapper\",l.init_CategoricalPatternMapper()},\n", + " function _(n,r,o,t,a){t();const e=n(202),i=n(12);class s extends e.ContinuousColorMapper{constructor(n){super(n)}scan(n,r){const o=null!=this.low?this.low:i.min(n),t=null!=this.high?this.high:i.max(n);return{max:t,min:o,norm_factor:1/(t-o),normed_interval:1/r}}cmap(n,r,o,t,a){const e=r.length-1;if(n==a.max)return r[e];const i=(n-a.min)*a.norm_factor,s=Math.floor(i/a.normed_interval);return s<0?o:s>e?t:r[s]}}o.LinearColorMapper=s,s.__name__=\"LinearColorMapper\"},\n", + " function _(o,t,n,r,l){r();const a=o(202),s=o(12);class e extends a.ContinuousColorMapper{constructor(o){super(o)}scan(o,t){const n=null!=this.low?this.low:s.min(o),r=null!=this.high?this.high:s.max(o);return{max:r,min:n,scale:t/(Math.log(r)-Math.log(n))}}cmap(o,t,n,r,l){const a=t.length-1;if(o>l.max)return r;if(o==l.max)return t[a];if(oa&&(e=a),t[e]}}n.LogColorMapper=e,e.__name__=\"LogColorMapper\"},\n", + " function _(n,t,i,e,o){e();const s=n(201),r=n(12),a=n(9),l=n(19);class c extends s.ScanningColorMapper{constructor(n){super(n)}static init_EqHistColorMapper(){this.define((({Int:n})=>({bins:[n,65536]})))}scan(n,t){const i=null!=this.low?this.low:r.min(n),e=null!=this.high?this.high:r.max(n),o=this.bins,s=a.linspace(i,e,o+1),c=r.bin_counts(n,s),h=new Array(o);for(let n=0,t=s.length;nn/g));let m=t-1,M=[],_=0,f=2*t;for(;m!=t&&_<4&&0!=m;){const n=f/m;if(n>1e3)break;f=Math.round(Math.max(t*n,t));const i=a.range(0,f),e=r.map(u,(n=>n*(f-1)));M=r.interpolate(i,e,h);m=a.uniq(M).length-1,_++}if(0==m){M=[i,e];for(let n=0;ne*n+t}compute(e){return this._linear_compute(e)}v_compute(e){return this._linear_v_compute(e)}invert(e){return this._linear_invert(e)}v_invert(e){return this._linear_v_invert(e)}}n.LinearScale=u,u.__name__=\"LinearScale\"},\n", + " function _(n,t,e,r,i){r();const a=n(146),o=n(12);class c extends a.Scale{constructor(n){super(n)}static init_LinearInterpolationScale(){this.internal((({Arrayable:n})=>({binning:[n]})))}get s_compute(){throw new Error(\"not implemented\")}compute(n){return n}v_compute(n){const{binning:t}=this,{start:e,end:r}=this.source_range,i=e,a=r,c=t.length,l=(r-e)/(c-1),s=new Float64Array(c);for(let n=0;n{if(na)return a;const e=o.left_edge_index(n,t);if(-1==e)return i;if(e>=c-1)return a;const r=t[e],l=(n-r)/(t[e+1]-r),u=s[e];return u+l*(s[e+1]-u)}));return this._linear_v_compute(u)}invert(n){return n}v_invert(n){return new Float64Array(n)}}e.LinearInterpolationScale=c,c.__name__=\"LinearInterpolationScale\",c.init_LinearInterpolationScale()},\n", + " function _(a,n,e,g,R){g(),R(\"DataRange\",a(160).DataRange),R(\"DataRange1d\",a(159).DataRange1d),R(\"FactorRange\",a(104).FactorRange),R(\"Range\",a(105).Range),R(\"Range1d\",a(156).Range1d)},\n", + " function _(a,o,i,t,e){t();var n=a(141);e(\"Sizeable\",n.Sizeable),e(\"SizingPolicy\",n.SizingPolicy);var c=a(142);e(\"Layoutable\",c.Layoutable),e(\"LayoutItem\",c.LayoutItem);var r=a(222);e(\"HStack\",r.HStack),e(\"VStack\",r.VStack);var l=a(223);e(\"Grid\",l.Grid),e(\"Row\",l.Row),e(\"Column\",l.Column);var S=a(224);e(\"ContentBox\",S.ContentBox),e(\"VariadicBox\",S.VariadicBox)},\n", + " function _(t,e,h,i,r){i();const n=t(142),o=t(99);class s extends n.Layoutable{constructor(){super(...arguments),this.children=[]}*[Symbol.iterator](){yield*this.children}}h.Stack=s,s.__name__=\"Stack\";class c extends s{_measure(t){let e=0,h=0;for(const t of this.children){const i=t.measure({width:0,height:0});e+=i.width,h=Math.max(h,i.height)}return{width:e,height:h}}_set_geometry(t,e){super._set_geometry(t,e);const h=this.absolute?t.top:0;let i=this.absolute?t.left:0;const{height:r}=t;for(const t of this.children){const{width:e}=t.measure({width:0,height:0});t.set_geometry(new o.BBox({left:i,width:e,top:h,height:r})),i+=e}}}h.HStack=c,c.__name__=\"HStack\";class a extends s{_measure(t){let e=0,h=0;for(const t of this.children){const i=t.measure({width:0,height:0});e=Math.max(e,i.width),h+=i.height}return{width:e,height:h}}_set_geometry(t,e){super._set_geometry(t,e);const h=this.absolute?t.left:0;let i=this.absolute?t.top:0;const{width:r}=t;for(const t of this.children){const{height:e}=t.measure({width:0,height:0});t.set_geometry(new o.BBox({top:i,height:e,left:h,width:r})),i+=e}}}h.VStack=a,a.__name__=\"VStack\";class l extends n.Layoutable{constructor(){super(...arguments),this.children=[]}*[Symbol.iterator](){yield*this.children}_measure(t){const{width_policy:e,height_policy:h}=this.sizing,{min:i,max:r}=Math;let n=0,o=0;for(const e of this.children){const{width:h,height:i}=e.measure(t);n=r(n,h),o=r(o,i)}return{width:(()=>{const{width:h}=this.sizing;if(t.width==1/0)return\"fixed\"==e&&null!=h?h:n;switch(e){case\"fixed\":return null!=h?h:n;case\"min\":return n;case\"fit\":return null!=h?i(t.width,h):t.width;case\"max\":return null!=h?r(t.width,h):t.width}})(),height:(()=>{const{height:e}=this.sizing;if(t.height==1/0)return\"fixed\"==h&&null!=e?e:o;switch(h){case\"fixed\":return null!=e?e:o;case\"min\":return o;case\"fit\":return null!=e?i(t.height,e):t.height;case\"max\":return null!=e?r(t.height,e):t.height}})()}}_set_geometry(t,e){super._set_geometry(t,e);const h=this.absolute?t:t.relative(),{left:i,right:r,top:n,bottom:s}=h,c=Math.round(h.vcenter),a=Math.round(h.hcenter);for(const e of this.children){const{margin:h,halign:l,valign:d}=e.sizing,{width:u,height:g,inner:_}=e.measure(t),w=(()=>{switch(`${d}_${l}`){case\"start_start\":return new o.BBox({left:i+h.left,top:n+h.top,width:u,height:g});case\"start_center\":return new o.BBox({hcenter:a,top:n+h.top,width:u,height:g});case\"start_end\":return new o.BBox({right:r-h.right,top:n+h.top,width:u,height:g});case\"center_start\":return new o.BBox({left:i+h.left,vcenter:c,width:u,height:g});case\"center_center\":return new o.BBox({hcenter:a,vcenter:c,width:u,height:g});case\"center_end\":return new o.BBox({right:r-h.right,vcenter:c,width:u,height:g});case\"end_start\":return new o.BBox({left:i+h.left,bottom:s-h.bottom,width:u,height:g});case\"end_center\":return new o.BBox({hcenter:a,bottom:s-h.bottom,width:u,height:g});case\"end_end\":return new o.BBox({right:r-h.right,bottom:s-h.bottom,width:u,height:g})}})(),m=null==_?w:new o.BBox({left:w.left+_.left,top:w.top+_.top,right:w.right-_.right,bottom:w.bottom-_.bottom});e.set_geometry(w,m)}}}h.NodeLayout=l,l.__name__=\"NodeLayout\"},\n", + " function _(t,i,s,e,o){e();const n=t(141),l=t(142),r=t(8),h=t(99),c=t(9),{max:a,round:g}=Math;class p{constructor(t){this.def=t,this._map=new Map}get(t){let i=this._map.get(t);return void 0===i&&(i=this.def(),this._map.set(t,i)),i}apply(t,i){const s=this.get(t);this._map.set(t,i(s))}}p.__name__=\"DefaultMap\";class f{constructor(){this._items=[],this._nrows=0,this._ncols=0}get nrows(){return this._nrows}get ncols(){return this._ncols}add(t,i){const{r1:s,c1:e}=t;this._nrows=a(this._nrows,s+1),this._ncols=a(this._ncols,e+1),this._items.push({span:t,data:i})}at(t,i){return this._items.filter((({span:s})=>s.r0<=t&&t<=s.r1&&s.c0<=i&&i<=s.c1)).map((({data:t})=>t))}row(t){return this._items.filter((({span:i})=>i.r0<=t&&t<=i.r1)).map((({data:t})=>t))}col(t){return this._items.filter((({span:i})=>i.c0<=t&&t<=i.c1)).map((({data:t})=>t))}foreach(t){for(const{span:i,data:s}of this._items)t(i,s)}map(t){const i=new f;for(const{span:s,data:e}of this._items)i.add(s,t(s,e));return i}}f.__name__=\"Container\";class _ extends l.Layoutable{constructor(t=[]){super(),this.items=t,this.rows=\"auto\",this.cols=\"auto\",this.spacing=0}*[Symbol.iterator](){for(const{layout:t}of this.items)yield t}is_width_expanding(){if(super.is_width_expanding())return!0;if(\"fixed\"==this.sizing.width_policy)return!1;const{cols:t}=this._state;return c.some(t,(t=>\"max\"==t.policy))}is_height_expanding(){if(super.is_height_expanding())return!0;if(\"fixed\"==this.sizing.height_policy)return!1;const{rows:t}=this._state;return c.some(t,(t=>\"max\"==t.policy))}_init(){var t,i,s,e;super._init();const o=new f;for(const{layout:t,row:i,col:s,row_span:e,col_span:n}of this.items)if(t.sizing.visible){const l=i,r=s,h=i+(null!=e?e:1)-1,c=s+(null!=n?n:1)-1;o.add({r0:l,c0:r,r1:h,c1:c},t)}const{nrows:n,ncols:l}=o,h=new Array(n);for(let s=0;s{var t;const i=r.isPlainObject(this.rows)?null!==(t=this.rows[s])&&void 0!==t?t:this.rows[\"*\"]:this.rows;return null==i?{policy:\"auto\"}:r.isNumber(i)?{policy:\"fixed\",height:i}:r.isString(i)?{policy:i}:i})(),n=null!==(t=e.align)&&void 0!==t?t:\"auto\";if(\"fixed\"==e.policy)h[s]={policy:\"fixed\",height:e.height,align:n};else if(\"min\"==e.policy)h[s]={policy:\"min\",align:n};else if(\"fit\"==e.policy||\"max\"==e.policy)h[s]={policy:e.policy,flex:null!==(i=e.flex)&&void 0!==i?i:1,align:n};else{if(\"auto\"!=e.policy)throw new Error(\"unrechable\");c.some(o.row(s),(t=>t.is_height_expanding()))?h[s]={policy:\"max\",flex:1,align:n}:h[s]={policy:\"min\",align:n}}}const a=new Array(l);for(let t=0;t{var i;const s=r.isPlainObject(this.cols)?null!==(i=this.cols[t])&&void 0!==i?i:this.cols[\"*\"]:this.cols;return null==s?{policy:\"auto\"}:r.isNumber(s)?{policy:\"fixed\",width:s}:r.isString(s)?{policy:s}:s})(),n=null!==(s=i.align)&&void 0!==s?s:\"auto\";if(\"fixed\"==i.policy)a[t]={policy:\"fixed\",width:i.width,align:n};else if(\"min\"==i.policy)a[t]={policy:\"min\",align:n};else if(\"fit\"==i.policy||\"max\"==i.policy)a[t]={policy:i.policy,flex:null!==(e=i.flex)&&void 0!==e?e:1,align:n};else{if(\"auto\"!=i.policy)throw new Error(\"unrechable\");c.some(o.col(t),(t=>t.is_width_expanding()))?a[t]={policy:\"max\",flex:1,align:n}:a[t]={policy:\"min\",align:n}}}const[g,p]=r.isNumber(this.spacing)?[this.spacing,this.spacing]:this.spacing;this._state={items:o,nrows:n,ncols:l,rows:h,cols:a,rspacing:g,cspacing:p}}_measure_totals(t,i){const{nrows:s,ncols:e,rspacing:o,cspacing:n}=this._state;return{height:c.sum(t)+(s-1)*o,width:c.sum(i)+(e-1)*n}}_measure_cells(t){const{items:i,nrows:s,ncols:e,rows:o,cols:l,rspacing:r,cspacing:h}=this._state,c=new Array(s);for(let t=0;t{const{r0:e,c0:f,r1:d,c1:u}=i,w=(d-e)*r,m=(u-f)*h;let y=0;for(let i=e;i<=d;i++)y+=t(i,f).height;y+=w;let x=0;for(let i=f;i<=u;i++)x+=t(e,i).width;x+=m;const b=s.measure({width:x,height:y});_.add(i,{layout:s,size_hint:b});const z=new n.Sizeable(b).grow_by(s.sizing.margin);z.height-=w,z.width-=m;const v=[];for(let t=e;t<=d;t++){const i=o[t];\"fixed\"==i.policy?z.height-=i.height:v.push(t)}if(z.height>0){const t=g(z.height/v.length);for(const i of v)c[i]=a(c[i],t)}const j=[];for(let t=f;t<=u;t++){const i=l[t];\"fixed\"==i.policy?z.width-=i.width:j.push(t)}if(z.width>0){const t=g(z.width/j.length);for(const i of j)p[i]=a(p[i],t)}}));return{size:this._measure_totals(c,p),row_heights:c,col_widths:p,size_hints:_}}_measure_grid(t){const{nrows:i,ncols:s,rows:e,cols:o,rspacing:n,cspacing:l}=this._state,r=this._measure_cells(((t,i)=>{const s=e[t],n=o[i];return{width:\"fixed\"==n.policy?n.width:1/0,height:\"fixed\"==s.policy?s.height:1/0}}));let h;h=\"fixed\"==this.sizing.height_policy&&null!=this.sizing.height?this.sizing.height:t.height!=1/0&&this.is_height_expanding()?t.height:r.size.height;let c,p=0;for(let t=0;t0)for(let t=0;ti?i:e,t--}}}c=\"fixed\"==this.sizing.width_policy&&null!=this.sizing.width?this.sizing.width:t.width!=1/0&&this.is_width_expanding()?t.width:r.size.width;let f=0;for(let t=0;t0)for(let t=0;ts?s:o,t--}}}const{row_heights:_,col_widths:d,size_hints:u}=this._measure_cells(((t,i)=>({width:r.col_widths[i],height:r.row_heights[t]})));return{size:this._measure_totals(_,d),row_heights:_,col_widths:d,size_hints:u}}_measure(t){const{size:i}=this._measure_grid(t);return i}_set_geometry(t,i){super._set_geometry(t,i);const{nrows:s,ncols:e,rspacing:o,cspacing:n}=this._state,{row_heights:l,col_widths:r,size_hints:c}=this._measure_grid(t),f=this._state.rows.map(((t,i)=>Object.assign(Object.assign({},t),{top:0,height:l[i],get bottom(){return this.top+this.height}}))),_=this._state.cols.map(((t,i)=>Object.assign(Object.assign({},t),{left:0,width:r[i],get right(){return this.left+this.width}}))),d=c.map(((t,i)=>Object.assign(Object.assign({},i),{outer:new h.BBox,inner:new h.BBox})));for(let i=0,e=this.absolute?t.top:0;i{const{layout:r,size_hint:c}=l,{sizing:a}=r,{width:p,height:d}=c,u=function(t,i){let s=(i-t)*n;for(let e=t;e<=i;e++)s+=_[e].width;return s}(i,e),w=function(t,i){let s=(i-t)*o;for(let e=t;e<=i;e++)s+=f[e].height;return s}(t,s),m=i==e&&\"auto\"!=_[i].align?_[i].align:a.halign,y=t==s&&\"auto\"!=f[t].align?f[t].align:a.valign;let x=_[i].left;\"start\"==m?x+=a.margin.left:\"center\"==m?x+=g((u-p)/2):\"end\"==m&&(x+=u-a.margin.right-p);let b=f[t].top;\"start\"==y?b+=a.margin.top:\"center\"==y?b+=g((w-d)/2):\"end\"==y&&(b+=w-a.margin.bottom-d),l.outer=new h.BBox({left:x,top:b,width:p,height:d})}));const u=f.map((()=>({start:new p((()=>0)),end:new p((()=>0))}))),w=_.map((()=>({start:new p((()=>0)),end:new p((()=>0))})));d.foreach((({r0:t,c0:i,r1:s,c1:e},{size_hint:o,outer:n})=>{const{inner:l}=o;null!=l&&(u[t].start.apply(n.top,(t=>a(t,l.top))),u[s].end.apply(f[s].bottom-n.bottom,(t=>a(t,l.bottom))),w[i].start.apply(n.left,(t=>a(t,l.left))),w[e].end.apply(_[e].right-n.right,(t=>a(t,l.right))))})),d.foreach((({r0:t,c0:i,r1:s,c1:e},o)=>{const{size_hint:n,outer:l}=o,r=t=>{const i=this.absolute?l:l.relative(),s=i.left+t.left,e=i.top+t.top,o=i.right-t.right,n=i.bottom-t.bottom;return new h.BBox({left:s,top:e,right:o,bottom:n})};if(null!=n.inner){let h=r(n.inner);if(!1!==n.align){const o=u[t].start.get(l.top),n=u[s].end.get(f[s].bottom-l.bottom),c=w[i].start.get(l.left),a=w[e].end.get(_[e].right-l.right);try{h=r({top:o,bottom:n,left:c,right:a})}catch(t){}}o.inner=h}else o.inner=l})),d.foreach(((t,{layout:i,outer:s,inner:e})=>{i.set_geometry(s,e)}))}}s.Grid=_,_.__name__=\"Grid\";class d extends _{constructor(t){super(),this.items=t.map(((t,i)=>({layout:t,row:0,col:i}))),this.rows=\"fit\"}}s.Row=d,d.__name__=\"Row\";class u extends _{constructor(t){super(),this.items=t.map(((t,i)=>({layout:t,row:i,col:0}))),this.cols=\"fit\"}}s.Column=u,u.__name__=\"Column\"},\n", + " function _(e,t,s,n,i){n();const a=e(142),c=e(141),o=e(43);class r extends a.ContentLayoutable{constructor(e){super(),this.content_size=o.unsized(e,(()=>new c.Sizeable(o.size(e))))}_content_size(){return this.content_size}}s.ContentBox=r,r.__name__=\"ContentBox\";class _ extends a.Layoutable{constructor(e){super(),this.el=e}_measure(e){const t=new c.Sizeable(e).bounded_to(this.sizing.size);return o.sized(this.el,t,(()=>{const e=new c.Sizeable(o.content_size(this.el)),{border:t,padding:s}=o.extents(this.el);return e.grow_by(t).grow_by(s).map(Math.ceil)}))}}s.VariadicBox=_,_.__name__=\"VariadicBox\";class h extends _{constructor(e){super(e),this._cache=new Map}_measure(e){const{width:t,height:s}=e,n=`${t},${s}`;let i=this._cache.get(n);return null==i&&(i=super._measure(e),this._cache.set(n,i)),i}invalidate_cache(){this._cache.clear()}}s.CachedVariadicBox=h,h.__name__=\"CachedVariadicBox\"},\n", + " function _(t,e,i,h,o){h();const s=t(141),r=t(142),n=t(99);class g extends r.Layoutable{constructor(){super(...arguments),this.min_border={left:0,top:0,right:0,bottom:0},this.padding={left:0,top:0,right:0,bottom:0}}*[Symbol.iterator](){yield this.top_panel,yield this.bottom_panel,yield this.left_panel,yield this.right_panel,yield this.center_panel}_measure(t){t=new s.Sizeable({width:\"fixed\"==this.sizing.width_policy||t.width==1/0?this.sizing.width:t.width,height:\"fixed\"==this.sizing.height_policy||t.height==1/0?this.sizing.height:t.height});const e=this.left_panel.measure({width:0,height:t.height}),i=Math.max(e.width,this.min_border.left)+this.padding.left,h=this.right_panel.measure({width:0,height:t.height}),o=Math.max(h.width,this.min_border.right)+this.padding.right,r=this.top_panel.measure({width:t.width,height:0}),n=Math.max(r.height,this.min_border.top)+this.padding.top,g=this.bottom_panel.measure({width:t.width,height:0}),a=Math.max(g.height,this.min_border.bottom)+this.padding.bottom,d=new s.Sizeable(t).shrink_by({left:i,right:o,top:n,bottom:a}),l=this.center_panel.measure(d);return{width:i+l.width+o,height:n+l.height+a,inner:{left:i,right:o,top:n,bottom:a},align:(()=>{const{width_policy:t,height_policy:e}=this.center_panel.sizing;return\"fixed\"!=t&&\"fixed\"!=e})()}}_set_geometry(t,e){super._set_geometry(t,e),this.center_panel.set_geometry(e);const i=this.left_panel.measure({width:0,height:t.height}),h=this.right_panel.measure({width:0,height:t.height}),o=this.top_panel.measure({width:t.width,height:0}),s=this.bottom_panel.measure({width:t.width,height:0}),{left:r,top:g,right:a,bottom:d}=e;this.top_panel.set_geometry(new n.BBox({left:r,right:a,bottom:g,height:o.height})),this.bottom_panel.set_geometry(new n.BBox({left:r,right:a,top:d,height:s.height})),this.left_panel.set_geometry(new n.BBox({top:g,bottom:d,right:r,width:i.width})),this.right_panel.set_geometry(new n.BBox({top:g,bottom:d,left:a,width:h.width}))}}i.BorderLayout=g,g.__name__=\"BorderLayout\"},\n", + " function _(t,e,i,s,n){s();const o=t(1),l=t(139),a=t(10),_=t(143),d=t(20),h=o.__importStar(t(48));class r extends l.TextAnnotationView{_get_size(){const{ctx:t}=this.layer;this.visuals.text.set_value(t);const{width:e}=t.measureText(this.model.text),{height:i}=_.font_metrics(t.font);return{width:e,height:i}}_render(){const{angle:t,angle_units:e}=this.model,i=a.resolve_angle(t,e),s=null!=this.layout?this.layout:this.plot_view.frame,n=this.coordinates.x_scale,o=this.coordinates.y_scale;let l=\"data\"==this.model.x_units?n.compute(this.model.x):s.bbox.xview.compute(this.model.x),_=\"data\"==this.model.y_units?o.compute(this.model.y):s.bbox.yview.compute(this.model.y);l+=this.model.x_offset,_-=this.model.y_offset;(\"canvas\"==this.model.render_mode?this._canvas_text.bind(this):this._css_text.bind(this))(this.layer.ctx,this.model.text,l,_,i)}}i.LabelView=r,r.__name__=\"LabelView\";class c extends l.TextAnnotation{constructor(t){super(t)}static init_Label(){this.prototype.default_view=r,this.mixins([h.Text,[\"border_\",h.Line],[\"background_\",h.Fill]]),this.define((({Number:t,String:e,Angle:i})=>({x:[t],x_units:[d.SpatialUnits,\"data\"],y:[t],y_units:[d.SpatialUnits,\"data\"],text:[e,\"\"],angle:[i,0],angle_units:[d.AngleUnits,\"rad\"],x_offset:[t,0],y_offset:[t,0]}))),this.override({background_fill_color:null,border_line_color:null})}}i.Label=c,c.__name__=\"Label\",c.init_Label()},\n", + " function _(t,e,s,i,o){i();const l=t(1),n=t(139),a=t(56),r=t(130),_=l.__importStar(t(48)),c=t(20),h=t(43),d=l.__importStar(t(18)),u=t(143);class x extends n.TextAnnotationView{set_data(t){a.DataAnnotationView.prototype.set_data.call(this,t)}initialize(){if(super.initialize(),this.set_data(this.model.source),\"css\"==this.model.render_mode)for(let t=0,e=this.text.length;t{this.set_data(this.model.source),\"css\"==this.model.render_mode?this.render():this.request_render()};this.connect(this.model.change,t),this.connect(this.model.source.streaming,t),this.connect(this.model.source.patching,t),this.connect(this.model.source.change,t)}_calculate_text_dimensions(t,e){const{width:s}=t.measureText(e),{height:i}=u.font_metrics(this.visuals.text.font_value(0));return[s,i]}_map_data(){const t=this.coordinates.x_scale,e=this.coordinates.y_scale,s=null!=this.layout?this.layout:this.plot_view.frame;return[\"data\"==this.model.x_units?t.v_compute(this._x):s.bbox.xview.v_compute(this._x),\"data\"==this.model.y_units?e.v_compute(this._y):s.bbox.yview.v_compute(this._y)]}_render(){const t=\"canvas\"==this.model.render_mode?this._v_canvas_text.bind(this):this._v_css_text.bind(this),{ctx:e}=this.layer,[s,i]=this._map_data();for(let o=0,l=this.text.length;o({x:[d.XCoordinateSpec,{field:\"x\"}],y:[d.YCoordinateSpec,{field:\"y\"}],x_units:[c.SpatialUnits,\"data\"],y_units:[c.SpatialUnits,\"data\"],text:[d.StringSpec,{field:\"text\"}],angle:[d.AngleSpec,0],x_offset:[d.NumberSpec,{value:0}],y_offset:[d.NumberSpec,{value:0}],source:[t(r.ColumnDataSource),()=>new r.ColumnDataSource]}))),this.override({background_fill_color:null,border_line_color:null})}}s.LabelSet=v,v.__name__=\"LabelSet\",v.init_LabelSet()},\n", + " function _(t,e,i,s,l){s();const n=t(1),h=t(40),o=t(229),a=t(20),_=n.__importStar(t(48)),r=t(15),d=t(140),c=t(143),g=t(99),m=t(9),b=t(8),f=t(11);class u extends h.AnnotationView{update_layout(){const{panel:t}=this;this.layout=null!=t?new d.SideLayout(t,(()=>this.get_size())):void 0}cursor(t,e){return\"none\"==this.model.click_policy?null:\"pointer\"}get legend_padding(){return null!=this.model.border_line_color?this.model.padding:0}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.request_render())),this.connect(this.model.item_change,(()=>this.request_render()))}compute_legend_bbox(){const t=this.model.get_legend_names(),{glyph_height:e,glyph_width:i}=this.model,{label_height:s,label_width:l}=this.model;this.max_label_height=m.max([c.font_metrics(this.visuals.label_text.font_value()).height,s,e]);const{ctx:n}=this.layer;n.save(),this.visuals.label_text.set_value(n),this.text_widths=new Map;for(const e of t)this.text_widths.set(e,m.max([n.measureText(e).width,l]));this.visuals.title_text.set_value(n),this.title_height=this.model.title?c.font_metrics(this.visuals.title_text.font_value()).height+this.model.title_standoff:0,this.title_width=this.model.title?n.measureText(this.model.title).width:0,n.restore();const h=Math.max(m.max([...this.text_widths.values()]),0),o=this.model.margin,{legend_padding:a}=this,_=this.model.spacing,{label_standoff:r}=this.model;let d,u;if(\"vertical\"==this.model.orientation)d=t.length*this.max_label_height+Math.max(t.length-1,0)*_+2*a+this.title_height,u=m.max([h+i+r+2*a,this.title_width+2*a]);else{let e=2*a+Math.max(t.length-1,0)*_;for(const[,t]of this.text_widths)e+=m.max([t,l])+i+r;u=m.max([this.title_width+2*a,e]),d=this.max_label_height+this.title_height+2*a}const x=null!=this.layout?this.layout:this.plot_view.frame,[p,w]=x.bbox.ranges,{location:v}=this.model;let y,k;if(b.isString(v))switch(v){case\"top_left\":y=p.start+o,k=w.start+o;break;case\"top\":case\"top_center\":y=(p.end+p.start)/2-u/2,k=w.start+o;break;case\"top_right\":y=p.end-o-u,k=w.start+o;break;case\"bottom_right\":y=p.end-o-u,k=w.end-o-d;break;case\"bottom\":case\"bottom_center\":y=(p.end+p.start)/2-u/2,k=w.end-o-d;break;case\"bottom_left\":y=p.start+o,k=w.end-o-d;break;case\"left\":case\"center_left\":y=p.start+o,k=(w.end+w.start)/2-d/2;break;case\"center\":case\"center_center\":y=(p.end+p.start)/2-u/2,k=(w.end+w.start)/2-d/2;break;case\"right\":case\"center_right\":y=p.end-o-u,k=(w.end+w.start)/2-d/2}else if(b.isArray(v)&&2==v.length){const[t,e]=v;y=x.bbox.xview.compute(t),k=x.bbox.yview.compute(e)-d}else f.unreachable();return new g.BBox({left:y,top:k,width:u,height:d})}interactive_bbox(){return this.compute_legend_bbox()}interactive_hit(t,e){return this.interactive_bbox().contains(t,e)}on_hit(t,e){let i;const{glyph_width:s}=this.model,{legend_padding:l}=this,n=this.model.spacing,{label_standoff:h}=this.model;let o=i=l;const a=this.compute_legend_bbox(),_=\"vertical\"==this.model.orientation;for(const r of this.model.items){const d=r.get_labels_list_from_label_prop();for(const c of d){const d=a.x+o,m=a.y+i+this.title_height;let b,f;[b,f]=_?[a.width-2*l,this.max_label_height]:[this.text_widths.get(c)+s+h,this.max_label_height];if(new g.BBox({left:d,top:m,width:b,height:f}).contains(t,e)){switch(this.model.click_policy){case\"hide\":for(const t of r.renderers)t.visible=!t.visible;break;case\"mute\":for(const t of r.renderers)t.muted=!t.muted}return!0}_?i+=this.max_label_height+n:o+=this.text_widths.get(c)+s+h+n}}return!1}_render(){if(0==this.model.items.length)return;for(const t of this.model.items)t.legend=this.model;const{ctx:t}=this.layer,e=this.compute_legend_bbox();t.save(),this._draw_legend_box(t,e),this._draw_legend_items(t,e),this._draw_title(t,e),t.restore()}_draw_legend_box(t,e){t.beginPath(),t.rect(e.x,e.y,e.width,e.height),this.visuals.background_fill.set_value(t),t.fill(),this.visuals.border_line.doit&&(this.visuals.border_line.set_value(t),t.stroke())}_draw_legend_items(t,e){const{glyph_width:i,glyph_height:s}=this.model,{legend_padding:l}=this,n=this.model.spacing,{label_standoff:h}=this.model;let o=l,a=l;const _=\"vertical\"==this.model.orientation;for(const r of this.model.items){const d=r.get_labels_list_from_label_prop(),c=r.get_field_from_label_prop();if(0==d.length)continue;const g=(()=>{switch(this.model.click_policy){case\"none\":return!0;case\"hide\":return m.every(r.renderers,(t=>t.visible));case\"mute\":return m.every(r.renderers,(t=>!t.muted))}})();for(const m of d){const d=e.x+o,b=e.y+a+this.title_height,f=d+i,u=b+s;_?a+=this.max_label_height+n:o+=this.text_widths.get(m)+i+h+n,this.visuals.label_text.set_value(t),t.fillText(m,f+h,b+this.max_label_height/2);for(const e of r.renderers){const i=this.plot_view.renderer_view(e);null==i||i.draw_legend(t,d,f,b,u,c,m,r.index)}if(!g){let s,n;[s,n]=_?[e.width-2*l,this.max_label_height]:[this.text_widths.get(m)+i+h,this.max_label_height],t.beginPath(),t.rect(d,b,s,n),this.visuals.inactive_fill.set_value(t),t.fill()}}}}_draw_title(t,e){const{title:i}=this.model;i&&this.visuals.title_text.doit&&(t.save(),t.translate(e.x0,e.y0+this.title_height),this.visuals.title_text.set_value(t),t.fillText(i,this.legend_padding,this.legend_padding-this.model.title_standoff),t.restore())}_get_size(){const{width:t,height:e}=this.compute_legend_bbox();return{width:t+2*this.model.margin,height:e+2*this.model.margin}}}i.LegendView=u,u.__name__=\"LegendView\";class x extends h.Annotation{constructor(t){super(t)}initialize(){super.initialize(),this.item_change=new r.Signal0(this,\"item_change\")}static init_Legend(){this.prototype.default_view=u,this.mixins([[\"label_\",_.Text],[\"title_\",_.Text],[\"inactive_\",_.Fill],[\"border_\",_.Line],[\"background_\",_.Fill]]),this.define((({Number:t,String:e,Array:i,Tuple:s,Or:l,Ref:n,Nullable:h})=>({orientation:[a.Orientation,\"vertical\"],location:[l(a.LegendLocation,s(t,t)),\"top_right\"],title:[h(e),null],title_standoff:[t,5],label_standoff:[t,5],glyph_height:[t,20],glyph_width:[t,20],label_height:[t,20],label_width:[t,20],margin:[t,10],padding:[t,10],spacing:[t,3],items:[i(n(o.LegendItem)),[]],click_policy:[a.LegendClickPolicy,\"none\"]}))),this.override({border_line_color:\"#e5e5e5\",border_line_alpha:.5,border_line_width:1,background_fill_color:\"#ffffff\",background_fill_alpha:.95,inactive_fill_color:\"white\",inactive_fill_alpha:.7,label_text_font_size:\"13px\",label_text_baseline:\"middle\",title_text_font_size:\"13px\",title_text_font_style:\"italic\"})}get_legend_names(){const t=[];for(const e of this.items){const i=e.get_labels_list_from_label_prop();t.push(...i)}return t}}i.Legend=x,x.__name__=\"Legend\",x.init_Legend()},\n", + " function _(e,r,n,l,t){l();const i=e(1),s=e(53),o=e(61),_=e(57),a=e(230),u=i.__importStar(e(18)),d=e(19),c=e(9);class f extends s.Model{constructor(e){super(e)}static init_LegendItem(){this.define((({Int:e,Array:r,Ref:n,Nullable:l})=>({label:[u.NullStringSpec,null],renderers:[r(n(o.GlyphRenderer)),[]],index:[l(e),null]})))}_check_data_sources_on_renderers(){if(null!=this.get_field_from_label_prop()){if(this.renderers.length<1)return!1;const e=this.renderers[0].data_source;if(null!=e)for(const r of this.renderers)if(r.data_source!=e)return!1}return!0}_check_field_label_on_data_source(){const e=this.get_field_from_label_prop();if(null!=e){if(this.renderers.length<1)return!1;const r=this.renderers[0].data_source;if(null!=r&&!c.includes(r.columns(),e))return!1}return!0}initialize(){super.initialize(),this.legend=null,this.connect(this.change,(()=>{var e;return null===(e=this.legend)||void 0===e?void 0:e.item_change.emit()}));this._check_data_sources_on_renderers()||d.logger.error(\"Non matching data sources on legend item renderers\");this._check_field_label_on_data_source()||d.logger.error(`Bad column name on label: ${this.label}`)}get_field_from_label_prop(){const{label:e}=this;return a.isField(e)?e.field:null}get_labels_list_from_label_prop(){if(a.isValue(this.label)){const{value:e}=this.label;return null!=e?[e]:[]}const e=this.get_field_from_label_prop();if(null!=e){let r;if(!this.renderers[0]||null==this.renderers[0].data_source)return[\"No source found\"];if(r=this.renderers[0].data_source,r instanceof _.ColumnarDataSource){const n=r.get_column(e);return null!=n?c.uniq(Array.from(n)):[\"Invalid field\"]}}return[]}}n.LegendItem=f,f.__name__=\"LegendItem\",f.init_LegendItem()},\n", + " function _(i,n,e,t,u){t();const c=i(8);e.isValue=function(i){return c.isPlainObject(i)&&\"value\"in i},e.isField=function(i){return c.isPlainObject(i)&&\"field\"in i},e.isExpr=function(i){return c.isPlainObject(i)&&\"expr\"in i}},\n", + " function _(t,i,s,n,e){n();const o=t(1),l=t(40),a=o.__importStar(t(48)),c=t(20);class h extends l.AnnotationView{connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.request_render()))}_render(){const{xs:t,ys:i}=this.model;if(t.length!=i.length)return;const s=t.length;if(s<3)return;const{frame:n}=this.plot_view,{ctx:e}=this.layer,o=this.coordinates.x_scale,l=this.coordinates.y_scale,{screen:a}=this.model;function c(t,i,s,n){return a?t:\"data\"==i?s.v_compute(t):n.v_compute(t)}const h=c(t,this.model.xs_units,o,n.bbox.xview),r=c(i,this.model.ys_units,l,n.bbox.yview);e.beginPath();for(let t=0;t({xs:[i(t),[]],xs_units:[c.SpatialUnits,\"data\"],ys:[i(t),[]],ys_units:[c.SpatialUnits,\"data\"]}))),this.internal((({Boolean:t})=>({screen:[t,!1]}))),this.override({fill_color:\"#fff9ba\",fill_alpha:.4,line_color:\"#cccccc\",line_alpha:.3})}update({xs:t,ys:i}){this.setv({xs:t,ys:i,screen:!0},{check_eq:!1})}}s.PolyAnnotation=r,r.__name__=\"PolyAnnotation\",r.init_PolyAnnotation()},\n", + " function _(e,t,i,n,o){n();const s=e(1),l=e(40),r=s.__importStar(e(48));class c extends l.AnnotationView{connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.request_render()))}_render(){const{gradient:e,y_intercept:t}=this.model;if(null==e||null==t)return;const{frame:i}=this.plot_view,n=this.coordinates.x_scale,o=this.coordinates.y_scale;let s,l,r,c;if(0==e)s=o.compute(t),l=s,r=i.bbox.left,c=r+i.bbox.width;else{s=i.bbox.top,l=s+i.bbox.height;const a=(o.invert(s)-t)/e,_=(o.invert(l)-t)/e;r=n.compute(a),c=n.compute(_)}const{ctx:a}=this.layer;a.save(),a.beginPath(),this.visuals.line.set_value(a),a.moveTo(r,s),a.lineTo(c,l),a.stroke(),a.restore()}}i.SlopeView=c,c.__name__=\"SlopeView\";class a extends l.Annotation{constructor(e){super(e)}static init_Slope(){this.prototype.default_view=c,this.mixins(r.Line),this.define((({Number:e,Nullable:t})=>({gradient:[t(e),null],y_intercept:[t(e),null]}))),this.override({line_color:\"black\"})}}i.Slope=a,a.__name__=\"Slope\",a.init_Slope()},\n", + " function _(e,i,t,n,o){n();const s=e(1),a=e(40),l=s.__importStar(e(48)),h=e(20);class c extends a.AnnotationView{connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.plot_view.request_paint(this)))}_render(){const{location:e}=this.model;if(null==e)return;const{frame:i}=this.plot_view,t=this.coordinates.x_scale,n=this.coordinates.y_scale,o=(i,t)=>\"data\"==this.model.location_units?i.compute(e):this.model.for_hover?e:t.compute(e);let s,a,l,h;\"width\"==this.model.dimension?(l=o(n,i.bbox.yview),a=i.bbox.left,h=i.bbox.width,s=this.model.line_width):(l=i.bbox.top,a=o(t,i.bbox.xview),h=this.model.line_width,s=i.bbox.height);const{ctx:c}=this.layer;c.save(),c.beginPath(),this.visuals.line.set_value(c),c.moveTo(a,l),\"width\"==this.model.dimension?c.lineTo(a+h,l):c.lineTo(a,l+s),c.stroke(),c.restore()}}t.SpanView=c,c.__name__=\"SpanView\";class d extends a.Annotation{constructor(e){super(e)}static init_Span(){this.prototype.default_view=c,this.mixins(l.Line),this.define((({Number:e,Nullable:i})=>({render_mode:[h.RenderMode,\"canvas\"],location:[i(e),null],location_units:[h.SpatialUnits,\"data\"],dimension:[h.Dimension,\"width\"]}))),this.internal((({Boolean:e})=>({for_hover:[e,!1]}))),this.override({line_color:\"black\"})}}t.Span=d,d.__name__=\"Span\",d.init_Span()},\n", + " function _(i,e,t,o,l){o();const s=i(40),a=i(235),n=i(122),r=i(43),_=i(140),h=i(99);class b extends s.AnnotationView{constructor(){super(...arguments),this._invalidate_toolbar=!0,this._previous_bbox=new h.BBox}update_layout(){this.layout=new _.SideLayout(this.panel,(()=>this.get_size()),!0)}initialize(){super.initialize(),this.el=r.div(),this.plot_view.canvas_view.add_event(this.el)}async lazy_initialize(){await super.lazy_initialize(),this._toolbar_view=await n.build_view(this.model.toolbar,{parent:this}),this.plot_view.visibility_callbacks.push((i=>this._toolbar_view.set_visibility(i)))}remove(){this._toolbar_view.remove(),r.remove(this.el),super.remove()}render(){this.model.visible||r.undisplay(this.el),super.render()}_render(){const{bbox:i}=this.layout;this._previous_bbox.equals(i)||(r.position(this.el,i),this._previous_bbox=i),this._invalidate_toolbar&&(this.el.style.position=\"absolute\",this.el.style.overflow=\"hidden\",this._toolbar_view.render(),r.empty(this.el),this.el.appendChild(this._toolbar_view.el),this._invalidate_toolbar=!1),r.display(this.el)}_get_size(){const{tools:i,logo:e}=this.model.toolbar;return{width:30*i.length+(null!=e?25:0),height:30}}}t.ToolbarPanelView=b,b.__name__=\"ToolbarPanelView\";class d extends s.Annotation{constructor(i){super(i)}static init_ToolbarPanel(){this.prototype.default_view=b,this.define((({Ref:i})=>({toolbar:[i(a.Toolbar)]})))}}t.ToolbarPanel=d,d.__name__=\"ToolbarPanel\",d.init_ToolbarPanel()},\n", + " function _(t,s,e,i,o){i();const c=t(8),n=t(9),a=t(13),l=t(236),r=t(237),_=t(247),p=t(248);e.Drag=l.Tool,e.Inspection=l.Tool,e.Scroll=l.Tool,e.Tap=l.Tool;const u=t=>{switch(t){case\"tap\":return\"active_tap\";case\"pan\":return\"active_drag\";case\"pinch\":case\"scroll\":return\"active_scroll\";case\"multi\":return\"active_multi\"}return null},h=t=>\"tap\"==t||\"pan\"==t;class v extends p.ToolbarBase{constructor(t){super(t)}static init_Toolbar(){this.prototype.default_view=p.ToolbarBaseView,this.define((({Or:t,Ref:s,Auto:i,Null:o,Nullable:c})=>({active_drag:[t(s(e.Drag),i,o),\"auto\"],active_inspect:[t(s(e.Inspection),i,o),\"auto\"],active_scroll:[t(s(e.Scroll),i,o),\"auto\"],active_tap:[t(s(e.Tap),i,o),\"auto\"],active_multi:[c(s(r.GestureTool)),null]})))}connect_signals(){super.connect_signals();const{tools:t,active_drag:s,active_inspect:e,active_scroll:i,active_tap:o,active_multi:c}=this.properties;this.on_change([t,s,e,i,o,c],(()=>this._init_tools()))}_init_tools(){if(super._init_tools(),\"auto\"==this.active_inspect);else if(this.active_inspect instanceof _.InspectTool){let t=!1;for(const s of this.inspectors)s!=this.active_inspect?s.active=!1:t=!0;t||(this.active_inspect=null)}else if(c.isArray(this.active_inspect)){const t=n.intersection(this.active_inspect,this.inspectors);t.length!=this.active_inspect.length&&(this.active_inspect=t);for(const t of this.inspectors)n.includes(this.active_inspect,t)||(t.active=!1)}else if(null==this.active_inspect)for(const t of this.inspectors)t.active=!1;const t=t=>{t.active?this._active_change(t):t.active=!0};for(const t of a.values(this.gestures)){t.tools=n.sort_by(t.tools,(t=>t.default_order));for(const s of t.tools)this.connect(s.properties.active.change,(()=>this._active_change(s)))}for(const[s,e]of a.entries(this.gestures)){const i=u(s);if(i){const o=this[i];\"auto\"==o?0!=e.tools.length&&h(s)&&t(e.tools[0]):null!=o&&(n.includes(this.tools,o)?t(o):this[i]=null)}}}}e.Toolbar=v,v.__name__=\"Toolbar\",v.init_Toolbar()},\n", + " function _(t,e,n,i,o){i();const s=t(42),a=t(9),r=t(53);class l extends s.View{get plot_view(){return this.parent}get plot_model(){return this.parent.model}connect_signals(){super.connect_signals(),this.connect(this.model.properties.active.change,(()=>{this.model.active?this.activate():this.deactivate()}))}activate(){}deactivate(){}}n.ToolView=l,l.__name__=\"ToolView\";class _ extends r.Model{constructor(t){super(t)}static init_Tool(){this.prototype._known_aliases=new Map,this.define((({String:t,Nullable:e})=>({description:[e(t),null]}))),this.internal((({Boolean:t})=>({active:[t,!1]})))}get synthetic_renderers(){return[]}_get_dim_limits([t,e],[n,i],o,s){const r=o.bbox.h_range;let l;\"width\"==s||\"both\"==s?(l=[a.min([t,n]),a.max([t,n])],l=[a.max([l[0],r.start]),a.min([l[1],r.end])]):l=[r.start,r.end];const _=o.bbox.v_range;let c;return\"height\"==s||\"both\"==s?(c=[a.min([e,i]),a.max([e,i])],c=[a.max([c[0],_.start]),a.min([c[1],_.end])]):c=[_.start,_.end],[l,c]}static register_alias(t,e){this.prototype._known_aliases.set(t,e)}static from_string(t){const e=this.prototype._known_aliases.get(t);if(null!=e)return e();{const e=[...this.prototype._known_aliases.keys()];throw new Error(`unexpected tool name '${t}', possible tools are ${e.join(\", \")}`)}}}n.Tool=_,_.__name__=\"Tool\",_.init_Tool()},\n", + " function _(e,o,t,s,n){s();const u=e(238),_=e(246);class l extends u.ButtonToolView{}t.GestureToolView=l,l.__name__=\"GestureToolView\";class i extends u.ButtonTool{constructor(e){super(e),this.button_view=_.OnOffButtonView}}t.GestureTool=i,i.__name__=\"GestureTool\"},\n", + " function _(t,e,o,i,s){i();const n=t(1),l=n.__importDefault(t(239)),r=t(240),a=t(236),u=t(43),h=t(34),_=t(8),c=t(9),d=n.__importStar(t(241)),m=d,p=n.__importDefault(t(242)),g=n.__importDefault(t(243)),v=t(244);class f extends r.DOMView{initialize(){super.initialize();const t=this.model.menu;if(null!=t){const e=this.parent.model.toolbar_location,o=\"left\"==e||\"above\"==e,i=this.parent.model.horizontal?\"vertical\":\"horizontal\";this._menu=new v.ContextMenu(o?c.reversed(t):t,{orientation:i,prevent_hide:t=>t.target==this.el})}this._hammer=new l.default(this.el,{touchAction:\"auto\",inputClass:l.default.TouchMouseInput}),this.connect(this.model.change,(()=>this.render())),this._hammer.on(\"tap\",(t=>{var e;(null===(e=this._menu)||void 0===e?void 0:e.is_open)?this._menu.hide():t.target==this.el&&this._clicked()})),this._hammer.on(\"press\",(()=>this._pressed()))}remove(){var t;this._hammer.destroy(),null===(t=this._menu)||void 0===t||t.remove(),super.remove()}styles(){return[...super.styles(),d.default,p.default,g.default]}css_classes(){return super.css_classes().concat(m.toolbar_button)}render(){u.empty(this.el);const t=this.model.computed_icon;_.isString(t)&&(h.startsWith(t,\"data:image\")?this.el.style.backgroundImage=\"url('\"+t+\"')\":this.el.classList.add(t)),this.el.title=this.model.tooltip,null!=this._menu&&this.root.el.appendChild(this._menu.el)}_pressed(){var t;const{left:e,top:o,right:i,bottom:s}=this.el.getBoundingClientRect(),n=(()=>{switch(this.parent.model.toolbar_location){case\"right\":return{right:e,top:o};case\"left\":return{left:i,top:o};case\"above\":return{left:e,top:s};case\"below\":return{left:e,bottom:o}}})();null===(t=this._menu)||void 0===t||t.toggle(n)}}o.ButtonToolButtonView=f,f.__name__=\"ButtonToolButtonView\";class b extends a.ToolView{}o.ButtonToolView=b,b.__name__=\"ButtonToolView\";class B extends a.Tool{constructor(t){super(t)}static init_ButtonTool(){this.internal((({Boolean:t})=>({disabled:[t,!1]})))}_get_dim_tooltip(t){const{description:e,tool_name:o}=this;return null!=e?e:\"both\"==t?o:`${o} (${\"width\"==t?\"x\":\"y\"}-axis)`}get tooltip(){var t;return null!==(t=this.description)&&void 0!==t?t:this.tool_name}get computed_icon(){return this.icon}get menu(){return null}}o.ButtonTool=B,B.__name__=\"ButtonTool\",B.init_ButtonTool()},\n", + " function _(t,e,i,n,r){\n", + " /*! Hammer.JS - v2.0.7 - 2016-04-22\n", + " * http://hammerjs.github.io/\n", + " *\n", + " * Copyright (c) 2016 Jorik Tangelder;\n", + " * Licensed under the MIT license */\n", + " !function(t,i,n,r){\"use strict\";var s,o=[\"\",\"webkit\",\"Moz\",\"MS\",\"ms\",\"o\"],a=i.createElement(\"div\"),h=Math.round,u=Math.abs,c=Date.now;function l(t,e,i){return setTimeout(T(t,i),e)}function p(t,e,i){return!!Array.isArray(t)&&(f(t,i[e],i),!0)}function f(t,e,i){var n;if(t)if(t.forEach)t.forEach(e,i);else if(t.length!==r)for(n=0;n\\s*\\(/gm,\"{anonymous}()@\"):\"Unknown Stack Trace\",s=t.console&&(t.console.warn||t.console.log);return s&&s.call(t.console,r,n),e.apply(this,arguments)}}s=\"function\"!=typeof Object.assign?function(t){if(t===r||null===t)throw new TypeError(\"Cannot convert undefined or null to object\");for(var e=Object(t),i=1;i-1}function S(t){return t.trim().split(/\\s+/g)}function b(t,e,i){if(t.indexOf&&!i)return t.indexOf(e);for(var n=0;ni[e]})):n.sort()),n}function x(t,e){for(var i,n,s=e[0].toUpperCase()+e.slice(1),a=0;a1&&!i.firstMultiple?i.firstMultiple=H(e):1===s&&(i.firstMultiple=!1);var o=i.firstInput,a=i.firstMultiple,h=a?a.center:o.center,l=e.center=L(n);e.timeStamp=c(),e.deltaTime=e.timeStamp-o.timeStamp,e.angle=G(h,l),e.distance=j(h,l),function(t,e){var i=e.center,n=t.offsetDelta||{},r=t.prevDelta||{},s=t.prevInput||{};1!==e.eventType&&4!==s.eventType||(r=t.prevDelta={x:s.deltaX||0,y:s.deltaY||0},n=t.offsetDelta={x:i.x,y:i.y});e.deltaX=r.x+(i.x-n.x),e.deltaY=r.y+(i.y-n.y)}(i,e),e.offsetDirection=V(e.deltaX,e.deltaY);var p=U(e.deltaTime,e.deltaX,e.deltaY);e.overallVelocityX=p.x,e.overallVelocityY=p.y,e.overallVelocity=u(p.x)>u(p.y)?p.x:p.y,e.scale=a?(f=a.pointers,v=n,j(v[0],v[1],W)/j(f[0],f[1],W)):1,e.rotation=a?function(t,e){return G(e[1],e[0],W)+G(t[1],t[0],W)}(a.pointers,n):0,e.maxPointers=i.prevInput?e.pointers.length>i.prevInput.maxPointers?e.pointers.length:i.prevInput.maxPointers:e.pointers.length,function(t,e){var i,n,s,o,a=t.lastInterval||e,h=e.timeStamp-a.timeStamp;if(8!=e.eventType&&(h>25||a.velocity===r)){var c=e.deltaX-a.deltaX,l=e.deltaY-a.deltaY,p=U(h,c,l);n=p.x,s=p.y,i=u(p.x)>u(p.y)?p.x:p.y,o=V(c,l),t.lastInterval=e}else i=a.velocity,n=a.velocityX,s=a.velocityY,o=a.direction;e.velocity=i,e.velocityX=n,e.velocityY=s,e.direction=o}(i,e);var f,v;var d=t.element;_(e.srcEvent.target,d)&&(d=e.srcEvent.target);e.target=d}(t,i),t.emit(\"hammer.input\",i),t.recognize(i),t.session.prevInput=i}function H(t){for(var e=[],i=0;i=u(e)?t<0?2:4:e<0?8:16}function j(t,e,i){i||(i=F);var n=e[i[0]]-t[i[0]],r=e[i[1]]-t[i[1]];return Math.sqrt(n*n+r*r)}function G(t,e,i){i||(i=F);var n=e[i[0]]-t[i[0]],r=e[i[1]]-t[i[1]];return 180*Math.atan2(r,n)/Math.PI}q.prototype={handler:function(){},init:function(){this.evEl&&I(this.element,this.evEl,this.domHandler),this.evTarget&&I(this.target,this.evTarget,this.domHandler),this.evWin&&I(O(this.element),this.evWin,this.domHandler)},destroy:function(){this.evEl&&A(this.element,this.evEl,this.domHandler),this.evTarget&&A(this.target,this.evTarget,this.domHandler),this.evWin&&A(O(this.element),this.evWin,this.domHandler)}};var Z={mousedown:1,mousemove:2,mouseup:4},B=\"mousedown\",$=\"mousemove mouseup\";function J(){this.evEl=B,this.evWin=$,this.pressed=!1,q.apply(this,arguments)}g(J,q,{handler:function(t){var e=Z[t.type];1&e&&0===t.button&&(this.pressed=!0),2&e&&1!==t.which&&(e=4),this.pressed&&(4&e&&(this.pressed=!1),this.callback(this.manager,e,{pointers:[t],changedPointers:[t],pointerType:X,srcEvent:t}))}});var K={pointerdown:1,pointermove:2,pointerup:4,pointercancel:8,pointerout:8},Q={2:N,3:\"pen\",4:X,5:\"kinect\"},tt=\"pointerdown\",et=\"pointermove pointerup pointercancel\";function it(){this.evEl=tt,this.evWin=et,q.apply(this,arguments),this.store=this.manager.session.pointerEvents=[]}t.MSPointerEvent&&!t.PointerEvent&&(tt=\"MSPointerDown\",et=\"MSPointerMove MSPointerUp MSPointerCancel\"),g(it,q,{handler:function(t){var e=this.store,i=!1,n=t.type.toLowerCase().replace(\"ms\",\"\"),r=K[n],s=Q[t.pointerType]||t.pointerType,o=s==N,a=b(e,t.pointerId,\"pointerId\");1&r&&(0===t.button||o)?a<0&&(e.push(t),a=e.length-1):12&r&&(i=!0),a<0||(e[a]=t,this.callback(this.manager,r,{pointers:e,changedPointers:[t],pointerType:s,srcEvent:t}),i&&e.splice(a,1))}});var nt={touchstart:1,touchmove:2,touchend:4,touchcancel:8},rt=\"touchstart\",st=\"touchstart touchmove touchend touchcancel\";function ot(){this.evTarget=rt,this.evWin=st,this.started=!1,q.apply(this,arguments)}function at(t,e){var i=P(t.touches),n=P(t.changedTouches);return 12&e&&(i=D(i.concat(n),\"identifier\",!0)),[i,n]}g(ot,q,{handler:function(t){var e=nt[t.type];if(1===e&&(this.started=!0),this.started){var i=at.call(this,t,e);12&e&&i[0].length-i[1].length==0&&(this.started=!1),this.callback(this.manager,e,{pointers:i[0],changedPointers:i[1],pointerType:N,srcEvent:t})}}});var ht={touchstart:1,touchmove:2,touchend:4,touchcancel:8},ut=\"touchstart touchmove touchend touchcancel\";function ct(){this.evTarget=ut,this.targetIds={},q.apply(this,arguments)}function lt(t,e){var i=P(t.touches),n=this.targetIds;if(3&e&&1===i.length)return n[i[0].identifier]=!0,[i,i];var r,s,o=P(t.changedTouches),a=[],h=this.target;if(s=i.filter((function(t){return _(t.target,h)})),1===e)for(r=0;r-1&&n.splice(t,1)}),2500)}}function dt(t){for(var e=t.srcEvent.clientX,i=t.srcEvent.clientY,n=0;n-1&&this.requireFail.splice(e,1),this},hasRequireFailures:function(){return this.requireFail.length>0},canRecognizeWith:function(t){return!!this.simultaneous[t.id]},emit:function(t){var e=this,i=this.state;function n(i){e.manager.emit(i,t)}i<8&&n(e.options.event+Dt(i)),n(e.options.event),t.additionalEvent&&n(t.additionalEvent),i>=8&&n(e.options.event+Dt(i))},tryEmit:function(t){if(this.canEmit())return this.emit(t);this.state=bt},canEmit:function(){for(var t=0;te.threshold&&r&e.direction},attrTest:function(t){return Ot.prototype.attrTest.call(this,t)&&(2&this.state||!(2&this.state)&&this.directionTest(t))},emit:function(t){this.pX=t.deltaX,this.pY=t.deltaY;var e=xt(t.direction);e&&(t.additionalEvent=this.options.event+e),this._super.emit.call(this,t)}}),g(Mt,Ot,{defaults:{event:\"pinch\",threshold:0,pointers:2},getTouchAction:function(){return[It]},attrTest:function(t){return this._super.attrTest.call(this,t)&&(Math.abs(t.scale-1)>this.options.threshold||2&this.state)},emit:function(t){if(1!==t.scale){var e=t.scale<1?\"in\":\"out\";t.additionalEvent=this.options.event+e}this._super.emit.call(this,t)}}),g(zt,Pt,{defaults:{event:\"press\",pointers:1,time:251,threshold:9},getTouchAction:function(){return[yt]},process:function(t){var e=this.options,i=t.pointers.length===e.pointers,n=t.distancee.time;if(this._input=t,!n||!i||12&t.eventType&&!r)this.reset();else if(1&t.eventType)this.reset(),this._timer=l((function(){this.state=8,this.tryEmit()}),e.time,this);else if(4&t.eventType)return 8;return bt},reset:function(){clearTimeout(this._timer)},emit:function(t){8===this.state&&(t&&4&t.eventType?this.manager.emit(this.options.event+\"up\",t):(this._input.timeStamp=c(),this.manager.emit(this.options.event,this._input)))}}),g(Nt,Ot,{defaults:{event:\"rotate\",threshold:0,pointers:2},getTouchAction:function(){return[It]},attrTest:function(t){return this._super.attrTest.call(this,t)&&(Math.abs(t.rotation)>this.options.threshold||2&this.state)}}),g(Xt,Ot,{defaults:{event:\"swipe\",threshold:10,velocity:.3,direction:30,pointers:1},getTouchAction:function(){return Rt.prototype.getTouchAction.call(this)},attrTest:function(t){var e,i=this.options.direction;return 30&i?e=t.overallVelocity:6&i?e=t.overallVelocityX:i&Y&&(e=t.overallVelocityY),this._super.attrTest.call(this,t)&&i&t.offsetDirection&&t.distance>this.options.threshold&&t.maxPointers==this.options.pointers&&u(e)>this.options.velocity&&4&t.eventType},emit:function(t){var e=xt(t.offsetDirection);e&&this.manager.emit(this.options.event+e,t),this.manager.emit(this.options.event,t)}}),g(Yt,Pt,{defaults:{event:\"tap\",pointers:1,taps:1,interval:300,time:250,threshold:9,posThreshold:10},getTouchAction:function(){return[Et]},process:function(t){var e=this.options,i=t.pointers.length===e.pointers,n=t.distance .bk-divider{cursor:default;overflow:hidden;background-color:#e5e5e5;}.bk-root .bk-context-menu.bk-horizontal > .bk-divider{width:1px;margin:5px 0;}.bk-root .bk-context-menu.bk-vertical > .bk-divider{height:1px;margin:0 5px;}.bk-root .bk-context-menu > :not(.bk-divider){border:1px solid transparent;}.bk-root .bk-context-menu > :not(.bk-divider).bk-active{border-color:#26aae1;}.bk-root .bk-context-menu > :not(.bk-divider):hover{background-color:#f9f9f9;}.bk-root .bk-context-menu.bk-horizontal > :not(.bk-divider):first-child{border-top-left-radius:4px;border-bottom-left-radius:4px;}.bk-root .bk-context-menu.bk-horizontal > :not(.bk-divider):last-child{border-top-right-radius:4px;border-bottom-right-radius:4px;}.bk-root .bk-context-menu.bk-vertical > :not(.bk-divider):first-child{border-top-left-radius:4px;border-top-right-radius:4px;}.bk-root .bk-context-menu.bk-vertical > :not(.bk-divider):last-child{border-bottom-left-radius:4px;border-bottom-right-radius:4px;}.bk-root .bk-menu{position:absolute;left:0;width:100%;z-index:100;cursor:pointer;font-size:12px;background-color:#fff;border:1px solid #ccc;border-radius:4px;box-shadow:0 6px 12px rgba(0, 0, 0, 0.175);}.bk-root .bk-menu.bk-above{bottom:100%;}.bk-root .bk-menu.bk-below{top:100%;}.bk-root .bk-menu > .bk-divider{height:1px;margin:7.5px 0;overflow:hidden;background-color:#e5e5e5;}.bk-root .bk-menu > :not(.bk-divider){padding:6px 12px;}.bk-root .bk-menu > :not(.bk-divider):hover,.bk-root .bk-menu > :not(.bk-divider).bk-active{background-color:#e6e6e6;}.bk-root .bk-caret{display:inline-block;vertical-align:middle;width:0;height:0;margin:0 5px;}.bk-root .bk-caret.bk-down{border-top:4px solid;}.bk-root .bk-caret.bk-up{border-bottom:4px solid;}.bk-root .bk-caret.bk-down,.bk-root .bk-caret.bk-up{border-right:4px solid transparent;border-left:4px solid transparent;}.bk-root .bk-caret.bk-left{border-right:4px solid;}.bk-root .bk-caret.bk-right{border-left:4px solid;}.bk-root .bk-caret.bk-left,.bk-root .bk-caret.bk-right{border-top:4px solid transparent;border-bottom:4px solid transparent;}\"},\n", + " function _(t,e,i,n,s){n();const o=t(1),l=t(43),h=t(245),d=o.__importStar(t(243));class r{constructor(t,e={}){this.items=t,this.options=e,this.el=l.div(),this._open=!1,this._item_click=t=>{var e;null===(e=this.items[t])||void 0===e||e.handler(),this.hide()},this._on_mousedown=t=>{var e,i;const{target:n}=t;n instanceof Node&&this.el.contains(n)||(null===(i=(e=this.options).prevent_hide)||void 0===i?void 0:i.call(e,t))||this.hide()},this._on_keydown=t=>{t.keyCode==l.Keys.Esc&&this.hide()},this._on_blur=()=>{this.hide()},l.undisplay(this.el)}get is_open(){return this._open}get can_open(){return 0!=this.items.length}remove(){l.remove(this.el),this._unlisten()}_listen(){document.addEventListener(\"mousedown\",this._on_mousedown),document.addEventListener(\"keydown\",this._on_keydown),window.addEventListener(\"blur\",this._on_blur)}_unlisten(){document.removeEventListener(\"mousedown\",this._on_mousedown),document.removeEventListener(\"keydown\",this._on_keydown),window.removeEventListener(\"blur\",this._on_blur)}_position(t){const e=this.el.parentElement;if(null!=e){const i=e.getBoundingClientRect();this.el.style.left=null!=t.left?t.left-i.left+\"px\":\"\",this.el.style.top=null!=t.top?t.top-i.top+\"px\":\"\",this.el.style.right=null!=t.right?i.right-t.right+\"px\":\"\",this.el.style.bottom=null!=t.bottom?i.bottom-t.bottom+\"px\":\"\"}}render(){var t,e;l.empty(this.el,!0);const i=null!==(t=this.options.orientation)&&void 0!==t?t:\"vertical\";l.classes(this.el).add(\"bk-context-menu\",`bk-${i}`);for(const[t,i]of h.enumerate(this.items)){let n;if(null==t)n=l.div({class:d.divider});else{if(null!=t.if&&!t.if())continue;{const i=null!=t.icon?l.div({class:[\"bk-menu-icon\",t.icon]}):null;n=l.div({class:(null===(e=t.active)||void 0===e?void 0:e.call(t))?\"bk-active\":null,title:t.tooltip},i,t.label)}}n.addEventListener(\"click\",(()=>this._item_click(i))),this.el.appendChild(n)}}show(t){if(0!=this.items.length&&!this._open){if(this.render(),0==this.el.children.length)return;this._position(null!=t?t:{left:0,top:0}),l.display(this.el),this._listen(),this._open=!0}}hide(){this._open&&(this._open=!1,this._unlisten(),l.undisplay(this.el))}toggle(t){this._open?this.hide():this.show(t)}}i.ContextMenu=r,r.__name__=\"ContextMenu\"},\n", + " function _(n,e,o,t,r){t();const f=n(9);function*i(n,e){const o=n.length;if(e>o)return;const t=f.range(e);for(yield t.map((e=>n[e]));;){let r;for(const n of f.reversed(f.range(e)))if(t[n]!=n+o-e){r=n;break}if(null==r)return;t[r]+=1;for(const n of f.range(r+1,e))t[n]=t[n-1]+1;yield t.map((e=>n[e]))}}o.enumerate=function*(n){let e=0;for(const o of n)yield[o,e++]},o.combinations=i,o.subsets=function*(n){for(const e of f.range(n.length+1))yield*i(n,e)}},\n", + " function _(t,e,i,n,o){n();const s=t(1),c=t(238),l=s.__importStar(t(241)),a=t(43);class _ extends c.ButtonToolButtonView{render(){super.render(),a.classes(this.el).toggle(l.active,this.model.active)}_clicked(){const{active:t}=this.model;this.model.active=!t}}i.OnOffButtonView=_,_.__name__=\"OnOffButtonView\"},\n", + " function _(t,e,o,n,s){n();const i=t(238),c=t(246);class l extends i.ButtonToolView{}o.InspectToolView=l,l.__name__=\"InspectToolView\";class _ extends i.ButtonTool{constructor(t){super(t),this.event_type=\"move\"}static init_InspectTool(){this.prototype.button_view=c.OnOffButtonView,this.define((({Boolean:t})=>({toggleable:[t,!0]}))),this.override({active:!0})}}o.InspectTool=_,_.__name__=\"InspectTool\",_.init_InspectTool()},\n", + " function _(t,o,e,i,s){i();const l=t(1),n=t(19),a=t(43),r=t(122),c=t(240),_=t(20),u=t(9),h=t(13),v=t(8),p=t(249),d=t(99),b=t(53),g=t(236),f=t(237),m=t(251),w=t(252),y=t(247),T=l.__importStar(t(241)),z=T,B=l.__importStar(t(253)),x=B;class L extends b.Model{constructor(t){super(t)}static init_ToolbarViewModel(){this.define((({Boolean:t,Nullable:o})=>({_visible:[o(t),null],autohide:[t,!1]})))}get visible(){return!this.autohide||null!=this._visible&&this._visible}}e.ToolbarViewModel=L,L.__name__=\"ToolbarViewModel\",L.init_ToolbarViewModel();class M extends c.DOMView{constructor(){super(...arguments),this.layout={bbox:new d.BBox}}initialize(){super.initialize(),this._tool_button_views=new Map,this._toolbar_view_model=new L({autohide:this.model.autohide})}async lazy_initialize(){await super.lazy_initialize(),await this._build_tool_button_views()}connect_signals(){super.connect_signals(),this.connect(this.model.properties.tools.change,(async()=>{await this._build_tool_button_views(),this.render()})),this.connect(this.model.properties.autohide.change,(()=>{this._toolbar_view_model.autohide=this.model.autohide,this._on_visible_change()})),this.connect(this._toolbar_view_model.properties._visible.change,(()=>this._on_visible_change()))}styles(){return[...super.styles(),T.default,B.default]}remove(){r.remove_views(this._tool_button_views),super.remove()}async _build_tool_button_views(){const t=null!=this.model._proxied_tools?this.model._proxied_tools:this.model.tools;await r.build_views(this._tool_button_views,t,{parent:this},(t=>t.button_view))}set_visibility(t){t!=this._toolbar_view_model._visible&&(this._toolbar_view_model._visible=t)}_on_visible_change(){const t=this._toolbar_view_model.visible,o=z.toolbar_hidden;this.el.classList.contains(o)&&t?this.el.classList.remove(o):t||this.el.classList.add(o)}render(){if(a.empty(this.el),this.el.classList.add(z.toolbar),this.el.classList.add(z[this.model.toolbar_location]),this._toolbar_view_model.autohide=this.model.autohide,this._on_visible_change(),null!=this.model.logo){const t=\"grey\"===this.model.logo?x.grey:null,o=a.a({href:\"https://bokeh.org/\",target:\"_blank\",class:[x.logo,x.logo_small,t]});this.el.appendChild(o)}for(const[,t]of this._tool_button_views)t.render();const t=[],o=t=>this._tool_button_views.get(t).el,{gestures:e}=this.model;for(const i of h.values(e))t.push(i.tools.map(o));t.push(this.model.actions.map(o)),t.push(this.model.inspectors.filter((t=>t.toggleable)).map(o));for(const o of t)if(0!==o.length){const t=a.div({class:z.button_bar},o);this.el.appendChild(t)}}update_layout(){}update_position(){}after_layout(){this._has_finished=!0}export(t,o=!0){const e=\"png\"==t?\"canvas\":\"svg\",i=new p.CanvasLayer(e,o);return i.resize(0,0),i}}function V(){return{pan:{tools:[],active:null},scroll:{tools:[],active:null},pinch:{tools:[],active:null},tap:{tools:[],active:null},doubletap:{tools:[],active:null},press:{tools:[],active:null},pressup:{tools:[],active:null},rotate:{tools:[],active:null},move:{tools:[],active:null},multi:{tools:[],active:null}}}e.ToolbarBaseView=M,M.__name__=\"ToolbarBaseView\";class S extends b.Model{constructor(t){super(t)}static init_ToolbarBase(){this.prototype.default_view=M,this.define((({Boolean:t,Array:o,Ref:e,Nullable:i})=>({tools:[o(e(g.Tool)),[]],logo:[i(_.Logo),\"normal\"],autohide:[t,!1]}))),this.internal((({Array:t,Struct:o,Ref:e,Nullable:i})=>{const s=o({tools:t(e(f.GestureTool)),active:i(e(g.Tool))});return{gestures:[o({pan:s,scroll:s,pinch:s,tap:s,doubletap:s,press:s,pressup:s,rotate:s,move:s,multi:s}),V],actions:[t(e(m.ActionTool)),[]],inspectors:[t(e(y.InspectTool)),[]],help:[t(e(w.HelpTool)),[]],toolbar_location:[_.Location,\"right\"]}}))}initialize(){super.initialize(),this._init_tools()}_init_tools(){const t=function(t,o){if(t.length!=o.length)return!0;const e=new Set(o.map((t=>t.id)));return u.some(t,(t=>!e.has(t.id)))},o=this.tools.filter((t=>t instanceof y.InspectTool));t(this.inspectors,o)&&(this.inspectors=o);const e=this.tools.filter((t=>t instanceof w.HelpTool));t(this.help,e)&&(this.help=e);const i=this.tools.filter((t=>t instanceof m.ActionTool));t(this.actions,i)&&(this.actions=i);const s=(t,o)=>{t in this.gestures||n.logger.warn(`Toolbar: unknown event type '${t}' for tool: ${o}`)},l={pan:{tools:[],active:null},scroll:{tools:[],active:null},pinch:{tools:[],active:null},tap:{tools:[],active:null},doubletap:{tools:[],active:null},press:{tools:[],active:null},pressup:{tools:[],active:null},rotate:{tools:[],active:null},move:{tools:[],active:null},multi:{tools:[],active:null}};for(const t of this.tools)if(t instanceof f.GestureTool&&t.event_type)if(v.isString(t.event_type))l[t.event_type].tools.push(t),s(t.event_type,t);else{l.multi.tools.push(t);for(const o of t.event_type)s(o,t)}for(const o of Object.keys(l)){const e=this.gestures[o];t(e.tools,l[o].tools)&&(e.tools=l[o].tools),e.active&&u.every(e.tools,(t=>t.id!=e.active.id))&&(e.active=null)}}get horizontal(){return\"above\"===this.toolbar_location||\"below\"===this.toolbar_location}get vertical(){return\"left\"===this.toolbar_location||\"right\"===this.toolbar_location}_active_change(t){const{event_type:o}=t;if(null==o)return;const e=v.isString(o)?[o]:o;for(const o of e)if(t.active){const e=this.gestures[o].active;null!=e&&t!=e&&(n.logger.debug(`Toolbar: deactivating tool: ${e} for event type '${o}'`),e.active=!1),this.gestures[o].active=t,n.logger.debug(`Toolbar: activating tool: ${t} for event type '${o}'`)}else this.gestures[o].active=null}}e.ToolbarBase=S,S.__name__=\"ToolbarBase\",S.init_ToolbarBase()},\n", + " function _(e,t,i,n,s){n();const o=e(250),a=e(99),r=e(43);function h(e){!function(e){void 0===e.lineDash&&Object.defineProperty(e,\"lineDash\",{get:()=>e.getLineDash(),set:t=>e.setLineDash(t)})}(e),function(e){e.setImageSmoothingEnabled=t=>{e.imageSmoothingEnabled=t,e.mozImageSmoothingEnabled=t,e.oImageSmoothingEnabled=t,e.webkitImageSmoothingEnabled=t,e.msImageSmoothingEnabled=t},e.getImageSmoothingEnabled=()=>{const t=e.imageSmoothingEnabled;return null==t||t}}(e),function(e){e.ellipse||(e.ellipse=function(t,i,n,s,o,a,r,h=!1){const l=.551784;e.translate(t,i),e.rotate(o);let c=n,g=s;h&&(c=-n,g=-s),e.moveTo(-c,0),e.bezierCurveTo(-c,g*l,-c*l,g,0,g),e.bezierCurveTo(c*l,g,c,g*l,c,0),e.bezierCurveTo(c,-g*l,c*l,-g,0,-g),e.bezierCurveTo(-c*l,-g,-c,-g*l,-c,0),e.rotate(-o),e.translate(-t,-i)})}(e)}const l={position:\"absolute\",top:\"0\",left:\"0\",width:\"100%\",height:\"100%\"};class c{constructor(e,t){switch(this.backend=e,this.hidpi=t,this.pixel_ratio=1,this.bbox=new a.BBox,e){case\"webgl\":case\"canvas\":{this._el=this._canvas=r.canvas({style:l});const e=this.canvas.getContext(\"2d\");if(null==e)throw new Error(\"unable to obtain 2D rendering context\");this._ctx=e,t&&(this.pixel_ratio=devicePixelRatio);break}case\"svg\":{const e=new o.SVGRenderingContext2D;this._ctx=e,this._canvas=e.get_svg(),this._el=r.div({style:l},this._canvas);break}}h(this._ctx)}get canvas(){return this._canvas}get ctx(){return this._ctx}get el(){return this._el}resize(e,t){this.bbox=new a.BBox({left:0,top:0,width:e,height:t});const i=this._ctx instanceof o.SVGRenderingContext2D?this._ctx:this.canvas;i.width=e*this.pixel_ratio,i.height=t*this.pixel_ratio}prepare(){const{ctx:e,hidpi:t,pixel_ratio:i}=this;e.save(),t&&(e.scale(i,i),e.translate(.5,.5)),this.clear()}clear(){const{x:e,y:t,width:i,height:n}=this.bbox;this.ctx.clearRect(e,t,i,n)}finish(){this.ctx.restore()}to_blob(){const{_canvas:e}=this;if(e instanceof HTMLCanvasElement)return null!=e.msToBlob?Promise.resolve(e.msToBlob()):new Promise(((t,i)=>{e.toBlob((e=>null!=e?t(e):i()),\"image/png\")}));{const e=this._ctx.get_serialized_svg(!0),t=new Blob([e],{type:\"image/svg+xml\"});return Promise.resolve(t)}}}i.CanvasLayer=c,c.__name__=\"CanvasLayer\"},\n", + " function _(t,e,i,s,n){s();const r=t(168),a=t(8),o=t(43);function l(t){if(!t)throw new Error(\"cannot create a random attribute name for an undefined object\");const e=\"ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz\";let i=\"\";do{i=\"\";for(let t=0;t<12;t++)i+=e[Math.floor(Math.random()*e.length)]}while(t[i]);return i}function h(t){var e;const i={left:\"start\",right:\"end\",center:\"middle\",start:\"start\",end:\"end\"};return null!==(e=i[t])&&void 0!==e?e:i.start}function c(t){var e;const i={alphabetic:\"alphabetic\",hanging:\"hanging\",top:\"text-before-edge\",bottom:\"text-after-edge\",middle:\"central\"};return null!==(e=i[t])&&void 0!==e?e:i.alphabetic}const _=function(t,e){const i=new Map,s=t.split(\",\");e=null!=e?e:10;for(let t=0;t=0?Math.acos(e):-Math.acos(e)}const w=v(f),b=v(g);this.lineTo(d+f[0]*n,m+f[1]*n),this.arc(d,m,n,w,b)}stroke(){\"path\"===this.__currentElement.nodeName&&this.__currentElement.setAttribute(\"paint-order\",\"fill\"),this.__applyCurrentDefaultPath(),this.__applyStyleToCurrentElement(\"stroke\"),null!=this._clip_path&&this.__currentElement.setAttribute(\"clip-path\",this._clip_path)}fill(t){if(\"path\"===this.__currentElement.nodeName&&this.__currentElement.setAttribute(\"paint-order\",\"stroke\"),\"none\"!=this.__currentElement.getAttribute(\"fill\")){const t=this.__currentElement.cloneNode(!0);this.__root.appendChild(t),this.__currentElement=t}this.__applyCurrentDefaultPath(),this.__applyStyleToCurrentElement(\"fill\"),null!=t&&this.__currentElement.setAttribute(\"fill-rule\",t),null!=this._clip_path&&this.__currentElement.setAttribute(\"clip-path\",this._clip_path)}rect(t,e,i,s){isFinite(t+e+i+s)&&(\"path\"!==this.__currentElement.nodeName&&this.beginPath(),this.moveTo(t,e),this.lineTo(t+i,e),this.lineTo(t+i,e+s),this.lineTo(t,e+s),this.lineTo(t,e))}fillRect(t,e,i,s){isFinite(t+e+i+s)&&(this.beginPath(),this.rect(t,e,i,s),this.fill())}strokeRect(t,e,i,s){isFinite(t+e+i+s)&&(this.beginPath(),this.rect(t,e,i,s),this.stroke())}__clearCanvas(){o.empty(this.__defs),o.empty(this.__root),this.__root.appendChild(this.__defs),this.__currentElement=this.__root}clearRect(t,e,i,s){if(!isFinite(t+e+i+s))return;if(0===t&&0===e&&i===this.width&&s===this.height)return void this.__clearCanvas();const n=this.__createElement(\"rect\",{x:t,y:e,width:i,height:s,fill:\"#FFFFFF\"},!0);this._apply_transform(n),this.__root.appendChild(n)}createLinearGradient(t,e,i,s){if(!isFinite(t+e+i+s))throw new Error(\"The provided double value is non-finite\");const[n,r]=this._transform.apply(t,e),[a,o]=this._transform.apply(i,s),h=this.__createElement(\"linearGradient\",{id:l(this.__ids),x1:`${n}px`,x2:`${a}px`,y1:`${r}px`,y2:`${o}px`,gradientUnits:\"userSpaceOnUse\"},!1);return this.__defs.appendChild(h),new p(h,this)}createRadialGradient(t,e,i,s,n,r){if(!isFinite(t+e+i+s+n+r))throw new Error(\"The provided double value is non-finite\");const[a,o]=this._transform.apply(t,e),[h,c]=this._transform.apply(s,n),_=this.__createElement(\"radialGradient\",{id:l(this.__ids),cx:`${h}px`,cy:`${c}px`,r:`${r}px`,fx:`${a}px`,fy:`${o}px`,gradientUnits:\"userSpaceOnUse\"},!1);return this.__defs.appendChild(_),new p(_,this)}__parseFont(){var t,e,i,s,n;const r=/^\\s*(?=(?:(?:[-a-z]+\\s*){0,2}(italic|oblique))?)(?=(?:(?:[-a-z]+\\s*){0,2}(small-caps))?)(?=(?:(?:[-a-z]+\\s*){0,2}(bold(?:er)?|lighter|[1-9]00))?)(?:(?:normal|\\1|\\2|\\3)\\s*){0,3}((?:xx?-)?(?:small|large)|medium|smaller|larger|[.\\d]+(?:\\%|in|[cem]m|ex|p[ctx]))(?:\\s*\\/\\s*(normal|[.\\d]+(?:\\%|in|[cem]m|ex|p[ctx])))?\\s*([-,\\'\\\"\\sa-z0-9]+?)\\s*$/i.exec(this.font),a={style:null!==(t=r[1])&&void 0!==t?t:\"normal\",size:null!==(e=r[4])&&void 0!==e?e:\"10px\",family:null!==(i=r[6])&&void 0!==i?i:\"sans-serif\",weight:null!==(s=r[3])&&void 0!==s?s:\"normal\",decoration:null!==(n=r[2])&&void 0!==n?n:\"normal\"};return\"underline\"===this.__fontUnderline&&(a.decoration=\"underline\"),null!=this.__fontHref&&(a.href=this.__fontHref),a}__wrapTextLink(t,e){if(t.href){const i=this.__createElement(\"a\");return i.setAttributeNS(\"http://www.w3.org/1999/xlink\",\"xlink:href\",t.href),i.appendChild(e),i}return e}__applyText(t,e,i,s){const n=this.__parseFont(),r=this.__createElement(\"text\",{\"font-family\":n.family,\"font-size\":n.size,\"font-style\":n.style,\"font-weight\":n.weight,\"text-decoration\":n.decoration,x:e,y:i,\"text-anchor\":h(this.textAlign),\"dominant-baseline\":c(this.textBaseline)},!0);r.appendChild(this.__document.createTextNode(t)),this._apply_transform(r),this.__currentElement=r,this.__applyStyleToCurrentElement(s),this.__root.appendChild(this.__wrapTextLink(n,r))}fillText(t,e,i){null!=t&&isFinite(e+i)&&this.__applyText(t,e,i,\"fill\")}strokeText(t,e,i){null!=t&&isFinite(e+i)&&this.__applyText(t,e,i,\"stroke\")}measureText(t){return this.__ctx.font=this.font,this.__ctx.measureText(t)}arc(t,e,i,s,n,r=!1){if(!isFinite(t+e+i+s+n))return;if(s===n)return;(s%=2*Math.PI)===(n%=2*Math.PI)&&(n=(n+2*Math.PI-.001*(r?-1:1))%(2*Math.PI));const a=t+i*Math.cos(n),o=e+i*Math.sin(n),l=t+i*Math.cos(s),h=e+i*Math.sin(s),c=r?0:1;let _=0,u=n-s;u<0&&(u+=2*Math.PI),_=r?u>Math.PI?0:1:u>Math.PI?1:0,this.lineTo(l,h);const p=i,d=i,[m,f]=this._transform.apply(a,o);this.__addPathCommand(m,f,`A ${p} ${d} 0 ${_} ${c} ${m} ${f}`)}clip(){const t=this.__createElement(\"clipPath\"),e=l(this.__ids);this.__applyCurrentDefaultPath(),t.setAttribute(\"id\",e),t.appendChild(this.__currentElement),this.__defs.appendChild(t),this._clip_path=`url(#${e})`}drawImage(t,...e){let i,s,n,r,a,o,l,h;if(2==e.length){if([i,s]=e,!isFinite(i+s))return;a=0,o=0,l=t.width,h=t.height,n=l,r=h}else if(4==e.length){if([i,s,n,r]=e,!isFinite(i+s+n+r))return;a=0,o=0,l=t.width,h=t.height}else{if(8!==e.length)throw new Error(`Inavlid number of arguments passed to drawImage: ${arguments.length}`);if([a,o,l,h,i,s,n,r]=e,!isFinite(a+o+l+h+i+s+n+r))return}const c=this.__root,_=this._transform.clone().translate(i,s);if(t instanceof m||t instanceof SVGSVGElement){const e=(t instanceof SVGSVGElement?t:t.get_svg()).cloneNode(!0);let i;_.is_identity?i=c:(i=this.__createElement(\"g\"),this._apply_transform(i,_),c.appendChild(i));for(const t of[...e.childNodes])if(t instanceof SVGDefsElement){for(const e of[...t.childNodes])if(e instanceof Element){const t=e.getAttribute(\"id\");this.__ids[t]=t,this.__defs.appendChild(e)}}else i.appendChild(t)}else if(t instanceof HTMLImageElement||t instanceof SVGImageElement){const e=this.__createElement(\"image\");if(e.setAttribute(\"width\",`${n}`),e.setAttribute(\"height\",`${r}`),e.setAttribute(\"preserveAspectRatio\",\"none\"),a||o||l!==t.width||h!==t.height){const e=this.__document.createElement(\"canvas\");e.width=n,e.height=r;e.getContext(\"2d\").drawImage(t,a,o,l,h,0,0,n,r),t=e}this._apply_transform(e,_);const i=t instanceof HTMLCanvasElement?t.toDataURL():t.getAttribute(\"src\");e.setAttributeNS(\"http://www.w3.org/1999/xlink\",\"xlink:href\",i),c.appendChild(e)}else if(t instanceof HTMLCanvasElement){const e=this.__createElement(\"image\");e.setAttribute(\"width\",`${n}`),e.setAttribute(\"height\",`${r}`),e.setAttribute(\"preserveAspectRatio\",\"none\");const i=this.__document.createElement(\"canvas\");i.width=n,i.height=r;const s=i.getContext(\"2d\");s.imageSmoothingEnabled=!1,s.drawImage(t,a,o,l,h,0,0,n,r),t=i,this._apply_transform(e,_),e.setAttributeNS(\"http://www.w3.org/1999/xlink\",\"xlink:href\",t.toDataURL()),c.appendChild(e)}}createPattern(t,e){const i=this.__document.createElementNS(\"http://www.w3.org/2000/svg\",\"pattern\"),s=l(this.__ids);if(i.setAttribute(\"id\",s),i.setAttribute(\"width\",`${this._to_number(t.width)}`),i.setAttribute(\"height\",`${this._to_number(t.height)}`),i.setAttribute(\"patternUnits\",\"userSpaceOnUse\"),t instanceof HTMLCanvasElement||t instanceof HTMLImageElement||t instanceof SVGImageElement){const e=this.__document.createElementNS(\"http://www.w3.org/2000/svg\",\"image\"),s=t instanceof HTMLCanvasElement?t.toDataURL():t.getAttribute(\"src\");e.setAttributeNS(\"http://www.w3.org/1999/xlink\",\"xlink:href\",s),i.appendChild(e),this.__defs.appendChild(i)}else if(t instanceof m){for(const e of[...t.__root.childNodes])e instanceof SVGDefsElement||i.appendChild(e);this.__defs.appendChild(i)}else{if(!(t instanceof SVGSVGElement))throw new Error(\"unsupported\");for(const e of[...t.childNodes])e instanceof SVGDefsElement||i.appendChild(e);this.__defs.appendChild(i)}return new d(i,this)}setLineDash(t){t&&t.length>0?this.lineDash=t.join(\",\"):this.lineDash=null}_to_number(t){return a.isNumber(t)?t:t.baseVal.value}}i.SVGRenderingContext2D=m,m.__name__=\"SVGRenderingContext2D\"},\n", + " function _(o,t,n,i,e){i();const s=o(238),c=o(15);class l extends s.ButtonToolButtonView{_clicked(){this.model.do.emit(void 0)}}n.ActionToolButtonView=l,l.__name__=\"ActionToolButtonView\";class _ extends s.ButtonToolView{connect_signals(){super.connect_signals(),this.connect(this.model.do,(o=>this.doit(o)))}}n.ActionToolView=_,_.__name__=\"ActionToolView\";class d extends s.ButtonTool{constructor(o){super(o),this.button_view=l,this.do=new c.Signal(this,\"do\")}}n.ActionTool=d,d.__name__=\"ActionTool\"},\n", + " function _(o,e,t,i,l){i();const s=o(251),n=o(242);class r extends s.ActionToolView{doit(){window.open(this.model.redirect)}}t.HelpToolView=r,r.__name__=\"HelpToolView\";class c extends s.ActionTool{constructor(o){super(o),this.tool_name=\"Help\",this.icon=n.tool_icon_help}static init_HelpTool(){this.prototype.default_view=r,this.define((({String:o})=>({redirect:[o,\"https://docs.bokeh.org/en/latest/docs/user_guide/tools.html\"]}))),this.override({description:\"Click the question mark to learn more about Bokeh plot tools.\"}),this.register_alias(\"help\",(()=>new c))}}t.HelpTool=c,c.__name__=\"HelpTool\",c.init_HelpTool()},\n", + " function _(o,l,g,A,r){A(),g.root=\"bk-root\",g.logo=\"bk-logo\",g.grey=\"bk-grey\",g.logo_small=\"bk-logo-small\",g.logo_notebook=\"bk-logo-notebook\",g.default=\".bk-root .bk-logo{margin:5px;position:relative;display:block;background-repeat:no-repeat;}.bk-root .bk-logo.bk-grey{filter:url(\\\"data:image/svg+xml;utf8,#grayscale\\\");filter:gray;-webkit-filter:grayscale(100%);}.bk-root .bk-logo-small{width:20px;height:20px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAABx0RVh0U29mdHdhcmUAQWRvYmUgRmlyZXdvcmtzIENTNui8sowAAAOkSURBVDiNjZRtaJVlGMd/1/08zzln5zjP1LWcU9N0NkN8m2CYjpgQYQXqSs0I84OLIC0hkEKoPtiH3gmKoiJDU7QpLgoLjLIQCpEsNJ1vqUOdO7ppbuec5+V+rj4ctwzd8IIbbi6u+8f1539dt3A78eXC7QizUF7gyV1fD1Yqg4JWz84yffhm0qkFqBogB9rM8tZdtwVsPUhWhGcFJngGeWrPzHm5oaMmkfEg1usvLFyc8jLRqDOMru7AyC8saQr7GG7f5fvDeH7Ej8CM66nIF+8yngt6HWaKh7k49Soy9nXurCi1o3qUbS3zWfrYeQDTB/Qj6kX6Ybhw4B+bOYoLKCC9H3Nu/leUTZ1JdRWkkn2ldcCamzrcf47KKXdAJllSlxAOkRgyHsGC/zRday5Qld9DyoM4/q/rUoy/CXh3jzOu3bHUVZeU+DEn8FInkPBFlu3+nW3Nw0mk6vCDiWg8CeJaxEwuHS3+z5RgY+YBR6V1Z1nxSOfoaPa4LASWxxdNp+VWTk7+4vzaou8v8PN+xo+KY2xsw6une2frhw05CTYOmQvsEhjhWjn0bmXPjpE1+kplmmkP3suftwTubK9Vq22qKmrBhpY4jvd5afdRA3wGjFAgcnTK2s4hY0/GPNIb0nErGMCRxWOOX64Z8RAC4oCXdklmEvcL8o0BfkNK4lUg9HTl+oPlQxdNo3Mg4Nv175e/1LDGzZen30MEjRUtmXSfiTVu1kK8W4txyV6BMKlbgk3lMwYCiusNy9fVfvvwMxv8Ynl6vxoByANLTWplvuj/nF9m2+PDtt1eiHPBr1oIfhCChQMBw6Aw0UulqTKZdfVvfG7VcfIqLG9bcldL/+pdWTLxLUy8Qq38heUIjh4XlzZxzQm19lLFlr8vdQ97rjZVOLf8nclzckbcD4wxXMidpX30sFd37Fv/GtwwhzhxGVAprjbg0gCAEeIgwCZyTV2Z1REEW8O4py0wsjeloKoMr6iCY6dP92H6Vw/oTyICIthibxjm/DfN9lVz8IqtqKYLUXfoKVMVQVVJOElGjrnnUt9T9wbgp8AyYKaGlqingHZU/uG2NTZSVqwHQTWkx9hxjkpWDaCg6Ckj5qebgBVbT3V3NNXMSiWSDdGV3hrtzla7J+duwPOToIg42ChPQOQjspnSlp1V+Gjdged7+8UN5CRAV7a5EdFNwCjEaBR27b3W890TE7g24NAP/mMDXRWrGoFPQI9ls/MWO2dWFAar/xcOIImbbpA3zgAAAABJRU5ErkJggg==);}.bk-root .bk-logo-notebook{display:inline-block;vertical-align:middle;margin-right:5px;}\"},\n", + " function _(t,e,i,s,l){s();const o=t(1),n=t(40),h=t(20),a=t(43),r=o.__importStar(t(255)),c=r;class d extends n.AnnotationView{initialize(){super.initialize(),this.el=a.div({class:c.tooltip}),a.undisplay(this.el),this.plot_view.canvas_view.add_overlay(this.el)}remove(){a.remove(this.el),super.remove()}connect_signals(){super.connect_signals(),this.connect(this.model.properties.content.change,(()=>this.render())),this.connect(this.model.properties.position.change,(()=>this._reposition()))}styles(){return[...super.styles(),r.default]}render(){this.model.visible||a.undisplay(this.el),super.render()}_render(){const{content:t}=this.model;null!=t?(a.empty(this.el),a.classes(this.el).toggle(\"bk-tooltip-custom\",this.model.custom),this.el.appendChild(t),this.model.show_arrow&&this.el.classList.add(c.tooltip_arrow)):a.undisplay(this.el)}_reposition(){const{position:t}=this.model;if(null==t)return void a.undisplay(this.el);const[e,i]=t,s=(()=>{const t=this.parent.layout.bbox.relative(),{attachment:s}=this.model;switch(s){case\"horizontal\":return e({attachment:[h.TooltipAttachment,\"horizontal\"],inner_only:[t,!0],show_arrow:[t,!0]}))),this.internal((({Boolean:t,Number:e,Tuple:i,Ref:s,Nullable:l})=>({position:[l(i(e,e)),null],content:[s(HTMLElement),()=>a.div()],custom:[t]}))),this.override({level:\"overlay\"})}clear(){this.position=null}}i.Tooltip=p,p.__name__=\"Tooltip\",p.init_Tooltip()},\n", + " function _(o,t,r,e,l){e(),r.root=\"bk-root\",r.tooltip=\"bk-tooltip\",r.left=\"bk-left\",r.tooltip_arrow=\"bk-tooltip-arrow\",r.right=\"bk-right\",r.above=\"bk-above\",r.below=\"bk-below\",r.tooltip_row_label=\"bk-tooltip-row-label\",r.tooltip_row_value=\"bk-tooltip-row-value\",r.tooltip_color_block=\"bk-tooltip-color-block\",r.default='.bk-root{}.bk-root .bk-tooltip{font-weight:300;font-size:12px;position:absolute;padding:5px;border:1px solid #e5e5e5;color:#2f2f2f;background-color:white;pointer-events:none;opacity:0.95;z-index:100;}.bk-root .bk-tooltip > div:not(:first-child){margin-top:5px;border-top:#e5e5e5 1px dashed;}.bk-root .bk-tooltip.bk-left.bk-tooltip-arrow::before{position:absolute;margin:-7px 0 0 0;top:50%;width:0;height:0;border-style:solid;border-width:7px 0 7px 0;border-color:transparent;content:\" \";display:block;left:-10px;border-right-width:10px;border-right-color:#909599;}.bk-root .bk-tooltip.bk-left::before{left:-10px;border-right-width:10px;border-right-color:#909599;}.bk-root .bk-tooltip.bk-right.bk-tooltip-arrow::after{position:absolute;margin:-7px 0 0 0;top:50%;width:0;height:0;border-style:solid;border-width:7px 0 7px 0;border-color:transparent;content:\" \";display:block;right:-10px;border-left-width:10px;border-left-color:#909599;}.bk-root .bk-tooltip.bk-right::after{right:-10px;border-left-width:10px;border-left-color:#909599;}.bk-root .bk-tooltip.bk-above::before{position:absolute;margin:0 0 0 -7px;left:50%;width:0;height:0;border-style:solid;border-width:0 7px 0 7px;border-color:transparent;content:\" \";display:block;top:-10px;border-bottom-width:10px;border-bottom-color:#909599;}.bk-root .bk-tooltip.bk-below::after{position:absolute;margin:0 0 0 -7px;left:50%;width:0;height:0;border-style:solid;border-width:0 7px 0 7px;border-color:transparent;content:\" \";display:block;bottom:-10px;border-top-width:10px;border-top-color:#909599;}.bk-root .bk-tooltip-row-label{text-align:right;color:#26aae1;}.bk-root .bk-tooltip-row-value{color:default;}.bk-root .bk-tooltip-color-block{width:12px;height:12px;margin-left:5px;margin-right:5px;outline:#dddddd solid 1px;display:inline-block;}'},\n", + " function _(e,t,i,s,r){s();const a=e(135),h=e(133),_=e(122),l=e(48);class o extends a.UpperLowerView{async lazy_initialize(){await super.lazy_initialize();const{lower_head:e,upper_head:t}=this.model;null!=e&&(this.lower_head=await _.build_view(e,{parent:this})),null!=t&&(this.upper_head=await _.build_view(t,{parent:this}))}set_data(e){var t,i;super.set_data(e),null===(t=this.lower_head)||void 0===t||t.set_data(e),null===(i=this.upper_head)||void 0===i||i.set_data(e)}paint(e){if(this.visuals.line.doit)for(let t=0,i=this._lower_sx.length;t({lower_head:[t(e(h.ArrowHead)),()=>new h.TeeHead({size:10})],upper_head:[t(e(h.ArrowHead)),()=>new h.TeeHead({size:10})]}))),this.override({level:\"underlay\"})}}i.Whisker=n,n.__name__=\"Whisker\",n.init_Whisker()},\n", + " function _(n,o,t,u,e){u(),e(\"CustomJS\",n(258).CustomJS),e(\"OpenURL\",n(260).OpenURL)},\n", + " function _(t,s,e,n,c){n();const u=t(259),i=t(13),a=t(34);class r extends u.Callback{constructor(t){super(t)}static init_CustomJS(){this.define((({Unknown:t,String:s,Dict:e})=>({args:[e(t),{}],code:[s,\"\"]})))}get names(){return i.keys(this.args)}get values(){return i.values(this.args)}get func(){const t=a.use_strict(this.code);return new Function(...this.names,\"cb_obj\",\"cb_data\",t)}execute(t,s={}){return this.func.apply(t,this.values.concat(t,s))}}e.CustomJS=r,r.__name__=\"CustomJS\",r.init_CustomJS()},\n", + " function _(c,a,l,n,s){n();const e=c(53);class o extends e.Model{constructor(c){super(c)}}l.Callback=o,o.__name__=\"Callback\"},\n", + " function _(e,t,n,i,o){i();const s=e(259),c=e(182),r=e(8);class a extends s.Callback{constructor(e){super(e)}static init_OpenURL(){this.define((({Boolean:e,String:t})=>({url:[t,\"http://\"],same_tab:[e,!1]})))}navigate(e){this.same_tab?window.location.href=e:window.open(e)}execute(e,{source:t}){const n=e=>{const n=c.replace_placeholders(this.url,t,e,void 0,void 0,encodeURI);if(!r.isString(n))throw new Error(\"HTML output is not supported in this context\");this.navigate(n)},{selected:i}=t;for(const e of i.indices)n(e);for(const e of i.line_indices)n(e)}}n.OpenURL=a,a.__name__=\"OpenURL\",a.init_OpenURL()},\n", + " function _(a,n,e,r,s){r(),s(\"Canvas\",a(262).Canvas),s(\"CartesianFrame\",a(144).CartesianFrame)},\n", + " function _(e,t,s,i,a){i();const l=e(14),n=e(240),r=e(19),o=e(43),h=e(20),_=e(13),c=e(263),d=e(99),p=e(249),v=(()=>{const e=document.createElement(\"canvas\"),t=e.getContext(\"webgl\",{premultipliedAlpha:!0});return null!=t?{canvas:e,gl:t}:void r.logger.trace(\"WebGL is not supported\")})(),u={position:\"absolute\",top:\"0\",left:\"0\",width:\"100%\",height:\"100%\"};class b extends n.DOMView{constructor(){super(...arguments),this.bbox=new d.BBox}initialize(){super.initialize(),\"webgl\"==this.model.output_backend&&(this.webgl=v),this.underlays_el=o.div({style:u}),this.primary=this.create_layer(),this.overlays=this.create_layer(),this.overlays_el=o.div({style:u}),this.events_el=o.div({class:\"bk-canvas-events\",style:u});const e=[this.underlays_el,this.primary.el,this.overlays.el,this.overlays_el,this.events_el];_.extend(this.el.style,u),o.append(this.el,...e),this.ui_event_bus=new c.UIEventBus(this)}remove(){this.ui_event_bus.destroy(),super.remove()}add_underlay(e){this.underlays_el.appendChild(e)}add_overlay(e){this.overlays_el.appendChild(e)}add_event(e){this.events_el.appendChild(e)}get pixel_ratio(){return this.primary.pixel_ratio}resize(e,t){this.bbox=new d.BBox({left:0,top:0,width:e,height:t}),this.primary.resize(e,t),this.overlays.resize(e,t)}prepare_webgl(e){const{webgl:t}=this;if(null!=t){const{width:s,height:i}=this.bbox;t.canvas.width=this.pixel_ratio*s,t.canvas.height=this.pixel_ratio*i;const{gl:a}=t;a.enable(a.SCISSOR_TEST);const[l,n,r,o]=e,{xview:h,yview:_}=this.bbox,c=h.compute(l),d=_.compute(n+o),p=this.pixel_ratio;a.scissor(p*c,p*d,p*r,p*o),a.enable(a.BLEND),a.blendFuncSeparate(a.SRC_ALPHA,a.ONE_MINUS_SRC_ALPHA,a.ONE_MINUS_DST_ALPHA,a.ONE),this._clear_webgl()}}blit_webgl(e){const{webgl:t}=this;if(null!=t){if(r.logger.debug(\"Blitting WebGL canvas\"),e.restore(),e.drawImage(t.canvas,0,0),e.save(),this.model.hidpi){const t=this.pixel_ratio;e.scale(t,t),e.translate(.5,.5)}this._clear_webgl()}}_clear_webgl(){const{webgl:e}=this;if(null!=e){const{gl:t,canvas:s}=e;t.viewport(0,0,s.width,s.height),t.clearColor(0,0,0,0),t.clear(t.COLOR_BUFFER_BIT|t.DEPTH_BUFFER_BIT)}}compose(){const e=this.create_layer(),{width:t,height:s}=this.bbox;return e.resize(t,s),e.ctx.drawImage(this.primary.canvas,0,0),e.ctx.drawImage(this.overlays.canvas,0,0),e}create_layer(){const{output_backend:e,hidpi:t}=this.model;return new p.CanvasLayer(e,t)}to_blob(){return this.compose().to_blob()}}s.CanvasView=b,b.__name__=\"CanvasView\";class g extends l.HasProps{constructor(e){super(e)}static init_Canvas(){this.prototype.default_view=b,this.internal((({Boolean:e})=>({hidpi:[e,!0],output_backend:[h.OutputBackend,\"canvas\"]})))}}s.Canvas=g,g.__name__=\"Canvas\",g.init_Canvas()},\n", + " function _(t,e,s,n,i){n();const r=t(1),a=r.__importDefault(t(239)),_=t(15),h=t(19),o=t(43),l=r.__importStar(t(264)),c=t(265),p=t(9),u=t(8),v=t(27),d=t(244);class g{constructor(t){this.canvas_view=t,this.pan_start=new _.Signal(this,\"pan:start\"),this.pan=new _.Signal(this,\"pan\"),this.pan_end=new _.Signal(this,\"pan:end\"),this.pinch_start=new _.Signal(this,\"pinch:start\"),this.pinch=new _.Signal(this,\"pinch\"),this.pinch_end=new _.Signal(this,\"pinch:end\"),this.rotate_start=new _.Signal(this,\"rotate:start\"),this.rotate=new _.Signal(this,\"rotate\"),this.rotate_end=new _.Signal(this,\"rotate:end\"),this.tap=new _.Signal(this,\"tap\"),this.doubletap=new _.Signal(this,\"doubletap\"),this.press=new _.Signal(this,\"press\"),this.pressup=new _.Signal(this,\"pressup\"),this.move_enter=new _.Signal(this,\"move:enter\"),this.move=new _.Signal(this,\"move\"),this.move_exit=new _.Signal(this,\"move:exit\"),this.scroll=new _.Signal(this,\"scroll\"),this.keydown=new _.Signal(this,\"keydown\"),this.keyup=new _.Signal(this,\"keyup\"),this.hammer=new a.default(this.hit_area,{touchAction:\"auto\",inputClass:a.default.TouchMouseInput}),this._prev_move=null,this._curr_pan=null,this._curr_pinch=null,this._curr_rotate=null,this._configure_hammerjs(),this.hit_area.addEventListener(\"mousemove\",(t=>this._mouse_move(t))),this.hit_area.addEventListener(\"mouseenter\",(t=>this._mouse_enter(t))),this.hit_area.addEventListener(\"mouseleave\",(t=>this._mouse_exit(t))),this.hit_area.addEventListener(\"contextmenu\",(t=>this._context_menu(t))),this.hit_area.addEventListener(\"wheel\",(t=>this._mouse_wheel(t))),document.addEventListener(\"keydown\",this),document.addEventListener(\"keyup\",this),this.menu=new d.ContextMenu([],{prevent_hide:t=>2==t.button&&t.target==this.hit_area}),this.hit_area.appendChild(this.menu.el)}get hit_area(){return this.canvas_view.events_el}destroy(){this.menu.remove(),this.hammer.destroy(),document.removeEventListener(\"keydown\",this),document.removeEventListener(\"keyup\",this)}handleEvent(t){\"keydown\"==t.type?this._key_down(t):\"keyup\"==t.type&&this._key_up(t)}_configure_hammerjs(){this.hammer.get(\"doubletap\").recognizeWith(\"tap\"),this.hammer.get(\"tap\").requireFailure(\"doubletap\"),this.hammer.get(\"doubletap\").dropRequireFailure(\"tap\"),this.hammer.on(\"doubletap\",(t=>this._doubletap(t))),this.hammer.on(\"tap\",(t=>this._tap(t))),this.hammer.on(\"press\",(t=>this._press(t))),this.hammer.on(\"pressup\",(t=>this._pressup(t))),this.hammer.get(\"pan\").set({direction:a.default.DIRECTION_ALL}),this.hammer.on(\"panstart\",(t=>this._pan_start(t))),this.hammer.on(\"pan\",(t=>this._pan(t))),this.hammer.on(\"panend\",(t=>this._pan_end(t))),this.hammer.get(\"pinch\").set({enable:!0}),this.hammer.on(\"pinchstart\",(t=>this._pinch_start(t))),this.hammer.on(\"pinch\",(t=>this._pinch(t))),this.hammer.on(\"pinchend\",(t=>this._pinch_end(t))),this.hammer.get(\"rotate\").set({enable:!0}),this.hammer.on(\"rotatestart\",(t=>this._rotate_start(t))),this.hammer.on(\"rotate\",(t=>this._rotate(t))),this.hammer.on(\"rotateend\",(t=>this._rotate_end(t)))}register_tool(t){const e=t.model.event_type;null!=e&&(u.isString(e)?this._register_tool(t,e):e.forEach(((e,s)=>this._register_tool(t,e,s<1))))}_register_tool(t,e,s=!0){const n=t,{id:i}=n.model,r=t=>e=>{e.id==i&&t(e.e)},a=t=>e=>{t(e.e)};switch(e){case\"pan\":null!=n._pan_start&&n.connect(this.pan_start,r(n._pan_start.bind(n))),null!=n._pan&&n.connect(this.pan,r(n._pan.bind(n))),null!=n._pan_end&&n.connect(this.pan_end,r(n._pan_end.bind(n)));break;case\"pinch\":null!=n._pinch_start&&n.connect(this.pinch_start,r(n._pinch_start.bind(n))),null!=n._pinch&&n.connect(this.pinch,r(n._pinch.bind(n))),null!=n._pinch_end&&n.connect(this.pinch_end,r(n._pinch_end.bind(n)));break;case\"rotate\":null!=n._rotate_start&&n.connect(this.rotate_start,r(n._rotate_start.bind(n))),null!=n._rotate&&n.connect(this.rotate,r(n._rotate.bind(n))),null!=n._rotate_end&&n.connect(this.rotate_end,r(n._rotate_end.bind(n)));break;case\"move\":null!=n._move_enter&&n.connect(this.move_enter,r(n._move_enter.bind(n))),null!=n._move&&n.connect(this.move,r(n._move.bind(n))),null!=n._move_exit&&n.connect(this.move_exit,r(n._move_exit.bind(n)));break;case\"tap\":null!=n._tap&&n.connect(this.tap,r(n._tap.bind(n))),null!=n._doubletap&&n.connect(this.doubletap,r(n._doubletap.bind(n)));break;case\"press\":null!=n._press&&n.connect(this.press,r(n._press.bind(n))),null!=n._pressup&&n.connect(this.pressup,r(n._pressup.bind(n)));break;case\"scroll\":null!=n._scroll&&n.connect(this.scroll,r(n._scroll.bind(n)));break;default:throw new Error(`unsupported event_type: ${e}`)}s&&(null!=n._keydown&&n.connect(this.keydown,a(n._keydown.bind(n))),null!=n._keyup&&n.connect(this.keyup,a(n._keyup.bind(n))),v.is_mobile&&null!=n._scroll&&\"pinch\"==e&&(h.logger.debug(\"Registering scroll on touch screen\"),n.connect(this.scroll,r(n._scroll.bind(n)))))}_hit_test_renderers(t,e,s){var n;const i=t.get_renderer_views();for(const t of p.reversed(i))if(null===(n=t.interactive_hit)||void 0===n?void 0:n.call(t,e,s))return t;return null}set_cursor(t=\"default\"){this.hit_area.style.cursor=t}_hit_test_frame(t,e,s){return t.frame.bbox.contains(e,s)}_hit_test_canvas(t,e,s){return t.layout.bbox.contains(e,s)}_hit_test_plot(t,e){for(const s of this.canvas_view.plot_views)if(s.layout.bbox.relative().contains(t,e))return s;return null}_trigger(t,e,s){var n;const{sx:i,sy:r}=e,a=this._hit_test_plot(i,r),_=t=>{const[s,n]=[i,r];return Object.assign(Object.assign({},e),{sx:s,sy:n})};if(\"panstart\"==e.type||\"pan\"==e.type||\"panend\"==e.type){let n;if(\"panstart\"==e.type&&null!=a?(this._curr_pan={plot_view:a},n=a):\"pan\"==e.type&&null!=this._curr_pan?n=this._curr_pan.plot_view:\"panend\"==e.type&&null!=this._curr_pan?(n=this._curr_pan.plot_view,this._curr_pan=null):n=null,null!=n){const e=_();this.__trigger(n,t,e,s)}}else if(\"pinchstart\"==e.type||\"pinch\"==e.type||\"pinchend\"==e.type){let n;if(\"pinchstart\"==e.type&&null!=a?(this._curr_pinch={plot_view:a},n=a):\"pinch\"==e.type&&null!=this._curr_pinch?n=this._curr_pinch.plot_view:\"pinchend\"==e.type&&null!=this._curr_pinch?(n=this._curr_pinch.plot_view,this._curr_pinch=null):n=null,null!=n){const e=_();this.__trigger(n,t,e,s)}}else if(\"rotatestart\"==e.type||\"rotate\"==e.type||\"rotateend\"==e.type){let n;if(\"rotatestart\"==e.type&&null!=a?(this._curr_rotate={plot_view:a},n=a):\"rotate\"==e.type&&null!=this._curr_rotate?n=this._curr_rotate.plot_view:\"rotateend\"==e.type&&null!=this._curr_rotate?(n=this._curr_rotate.plot_view,this._curr_rotate=null):n=null,null!=n){const e=_();this.__trigger(n,t,e,s)}}else if(\"mouseenter\"==e.type||\"mousemove\"==e.type||\"mouseleave\"==e.type){const h=null===(n=this._prev_move)||void 0===n?void 0:n.plot_view;if(null!=h&&(\"mouseleave\"==e.type||h!=a)){const{sx:t,sy:e}=_();this.__trigger(h,this.move_exit,{type:\"mouseleave\",sx:t,sy:e,shiftKey:!1,ctrlKey:!1},s)}if(null!=a&&(\"mouseenter\"==e.type||h!=a)){const{sx:t,sy:e}=_();this.__trigger(a,this.move_enter,{type:\"mouseenter\",sx:t,sy:e,shiftKey:!1,ctrlKey:!1},s)}if(null!=a&&\"mousemove\"==e.type){const e=_();this.__trigger(a,t,e,s)}this._prev_move={sx:i,sy:r,plot_view:a}}else if(null!=a){const e=_();this.__trigger(a,t,e,s)}}__trigger(t,e,s,n){var i,r;const a=t.model.toolbar.gestures,_=e.name.split(\":\")[0],h=this._hit_test_renderers(t,s.sx,s.sy),o=this._hit_test_canvas(t,s.sx,s.sy);switch(_){case\"move\":{const n=a[_].active;null!=n&&this.trigger(e,s,n.id);const r=t.model.toolbar.inspectors.filter((t=>t.active));let l=\"default\";null!=h?(l=null!==(i=h.cursor(s.sx,s.sy))&&void 0!==i?i:l,p.is_empty(r)||(e=this.move_exit)):this._hit_test_frame(t,s.sx,s.sy)&&(p.is_empty(r)||(l=\"crosshair\")),this.set_cursor(l),t.set_toolbar_visibility(o),r.map((t=>this.trigger(e,s,t.id)));break}case\"tap\":{const{target:t}=n;if(null!=t&&t!=this.hit_area)return;null!=h&&null!=h.on_hit&&h.on_hit(s.sx,s.sy);const i=a[_].active;null!=i&&this.trigger(e,s,i.id);break}case\"doubletap\":{const t=null!==(r=a.doubletap.active)&&void 0!==r?r:a.tap.active;null!=t&&this.trigger(e,s,t.id);break}case\"scroll\":{const t=a[v.is_mobile?\"pinch\":\"scroll\"].active;null!=t&&(n.preventDefault(),n.stopPropagation(),this.trigger(e,s,t.id));break}case\"pan\":{const t=a[_].active;null!=t&&(n.preventDefault(),this.trigger(e,s,t.id));break}default:{const t=a[_].active;null!=t&&this.trigger(e,s,t.id)}}this._trigger_bokeh_event(t,s)}trigger(t,e,s=null){t.emit({id:s,e})}_trigger_bokeh_event(t,e){const s=(()=>{const{sx:s,sy:n}=e,i=t.frame.x_scale.invert(s),r=t.frame.y_scale.invert(n);switch(e.type){case\"wheel\":return new l.MouseWheel(s,n,i,r,e.delta);case\"mousemove\":return new l.MouseMove(s,n,i,r);case\"mouseenter\":return new l.MouseEnter(s,n,i,r);case\"mouseleave\":return new l.MouseLeave(s,n,i,r);case\"tap\":return new l.Tap(s,n,i,r);case\"doubletap\":return new l.DoubleTap(s,n,i,r);case\"press\":return new l.Press(s,n,i,r);case\"pressup\":return new l.PressUp(s,n,i,r);case\"pan\":return new l.Pan(s,n,i,r,e.deltaX,e.deltaY);case\"panstart\":return new l.PanStart(s,n,i,r);case\"panend\":return new l.PanEnd(s,n,i,r);case\"pinch\":return new l.Pinch(s,n,i,r,e.scale);case\"pinchstart\":return new l.PinchStart(s,n,i,r);case\"pinchend\":return new l.PinchEnd(s,n,i,r);case\"rotate\":return new l.Rotate(s,n,i,r,e.rotation);case\"rotatestart\":return new l.RotateStart(s,n,i,r);case\"rotateend\":return new l.RotateEnd(s,n,i,r);default:return}})();null!=s&&t.model.trigger_event(s)}_get_sxy(t){const{pageX:e,pageY:s}=function(t){return\"undefined\"!=typeof TouchEvent&&t instanceof TouchEvent}(t)?(0!=t.touches.length?t.touches:t.changedTouches)[0]:t,{left:n,top:i}=o.offset(this.hit_area);return{sx:e-n,sy:s-i}}_pan_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t.srcEvent)),{deltaX:t.deltaX,deltaY:t.deltaY,shiftKey:t.srcEvent.shiftKey,ctrlKey:t.srcEvent.ctrlKey})}_pinch_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t.srcEvent)),{scale:t.scale,shiftKey:t.srcEvent.shiftKey,ctrlKey:t.srcEvent.ctrlKey})}_rotate_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t.srcEvent)),{rotation:t.rotation,shiftKey:t.srcEvent.shiftKey,ctrlKey:t.srcEvent.ctrlKey})}_tap_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t.srcEvent)),{shiftKey:t.srcEvent.shiftKey,ctrlKey:t.srcEvent.ctrlKey})}_move_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t)),{shiftKey:t.shiftKey,ctrlKey:t.ctrlKey})}_scroll_event(t){return Object.assign(Object.assign({type:t.type},this._get_sxy(t)),{delta:c.getDeltaY(t),shiftKey:t.shiftKey,ctrlKey:t.ctrlKey})}_key_event(t){return{type:t.type,keyCode:t.keyCode}}_pan_start(t){const e=this._pan_event(t);e.sx-=t.deltaX,e.sy-=t.deltaY,this._trigger(this.pan_start,e,t.srcEvent)}_pan(t){this._trigger(this.pan,this._pan_event(t),t.srcEvent)}_pan_end(t){this._trigger(this.pan_end,this._pan_event(t),t.srcEvent)}_pinch_start(t){this._trigger(this.pinch_start,this._pinch_event(t),t.srcEvent)}_pinch(t){this._trigger(this.pinch,this._pinch_event(t),t.srcEvent)}_pinch_end(t){this._trigger(this.pinch_end,this._pinch_event(t),t.srcEvent)}_rotate_start(t){this._trigger(this.rotate_start,this._rotate_event(t),t.srcEvent)}_rotate(t){this._trigger(this.rotate,this._rotate_event(t),t.srcEvent)}_rotate_end(t){this._trigger(this.rotate_end,this._rotate_event(t),t.srcEvent)}_tap(t){this._trigger(this.tap,this._tap_event(t),t.srcEvent)}_doubletap(t){this._trigger(this.doubletap,this._tap_event(t),t.srcEvent)}_press(t){this._trigger(this.press,this._tap_event(t),t.srcEvent)}_pressup(t){this._trigger(this.pressup,this._tap_event(t),t.srcEvent)}_mouse_enter(t){this._trigger(this.move_enter,this._move_event(t),t)}_mouse_move(t){this._trigger(this.move,this._move_event(t),t)}_mouse_exit(t){this._trigger(this.move_exit,this._move_event(t),t)}_mouse_wheel(t){this._trigger(this.scroll,this._scroll_event(t),t)}_context_menu(t){!this.menu.is_open&&this.menu.can_open&&t.preventDefault();const{sx:e,sy:s}=this._get_sxy(t);this.menu.toggle({left:e,top:s})}_key_down(t){this.trigger(this.keydown,this._key_event(t))}_key_up(t){this.trigger(this.keyup,this._key_event(t))}}s.UIEventBus=g,g.__name__=\"UIEventBus\"},\n", + " function _(e,t,s,n,_){n();var a=this&&this.__decorate||function(e,t,s,n){var _,a=arguments.length,o=a<3?t:null===n?n=Object.getOwnPropertyDescriptor(t,s):n;if(\"object\"==typeof Reflect&&\"function\"==typeof Reflect.decorate)o=Reflect.decorate(e,t,s,n);else for(var c=e.length-1;c>=0;c--)(_=e[c])&&(o=(a<3?_(o):a>3?_(t,s,o):_(t,s))||o);return a>3&&o&&Object.defineProperty(t,s,o),o};function o(e){return function(t){t.prototype.event_name=e}}class c{to_json(){const{event_name:e}=this;return{event_name:e,event_values:this._to_json()}}}s.BokehEvent=c,c.__name__=\"BokehEvent\";class r extends c{constructor(){super(...arguments),this.origin=null}_to_json(){return{model:this.origin}}}s.ModelEvent=r,r.__name__=\"ModelEvent\";let l=class extends c{_to_json(){return{}}};s.DocumentReady=l,l.__name__=\"DocumentReady\",s.DocumentReady=l=a([o(\"document_ready\")],l);let i=class extends r{};s.ButtonClick=i,i.__name__=\"ButtonClick\",s.ButtonClick=i=a([o(\"button_click\")],i);let u=class extends r{constructor(e){super(),this.item=e}_to_json(){const{item:e}=this;return Object.assign(Object.assign({},super._to_json()),{item:e})}};s.MenuItemClick=u,u.__name__=\"MenuItemClick\",s.MenuItemClick=u=a([o(\"menu_item_click\")],u);class d extends r{}s.UIEvent=d,d.__name__=\"UIEvent\";let h=class extends d{};s.LODStart=h,h.__name__=\"LODStart\",s.LODStart=h=a([o(\"lodstart\")],h);let m=class extends d{};s.LODEnd=m,m.__name__=\"LODEnd\",s.LODEnd=m=a([o(\"lodend\")],m);let x=class extends d{constructor(e,t){super(),this.geometry=e,this.final=t}_to_json(){const{geometry:e,final:t}=this;return Object.assign(Object.assign({},super._to_json()),{geometry:e,final:t})}};s.SelectionGeometry=x,x.__name__=\"SelectionGeometry\",s.SelectionGeometry=x=a([o(\"selectiongeometry\")],x);let p=class extends d{};s.Reset=p,p.__name__=\"Reset\",s.Reset=p=a([o(\"reset\")],p);class j extends d{constructor(e,t,s,n){super(),this.sx=e,this.sy=t,this.x=s,this.y=n}_to_json(){const{sx:e,sy:t,x:s,y:n}=this;return Object.assign(Object.assign({},super._to_json()),{sx:e,sy:t,x:s,y:n})}}s.PointEvent=j,j.__name__=\"PointEvent\";let y=class extends j{constructor(e,t,s,n,_,a){super(e,t,s,n),this.sx=e,this.sy=t,this.x=s,this.y=n,this.delta_x=_,this.delta_y=a}_to_json(){const{delta_x:e,delta_y:t}=this;return Object.assign(Object.assign({},super._to_json()),{delta_x:e,delta_y:t})}};s.Pan=y,y.__name__=\"Pan\",s.Pan=y=a([o(\"pan\")],y);let P=class extends j{constructor(e,t,s,n,_){super(e,t,s,n),this.sx=e,this.sy=t,this.x=s,this.y=n,this.scale=_}_to_json(){const{scale:e}=this;return Object.assign(Object.assign({},super._to_json()),{scale:e})}};s.Pinch=P,P.__name__=\"Pinch\",s.Pinch=P=a([o(\"pinch\")],P);let v=class extends j{constructor(e,t,s,n,_){super(e,t,s,n),this.sx=e,this.sy=t,this.x=s,this.y=n,this.rotation=_}_to_json(){const{rotation:e}=this;return Object.assign(Object.assign({},super._to_json()),{rotation:e})}};s.Rotate=v,v.__name__=\"Rotate\",s.Rotate=v=a([o(\"rotate\")],v);let g=class extends j{constructor(e,t,s,n,_){super(e,t,s,n),this.sx=e,this.sy=t,this.x=s,this.y=n,this.delta=_}_to_json(){const{delta:e}=this;return Object.assign(Object.assign({},super._to_json()),{delta:e})}};s.MouseWheel=g,g.__name__=\"MouseWheel\",s.MouseWheel=g=a([o(\"wheel\")],g);let E=class extends j{};s.MouseMove=E,E.__name__=\"MouseMove\",s.MouseMove=E=a([o(\"mousemove\")],E);let O=class extends j{};s.MouseEnter=O,O.__name__=\"MouseEnter\",s.MouseEnter=O=a([o(\"mouseenter\")],O);let b=class extends j{};s.MouseLeave=b,b.__name__=\"MouseLeave\",s.MouseLeave=b=a([o(\"mouseleave\")],b);let M=class extends j{};s.Tap=M,M.__name__=\"Tap\",s.Tap=M=a([o(\"tap\")],M);let R=class extends j{};s.DoubleTap=R,R.__name__=\"DoubleTap\",s.DoubleTap=R=a([o(\"doubletap\")],R);let f=class extends j{};s.Press=f,f.__name__=\"Press\",s.Press=f=a([o(\"press\")],f);let S=class extends j{};s.PressUp=S,S.__name__=\"PressUp\",s.PressUp=S=a([o(\"pressup\")],S);let D=class extends j{};s.PanStart=D,D.__name__=\"PanStart\",s.PanStart=D=a([o(\"panstart\")],D);let k=class extends j{};s.PanEnd=k,k.__name__=\"PanEnd\",s.PanEnd=k=a([o(\"panend\")],k);let L=class extends j{};s.PinchStart=L,L.__name__=\"PinchStart\",s.PinchStart=L=a([o(\"pinchstart\")],L);let C=class extends j{};s.PinchEnd=C,C.__name__=\"PinchEnd\",s.PinchEnd=C=a([o(\"pinchend\")],C);let T=class extends j{};s.RotateStart=T,T.__name__=\"RotateStart\",s.RotateStart=T=a([o(\"rotatestart\")],T);let B=class extends j{};s.RotateEnd=B,B.__name__=\"RotateEnd\",s.RotateEnd=B=a([o(\"rotateend\")],B)},\n", + " function _(t,e,n,l,o){\n", + " /*!\n", + " * jQuery Mousewheel 3.1.13\n", + " *\n", + " * Copyright jQuery Foundation and other contributors\n", + " * Released under the MIT license\n", + " * http://jquery.org/license\n", + " */\n", + " function u(t){const e=getComputedStyle(t).fontSize;return null!=e?parseInt(e,10):null}l(),n.getDeltaY=function(t){let e=-t.deltaY;if(t.target instanceof HTMLElement)switch(t.deltaMode){case t.DOM_DELTA_LINE:e*=(n=t.target,null!==(a=null!==(o=u(null!==(l=n.offsetParent)&&void 0!==l?l:document.body))&&void 0!==o?o:u(n))&&void 0!==a?a:16);break;case t.DOM_DELTA_PAGE:e*=function(t){return t.clientHeight}(t.target)}var n,l,o,a;return e}},\n", + " function _(m,i,u,s,a){s(),a(\"Expression\",m(124).Expression),a(\"CustomJSExpr\",m(267).CustomJSExpr),a(\"Stack\",m(268).Stack),a(\"CumSum\",m(269).CumSum),a(\"ScalarExpression\",m(124).ScalarExpression),a(\"Minimum\",m(270).Minimum),a(\"Maximum\",m(271).Maximum)},\n", + " function _(t,e,s,n,r){n();const i=t(14),o=t(124),a=t(24),c=t(9),u=t(13),l=t(34),h=t(8);class p extends o.Expression{constructor(t){super(t)}static init_CustomJSExpr(){this.define((({Unknown:t,String:e,Dict:s})=>({args:[s(t),{}],code:[e,\"\"]})))}connect_signals(){super.connect_signals();for(const t of u.values(this.args))t instanceof i.HasProps&&t.change.connect((()=>{this._result.clear(),this.change.emit()}))}get names(){return u.keys(this.args)}get values(){return u.values(this.args)}get func(){const t=l.use_strict(this.code);return new a.GeneratorFunction(...this.names,t)}_v_compute(t){const e=this.func.apply(t,this.values);let s=e.next();if(s.done&&void 0!==s.value){const{value:e}=s;return h.isArray(e)||h.isTypedArray(e)?e:h.isIterable(e)?[...e]:c.repeat(e,t.length)}{const t=[];do{t.push(s.value),s=e.next()}while(!s.done);return t}}}s.CustomJSExpr=p,p.__name__=\"CustomJSExpr\",p.init_CustomJSExpr()},\n", + " function _(t,n,e,i,s){i();const a=t(124);class c extends a.Expression{constructor(t){super(t)}static init_Stack(){this.define((({String:t,Array:n})=>({fields:[n(t),[]]})))}_v_compute(t){var n;const e=null!==(n=t.get_length())&&void 0!==n?n:0,i=new Float64Array(e);for(const n of this.fields){const s=t.data[n];if(null!=s)for(let t=0,n=Math.min(e,s.length);t({field:[t],include_zero:[e,!1]})))}_v_compute(e){var t;const n=new Float64Array(null!==(t=e.get_length())&&void 0!==t?t:0),i=e.data[this.field],u=this.include_zero?1:0;n[0]=this.include_zero?0:i[0];for(let e=1;e({field:[n],initial:[t(i),null]})))}_compute(i){var n,t;const l=null!==(n=i.data[this.field])&&void 0!==n?n:[];return Math.min(null!==(t=this.initial)&&void 0!==t?t:1/0,m.min(l))}}t.Minimum=s,s.__name__=\"Minimum\",s.init_Minimum()},\n", + " function _(i,t,a,n,l){n();const u=i(124),e=i(9);class m extends u.ScalarExpression{constructor(i){super(i)}static init_Maximum(){this.define((({Number:i,String:t,Nullable:a})=>({field:[t],initial:[a(i),null]})))}_compute(i){var t,a;const n=null!==(t=i.data[this.field])&&void 0!==t?t:[];return Math.max(null!==(a=this.initial)&&void 0!==a?a:-1/0,e.max(n))}}a.Maximum=m,m.__name__=\"Maximum\",m.init_Maximum()},\n", + " function _(e,t,l,r,i){r(),i(\"BooleanFilter\",e(273).BooleanFilter),i(\"CustomJSFilter\",e(274).CustomJSFilter),i(\"Filter\",e(121).Filter),i(\"GroupFilter\",e(275).GroupFilter),i(\"IndexFilter\",e(276).IndexFilter)},\n", + " function _(e,n,l,o,t){o();const i=e(121),s=e(24);class a extends i.Filter{constructor(e){super(e)}static init_BooleanFilter(){this.define((({Boolean:e,Array:n,Nullable:l})=>({booleans:[l(n(e)),null]})))}compute_indices(e){const n=e.length,{booleans:l}=this;return null==l?s.Indices.all_set(n):s.Indices.from_booleans(n,l)}}l.BooleanFilter=a,a.__name__=\"BooleanFilter\",a.init_BooleanFilter()},\n", + " function _(e,t,s,n,r){n();const i=e(121),o=e(24),u=e(13),c=e(8),a=e(34);class l extends i.Filter{constructor(e){super(e)}static init_CustomJSFilter(){this.define((({Unknown:e,String:t,Dict:s})=>({args:[s(e),{}],code:[t,\"\"]})))}get names(){return u.keys(this.args)}get values(){return u.values(this.args)}get func(){const e=a.use_strict(this.code);return new Function(...this.names,\"source\",e)}compute_indices(e){const t=e.length,s=this.func(...this.values,e);if(null==s)return o.Indices.all_set(t);if(c.isArrayOf(s,c.isInteger))return o.Indices.from_indices(t,s);if(c.isArrayOf(s,c.isBoolean))return o.Indices.from_booleans(t,s);throw new Error(`expect an array of integers or booleans, or null, got ${s}`)}}s.CustomJSFilter=l,l.__name__=\"CustomJSFilter\",l.init_CustomJSFilter()},\n", + " function _(n,t,e,i,o){i();const r=n(121),u=n(24),s=n(19);class c extends r.Filter{constructor(n){super(n)}static init_GroupFilter(){this.define((({String:n})=>({column_name:[n],group:[n]})))}compute_indices(n){const t=n.get_column(this.column_name);if(null==t)return s.logger.warn(`${this}: groupby column '${this.column_name}' not found in the data source`),new u.Indices(n.length,1);{const e=new u.Indices(n.length);for(let n=0;n({indices:[i(n(e)),null]})))}compute_indices(e){const n=e.length,{indices:i}=this;return null==i?c.Indices.all_set(n):c.Indices.from_indices(n,i)}}i.IndexFilter=r,r.__name__=\"IndexFilter\",r.init_IndexFilter()},\n", + " function _(e,a,l,i,t){i(),t(\"AnnularWedge\",e(278).AnnularWedge),t(\"Annulus\",e(279).Annulus),t(\"Arc\",e(280).Arc),t(\"Bezier\",e(281).Bezier),t(\"Circle\",e(282).Circle),t(\"Ellipse\",e(286).Ellipse),t(\"EllipseOval\",e(287).EllipseOval),t(\"Glyph\",e(98).Glyph),t(\"HArea\",e(117).HArea),t(\"HBar\",e(289).HBar),t(\"HexTile\",e(291).HexTile),t(\"Image\",e(292).Image),t(\"ImageRGBA\",e(294).ImageRGBA),t(\"ImageURL\",e(295).ImageURL),t(\"Line\",e(63).Line),t(\"MultiLine\",e(127).MultiLine),t(\"MultiPolygons\",e(297).MultiPolygons),t(\"Oval\",e(298).Oval),t(\"Patch\",e(116).Patch),t(\"Patches\",e(128).Patches),t(\"Quad\",e(299).Quad),t(\"Quadratic\",e(300).Quadratic),t(\"Ray\",e(301).Ray),t(\"Rect\",e(302).Rect),t(\"Scatter\",e(303).Scatter),t(\"Segment\",e(306).Segment),t(\"Spline\",e(307).Spline),t(\"Step\",e(309).Step),t(\"Text\",e(310).Text),t(\"VArea\",e(119).VArea),t(\"VBar\",e(311).VBar),t(\"Wedge\",e(312).Wedge)},\n", + " function _(e,t,s,i,r){i();const n=e(1),a=e(64),o=e(106),_=e(48),d=e(24),u=e(20),h=n.__importStar(e(18)),l=e(10),c=e(59);class g extends a.XYGlyphView{_map_data(){\"data\"==this.model.properties.inner_radius.units?this.sinner_radius=this.sdist(this.renderer.xscale,this._x,this.inner_radius):this.sinner_radius=d.to_screen(this.inner_radius),\"data\"==this.model.properties.outer_radius.units?this.souter_radius=this.sdist(this.renderer.xscale,this._x,this.outer_radius):this.souter_radius=d.to_screen(this.outer_radius)}_render(e,t,s){const{sx:i,sy:r,start_angle:n,end_angle:a,sinner_radius:o,souter_radius:_}=null!=s?s:this,d=\"anticlock\"==this.model.direction;for(const s of t){const t=i[s],u=r[s],h=o[s],l=_[s],c=n.get(s),g=a.get(s);if(isNaN(t+u+h+l+c+g))continue;const x=g-c;e.translate(t,u),e.rotate(c),e.beginPath(),e.moveTo(l,0),e.arc(0,0,l,0,x,d),e.rotate(x),e.lineTo(h,0),e.arc(0,0,h,0,-x,!d),e.closePath(),e.rotate(-x-c),e.translate(-t,-u),this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(e,s),e.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_vectorize(e,s),e.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(e,s),e.stroke())}}_hit_point(e){const{sx:t,sy:s}=e,i=this.renderer.xscale.invert(t),r=this.renderer.yscale.invert(s);let n,a,o,_;if(\"data\"==this.model.properties.outer_radius.units)n=i-this.max_outer_radius,o=i+this.max_outer_radius,a=r-this.max_outer_radius,_=r+this.max_outer_radius;else{const e=t-this.max_outer_radius,i=t+this.max_outer_radius;[n,o]=this.renderer.xscale.r_invert(e,i);const r=s-this.max_outer_radius,d=s+this.max_outer_radius;[a,_]=this.renderer.yscale.r_invert(r,d)}const d=[];for(const e of this.index.indices({x0:n,x1:o,y0:a,y1:_})){const t=this.souter_radius[e]**2,s=this.sinner_radius[e]**2,[n,a]=this.renderer.xscale.r_compute(i,this._x[e]),[o,_]=this.renderer.yscale.r_compute(r,this._y[e]),u=(n-a)**2+(o-_)**2;u<=t&&u>=s&&d.push(e)}const u=\"anticlock\"==this.model.direction,h=[];for(const e of d){const i=Math.atan2(s-this.sy[e],t-this.sx[e]);l.angle_between(-i,-this.start_angle.get(e),-this.end_angle.get(e),u)&&h.push(e)}return new c.Selection({indices:h})}draw_legend_for_index(e,t,s){o.generic_area_vector_legend(this.visuals,e,t,s)}scenterxy(e){const t=(this.sinner_radius[e]+this.souter_radius[e])/2,s=(this.start_angle.get(e)+this.end_angle.get(e))/2;return[this.sx[e]+t*Math.cos(s),this.sy[e]+t*Math.sin(s)]}}s.AnnularWedgeView=g,g.__name__=\"AnnularWedgeView\";class x extends a.XYGlyph{constructor(e){super(e)}static init_AnnularWedge(){this.prototype.default_view=g,this.mixins([_.LineVector,_.FillVector,_.HatchVector]),this.define((({})=>({direction:[u.Direction,\"anticlock\"],inner_radius:[h.DistanceSpec,{field:\"inner_radius\"}],outer_radius:[h.DistanceSpec,{field:\"outer_radius\"}],start_angle:[h.AngleSpec,{field:\"start_angle\"}],end_angle:[h.AngleSpec,{field:\"end_angle\"}]})))}}s.AnnularWedge=x,x.__name__=\"AnnularWedge\",x.init_AnnularWedge()},\n", + " function _(s,i,t,e,r){e();const n=s(1),a=s(64),u=s(24),_=s(48),o=n.__importStar(s(18)),h=s(27),d=s(59);class c extends a.XYGlyphView{_map_data(){\"data\"==this.model.properties.inner_radius.units?this.sinner_radius=this.sdist(this.renderer.xscale,this._x,this.inner_radius):this.sinner_radius=u.to_screen(this.inner_radius),\"data\"==this.model.properties.outer_radius.units?this.souter_radius=this.sdist(this.renderer.xscale,this._x,this.outer_radius):this.souter_radius=u.to_screen(this.outer_radius)}_render(s,i,t){const{sx:e,sy:r,sinner_radius:n,souter_radius:a}=null!=t?t:this;for(const t of i){const i=e[t],_=r[t],o=n[t],d=a[t];function u(){if(s.beginPath(),h.is_ie)for(const t of[!1,!0])s.arc(i,_,o,0,Math.PI,t),s.arc(i,_,d,Math.PI,0,!t);else s.arc(i,_,o,0,2*Math.PI,!0),s.arc(i,_,d,2*Math.PI,0,!1)}isNaN(i+_+o+d)||(this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(s,t),u(),s.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_vectorize(s,t),u(),s.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(s,t),s.beginPath(),s.arc(i,_,o,0,2*Math.PI),s.moveTo(i+d,_),s.arc(i,_,d,0,2*Math.PI),s.stroke()))}}_hit_point(s){const{sx:i,sy:t}=s,e=this.renderer.xscale.invert(i),r=this.renderer.yscale.invert(t);let n,a,u,_;if(\"data\"==this.model.properties.outer_radius.units)n=e-this.max_outer_radius,u=e+this.max_outer_radius,a=r-this.max_outer_radius,_=r+this.max_outer_radius;else{const s=i-this.max_outer_radius,e=i+this.max_outer_radius;[n,u]=this.renderer.xscale.r_invert(s,e);const r=t-this.max_outer_radius,o=t+this.max_outer_radius;[a,_]=this.renderer.yscale.r_invert(r,o)}const o=[];for(const s of this.index.indices({x0:n,x1:u,y0:a,y1:_})){const i=this.souter_radius[s]**2,t=this.sinner_radius[s]**2,[n,a]=this.renderer.xscale.r_compute(e,this._x[s]),[u,_]=this.renderer.yscale.r_compute(r,this._y[s]),h=(n-a)**2+(u-_)**2;h<=i&&h>=t&&o.push(s)}return new d.Selection({indices:o})}draw_legend_for_index(s,{x0:i,y0:t,x1:e,y1:r},n){const a=n+1,u=new Array(a);u[n]=(i+e)/2;const _=new Array(a);_[n]=(t+r)/2;const o=.5*Math.min(Math.abs(e-i),Math.abs(r-t)),h=new Array(a);h[n]=.4*o;const d=new Array(a);d[n]=.8*o,this._render(s,[n],{sx:u,sy:_,sinner_radius:h,souter_radius:d})}}t.AnnulusView=c,c.__name__=\"AnnulusView\";class l extends a.XYGlyph{constructor(s){super(s)}static init_Annulus(){this.prototype.default_view=c,this.mixins([_.LineVector,_.FillVector,_.HatchVector]),this.define((({})=>({inner_radius:[o.DistanceSpec,{field:\"inner_radius\"}],outer_radius:[o.DistanceSpec,{field:\"outer_radius\"}]})))}}t.Annulus=l,l.__name__=\"Annulus\",l.init_Annulus()},\n", + " function _(e,i,s,t,n){t();const r=e(1),a=e(64),c=e(106),d=e(48),_=e(24),l=e(20),o=r.__importStar(e(18));class h extends a.XYGlyphView{_map_data(){\"data\"==this.model.properties.radius.units?this.sradius=this.sdist(this.renderer.xscale,this._x,this.radius):this.sradius=_.to_screen(this.radius)}_render(e,i,s){if(this.visuals.line.doit){const{sx:t,sy:n,sradius:r,start_angle:a,end_angle:c}=null!=s?s:this,d=\"anticlock\"==this.model.direction;for(const s of i){const i=t[s],_=n[s],l=r[s],o=a.get(s),h=c.get(s);isNaN(i+_+l+o+h)||(e.beginPath(),e.arc(i,_,l,o,h,d),this.visuals.line.set_vectorize(e,s),e.stroke())}}}draw_legend_for_index(e,i,s){c.generic_line_vector_legend(this.visuals,e,i,s)}}s.ArcView=h,h.__name__=\"ArcView\";class u extends a.XYGlyph{constructor(e){super(e)}static init_Arc(){this.prototype.default_view=h,this.mixins(d.LineVector),this.define((({})=>({direction:[l.Direction,\"anticlock\"],radius:[o.DistanceSpec,{field:\"radius\"}],start_angle:[o.AngleSpec,{field:\"start_angle\"}],end_angle:[o.AngleSpec,{field:\"end_angle\"}]})))}}s.Arc=u,u.__name__=\"Arc\",u.init_Arc()},\n", + " function _(e,t,i,s,n){s();const o=e(1),c=e(48),r=e(98),a=e(106),_=e(65),d=o.__importStar(e(18));function l(e,t,i,s,n,o,c,r){const a=[],_=[[],[]];for(let _=0;_<=2;_++){let d,l,x;if(0===_?(l=6*e-12*i+6*n,d=-3*e+9*i-9*n+3*c,x=3*i-3*e):(l=6*t-12*s+6*o,d=-3*t+9*s-9*o+3*r,x=3*s-3*t),Math.abs(d)<1e-12){if(Math.abs(l)<1e-12)continue;const e=-x/l;0({x0:[d.XCoordinateSpec,{field:\"x0\"}],y0:[d.YCoordinateSpec,{field:\"y0\"}],x1:[d.XCoordinateSpec,{field:\"x1\"}],y1:[d.YCoordinateSpec,{field:\"y1\"}],cx0:[d.XCoordinateSpec,{field:\"cx0\"}],cy0:[d.YCoordinateSpec,{field:\"cy0\"}],cx1:[d.XCoordinateSpec,{field:\"cx1\"}],cy1:[d.YCoordinateSpec,{field:\"cy1\"}]}))),this.mixins(c.LineVector)}}i.Bezier=h,h.__name__=\"Bezier\",h.init_Bezier()},\n", + " function _(s,i,e,t,r){t();const a=s(1),n=s(64),h=s(283),d=s(48),l=s(24),c=s(20),_=a.__importStar(s(107)),u=a.__importStar(s(18)),o=s(9),x=s(12),m=s(59);class y extends n.XYGlyphView{initialize(){super.initialize();const{webgl:s}=this.renderer.plot_view.canvas_view;null!=s&&(this.glglyph=new h.MarkerGL(s.gl,this,\"circle\"))}get use_radius(){return!(this.radius.is_Scalar()&&isNaN(this.radius.value))}_map_data(){if(this.use_radius)if(\"data\"==this.model.properties.radius.units)switch(this.model.radius_dimension){case\"x\":this.sradius=this.sdist(this.renderer.xscale,this._x,this.radius);break;case\"y\":this.sradius=this.sdist(this.renderer.yscale,this._y,this.radius);break;case\"max\":{const s=this.sdist(this.renderer.xscale,this._x,this.radius),i=this.sdist(this.renderer.yscale,this._y,this.radius);this.sradius=x.map(s,((s,e)=>Math.max(s,i[e])));break}case\"min\":{const s=this.sdist(this.renderer.xscale,this._x,this.radius),i=this.sdist(this.renderer.yscale,this._y,this.radius);this.sradius=x.map(s,((s,e)=>Math.min(s,i[e])));break}}else this.sradius=l.to_screen(this.radius),this._configure(\"max_size\",{value:2*this.max_radius});else{const s=new l.ScreenArray(this.size);this.sradius=x.map(s,(s=>s/2))}}_mask_data(){const{frame:s}=this.renderer.plot_view,i=s.x_target,e=s.y_target;let t,r;return this.use_radius&&\"data\"==this.model.properties.radius.units?(t=i.map((s=>this.renderer.xscale.invert(s))).widen(this.max_radius),r=e.map((s=>this.renderer.yscale.invert(s))).widen(this.max_radius)):(t=i.widen(this.max_size).map((s=>this.renderer.xscale.invert(s))),r=e.widen(this.max_size).map((s=>this.renderer.yscale.invert(s)))),this.index.indices({x0:t.start,x1:t.end,y0:r.start,y1:r.end})}_render(s,i,e){const{sx:t,sy:r,sradius:a}=null!=e?e:this;for(const e of i){const i=t[e],n=r[e],h=a[e];isNaN(i+n+h)||(s.beginPath(),s.arc(i,n,h,0,2*Math.PI,!1),this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(s,e),s.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_vectorize(s,e),s.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(s,e),s.stroke()))}}_hit_point(s){const{sx:i,sy:e}=s,t=this.renderer.xscale.invert(i),r=this.renderer.yscale.invert(e),{hit_dilation:a}=this.model;let n,h,d,l;if(this.use_radius&&\"data\"==this.model.properties.radius.units)n=t-this.max_radius*a,h=t+this.max_radius*a,d=r-this.max_radius*a,l=r+this.max_radius*a;else{const s=i-this.max_size*a,t=i+this.max_size*a;[n,h]=this.renderer.xscale.r_invert(s,t);const r=e-this.max_size*a,c=e+this.max_size*a;[d,l]=this.renderer.yscale.r_invert(r,c)}const c=this.index.indices({x0:n,x1:h,y0:d,y1:l}),_=[];if(this.use_radius&&\"data\"==this.model.properties.radius.units)for(const s of c){const i=(this.sradius[s]*a)**2,[e,n]=this.renderer.xscale.r_compute(t,this._x[s]),[h,d]=this.renderer.yscale.r_compute(r,this._y[s]);(e-n)**2+(h-d)**2<=i&&_.push(s)}else for(const s of c){const t=(this.sradius[s]*a)**2;(this.sx[s]-i)**2+(this.sy[s]-e)**2<=t&&_.push(s)}return new m.Selection({indices:_})}_hit_span(s){const{sx:i,sy:e}=s,t=this.bounds();let r,a,n,h;if(\"h\"==s.direction){let s,e;if(n=t.y0,h=t.y1,this.use_radius&&\"data\"==this.model.properties.radius.units)s=i-this.max_radius,e=i+this.max_radius,[r,a]=this.renderer.xscale.r_invert(s,e);else{const t=this.max_size/2;s=i-t,e=i+t,[r,a]=this.renderer.xscale.r_invert(s,e)}}else{let s,i;if(r=t.x0,a=t.x1,this.use_radius&&\"data\"==this.model.properties.radius.units)s=e-this.max_radius,i=e+this.max_radius,[n,h]=this.renderer.yscale.r_invert(s,i);else{const t=this.max_size/2;s=e-t,i=e+t,[n,h]=this.renderer.yscale.r_invert(s,i)}}const d=[...this.index.indices({x0:r,x1:a,y0:n,y1:h})];return new m.Selection({indices:d})}_hit_rect(s){const{sx0:i,sx1:e,sy0:t,sy1:r}=s,[a,n]=this.renderer.xscale.r_invert(i,e),[h,d]=this.renderer.yscale.r_invert(t,r),l=[...this.index.indices({x0:a,x1:n,y0:h,y1:d})];return new m.Selection({indices:l})}_hit_poly(s){const{sx:i,sy:e}=s,t=o.range(0,this.sx.length),r=[];for(let s=0,a=t.length;s({angle:[u.AngleSpec,0],size:[u.ScreenDistanceSpec,{value:4}],radius:[u.NullDistanceSpec,null],radius_dimension:[c.RadiusDimension,\"x\"],hit_dilation:[s,1]})))}}e.Circle=p,p.__name__=\"Circle\",p.init_Circle()},\n", + " function _(t,e,s,i,a){i();const r=t(1),o=t(109),_=t(113),l=r.__importDefault(t(284)),h=r.__importDefault(t(285)),n=t(282),f=t(12),u=t(19),c=t(24),g=t(22),b=t(11);function d(t,e,s,i,a,r,o){if(a.doit)if(r.is_Scalar()&&o.is_Scalar()){e.used=!1;const[i,a,_,l]=g.color2rgba(r.value,o.value);t.set_attribute(s,\"vec4\",[i/255,a/255,_/255,l/255])}else{let a;if(e.used=!0,r.is_Vector()){const t=new c.ColorArray(r.array);if(a=new c.RGBAArray(t.buffer),!o.is_Scalar()||1!=o.value)for(let t=0;t2*t))),i.data_changed=!1),this.visuals_changed&&(this._set_visuals(a),this.visuals_changed=!1),this.prog.set_uniform(\"u_pixel_ratio\",\"float\",[s.pixel_ratio]),this.prog.set_uniform(\"u_canvas_size\",\"vec2\",[s.width,s.height]),this.prog.set_attribute(\"a_sx\",\"float\",i.vbo_sx),this.prog.set_attribute(\"a_sy\",\"float\",i.vbo_sy),this.prog.set_attribute(\"a_size\",\"float\",i.vbo_s),this.prog.set_attribute(\"a_angle\",\"float\",i.vbo_a),0!=t.length)if(t.length===a)this.prog.draw(this.gl.POINTS,[0,a]);else if(a<65535){const e=window.navigator.userAgent;e.indexOf(\"MSIE \")+e.indexOf(\"Trident/\")+e.indexOf(\"Edge/\")>0&&u.logger.warn(\"WebGL warning: IE is known to produce 1px sprites whith selections.\"),this.index_buffer.set_size(2*t.length),this.index_buffer.set_data(0,new Uint16Array(t)),this.prog.draw(this.gl.POINTS,this.index_buffer)}else{const e=64e3,s=[];for(let t=0,i=Math.ceil(a/e);t2*t))):this.vbo_s.set_data(0,new Float32Array(this.glyph.size))}_set_visuals(t){const{line:e,fill:s}=this.glyph.visuals;!function(t,e,s,i,a,r){if(a.doit){if(r.is_Scalar())e.used=!1,t.set_attribute(s,\"float\",[r.value]);else if(r.is_Vector()){e.used=!0;const a=new Float32Array(r.array);e.set_size(4*i),e.set_data(0,a),t.set_attribute(s,\"float\",e)}}else e.used=!1,t.set_attribute(s,\"float\",[0])}(this.prog,this.vbo_linewidth,\"a_linewidth\",t,e,e.line_width),d(this.prog,this.vbo_fg_color,\"a_fg_color\",t,e,e.line_color,e.line_alpha),d(this.prog,this.vbo_bg_color,\"a_bg_color\",t,s,s.fill_color,s.fill_alpha),this.prog.set_uniform(\"u_antialias\",\"float\",[.8])}}s.MarkerGL=p,p.__name__=\"MarkerGL\"},\n", + " function _(n,i,a,o,_){o();a.default=\"\\nprecision mediump float;\\nconst float SQRT_2 = 1.4142135623730951;\\n//\\nuniform float u_pixel_ratio;\\nuniform vec2 u_canvas_size;\\nuniform vec2 u_offset;\\nuniform vec2 u_scale;\\nuniform float u_antialias;\\n//\\nattribute float a_sx;\\nattribute float a_sy;\\nattribute float a_size;\\nattribute float a_angle; // in radians\\nattribute float a_linewidth;\\nattribute vec4 a_fg_color;\\nattribute vec4 a_bg_color;\\n//\\nvarying float v_linewidth;\\nvarying float v_size;\\nvarying vec4 v_fg_color;\\nvarying vec4 v_bg_color;\\nvarying vec2 v_rotation;\\n\\nvoid main (void)\\n{\\n v_size = a_size * u_pixel_ratio;\\n v_linewidth = a_linewidth * u_pixel_ratio;\\n v_fg_color = a_fg_color;\\n v_bg_color = a_bg_color;\\n v_rotation = vec2(cos(-a_angle), sin(-a_angle));\\n vec2 pos = vec2(a_sx, a_sy); // in pixels\\n pos += 0.5; // make up for Bokeh's offset\\n pos /= u_canvas_size / u_pixel_ratio; // in 0..1\\n gl_Position = vec4(pos*2.0-1.0, 0.0, 1.0);\\n gl_Position.y *= -1.0;\\n gl_PointSize = SQRT_2 * v_size + 2.0 * (v_linewidth + 1.5*u_antialias);\\n}\\n\"},\n", + " function _(n,a,s,e,t){e();s.default='\\nprecision mediump float;\\n\\nconst float SQRT_2 = 1.4142135623730951;\\nconst float PI = 3.14159265358979323846264;\\n\\nconst float IN_ANGLE = 0.6283185307179586; // PI/5. = 36 degrees (star of 5 pikes)\\n//const float OUT_ANGLE = PI/2. - IN_ANGLE; // External angle for regular stars\\nconst float COS_A = 0.8090169943749475; // cos(IN_ANGLE)\\nconst float SIN_A = 0.5877852522924731; // sin(IN_ANGLE)\\nconst float COS_B = 0.5877852522924731; // cos(OUT_ANGLE)\\nconst float SIN_B = 0.8090169943749475; // sin(OUT_ANGLE)\\n\\n//\\nuniform float u_antialias;\\n//\\nvarying vec4 v_fg_color;\\nvarying vec4 v_bg_color;\\nvarying float v_linewidth;\\nvarying float v_size;\\nvarying vec2 v_rotation;\\n\\n#ifdef USE_ASTERISK\\n// asterisk\\nfloat marker(vec2 P, float size)\\n{\\n // Masks\\n float diamond = max(abs(SQRT_2 / 2.0 * (P.x - P.y)), abs(SQRT_2 / 2.0 * (P.x + P.y))) - size / (2.0 * SQRT_2);\\n float square = max(abs(P.x), abs(P.y)) - size / (2.0 * SQRT_2);\\n // Shapes\\n float X = min(abs(P.x - P.y), abs(P.x + P.y)) - size / 100.0; // bit of \"width\" for aa\\n float cross = min(abs(P.x), abs(P.y)) - size / 100.0; // bit of \"width\" for aa\\n // Result is union of masked shapes\\n return min(max(X, diamond), max(cross, square));\\n}\\n#endif\\n\\n#ifdef USE_CIRCLE\\n// circle\\nfloat marker(vec2 P, float size)\\n{\\n return length(P) - size/2.0;\\n}\\n#endif\\n\\n#ifdef USE_SQUARE\\n// square\\nfloat marker(vec2 P, float size)\\n{\\n return max(abs(P.x), abs(P.y)) - size/2.0;\\n}\\n#endif\\n\\n#ifdef USE_DIAMOND\\n// diamond\\nfloat marker(vec2 P, float size)\\n{\\n float x = SQRT_2 / 2.0 * (P.x * 1.5 - P.y);\\n float y = SQRT_2 / 2.0 * (P.x * 1.5 + P.y);\\n float r1 = max(abs(x), abs(y)) - size / (2.0 * SQRT_2);\\n return r1 / SQRT_2;\\n}\\n#endif\\n\\n#ifdef USE_HEX\\n// hex\\nfloat marker(vec2 P, float size)\\n{\\n vec2 q = abs(P);\\n return max(q.y * 0.57735 + q.x - 1.0 * size/2.0, q.y - 0.866 * size/2.0);\\n}\\n#endif\\n\\n#ifdef USE_STAR\\n// star\\n// https://iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm\\nfloat marker(vec2 P, float size)\\n{\\n float bn = mod(atan(P.x, -P.y), 2.0*IN_ANGLE) - IN_ANGLE;\\n P = length(P)*vec2(cos(bn), abs(sin(bn)));\\n P -= size*vec2(COS_A, SIN_A)/2.;\\n P += vec2(COS_B, SIN_B)*clamp(-(P.x*COS_B + P.y*SIN_B), 0.0, size*SIN_A/SIN_B/2.);\\n\\n return length(P)*sign(P.x);\\n}\\n#endif\\n\\n#ifdef USE_TRIANGLE\\n// triangle\\nfloat marker(vec2 P, float size)\\n{\\n P.y -= size * 0.3;\\n float x = SQRT_2 / 2.0 * (P.x * 1.7 - P.y);\\n float y = SQRT_2 / 2.0 * (P.x * 1.7 + P.y);\\n float r1 = max(abs(x), abs(y)) - size / 1.6;\\n float r2 = P.y;\\n return max(r1 / SQRT_2, r2); // Intersect diamond with rectangle\\n}\\n#endif\\n\\n#ifdef USE_INVERTED_TRIANGLE\\n// inverted_triangle\\nfloat marker(vec2 P, float size)\\n{\\n P.y += size * 0.3;\\n float x = SQRT_2 / 2.0 * (P.x * 1.7 - P.y);\\n float y = SQRT_2 / 2.0 * (P.x * 1.7 + P.y);\\n float r1 = max(abs(x), abs(y)) - size / 1.6;\\n float r2 = - P.y;\\n return max(r1 / SQRT_2, r2); // Intersect diamond with rectangle\\n}\\n#endif\\n\\n#ifdef USE_CROSS\\n// cross\\nfloat marker(vec2 P, float size)\\n{\\n float square = max(abs(P.x), abs(P.y)) - size / 2.5; // 2.5 is a tweak\\n float cross = min(abs(P.x), abs(P.y)) - size / 100.0; // bit of \"width\" for aa\\n return max(square, cross);\\n}\\n#endif\\n\\n#ifdef USE_CIRCLE_CROSS\\n// circle_cross\\nfloat marker(vec2 P, float size)\\n{\\n // Define quadrants\\n float qs = size / 2.0; // quadrant size\\n float s1 = max(abs(P.x - qs), abs(P.y - qs)) - qs;\\n float s2 = max(abs(P.x + qs), abs(P.y - qs)) - qs;\\n float s3 = max(abs(P.x - qs), abs(P.y + qs)) - qs;\\n float s4 = max(abs(P.x + qs), abs(P.y + qs)) - qs;\\n // Intersect main shape with quadrants (to form cross)\\n float circle = length(P) - size/2.0;\\n float c1 = max(circle, s1);\\n float c2 = max(circle, s2);\\n float c3 = max(circle, s3);\\n float c4 = max(circle, s4);\\n // Union\\n return min(min(min(c1, c2), c3), c4);\\n}\\n#endif\\n\\n#ifdef USE_SQUARE_CROSS\\n// square_cross\\nfloat marker(vec2 P, float size)\\n{\\n // Define quadrants\\n float qs = size / 2.0; // quadrant size\\n float s1 = max(abs(P.x - qs), abs(P.y - qs)) - qs;\\n float s2 = max(abs(P.x + qs), abs(P.y - qs)) - qs;\\n float s3 = max(abs(P.x - qs), abs(P.y + qs)) - qs;\\n float s4 = max(abs(P.x + qs), abs(P.y + qs)) - qs;\\n // Intersect main shape with quadrants (to form cross)\\n float square = max(abs(P.x), abs(P.y)) - size/2.0;\\n float c1 = max(square, s1);\\n float c2 = max(square, s2);\\n float c3 = max(square, s3);\\n float c4 = max(square, s4);\\n // Union\\n return min(min(min(c1, c2), c3), c4);\\n}\\n#endif\\n\\n#ifdef USE_DIAMOND_CROSS\\n// diamond_cross\\nfloat marker(vec2 P, float size)\\n{\\n // Define quadrants\\n float qs = size / 2.0; // quadrant size\\n float s1 = max(abs(P.x - qs), abs(P.y - qs)) - qs;\\n float s2 = max(abs(P.x + qs), abs(P.y - qs)) - qs;\\n float s3 = max(abs(P.x - qs), abs(P.y + qs)) - qs;\\n float s4 = max(abs(P.x + qs), abs(P.y + qs)) - qs;\\n // Intersect main shape with quadrants (to form cross)\\n float x = SQRT_2 / 2.0 * (P.x * 1.5 - P.y);\\n float y = SQRT_2 / 2.0 * (P.x * 1.5 + P.y);\\n float diamond = max(abs(x), abs(y)) - size / (2.0 * SQRT_2);\\n diamond /= SQRT_2;\\n float c1 = max(diamond, s1);\\n float c2 = max(diamond, s2);\\n float c3 = max(diamond, s3);\\n float c4 = max(diamond, s4);\\n // Union\\n return min(min(min(c1, c2), c3), c4);\\n}\\n#endif\\n\\n#ifdef USE_X\\n// x\\nfloat marker(vec2 P, float size)\\n{\\n float circle = length(P) - size / 1.6;\\n float X = min(abs(P.x - P.y), abs(P.x + P.y)) - size / 100.0; // bit of \"width\" for aa\\n return max(circle, X);\\n}\\n#endif\\n\\n#ifdef USE_CIRCLE_X\\n// circle_x\\nfloat marker(vec2 P, float size)\\n{\\n float x = P.x - P.y;\\n float y = P.x + P.y;\\n // Define quadrants\\n float qs = size / 2.0; // quadrant size\\n float s1 = max(abs(x - qs), abs(y - qs)) - qs;\\n float s2 = max(abs(x + qs), abs(y - qs)) - qs;\\n float s3 = max(abs(x - qs), abs(y + qs)) - qs;\\n float s4 = max(abs(x + qs), abs(y + qs)) - qs;\\n // Intersect main shape with quadrants (to form cross)\\n float circle = length(P) - size/2.0;\\n float c1 = max(circle, s1);\\n float c2 = max(circle, s2);\\n float c3 = max(circle, s3);\\n float c4 = max(circle, s4);\\n // Union\\n float almost = min(min(min(c1, c2), c3), c4);\\n // In this case, the X is also outside of the main shape\\n float Xmask = length(P) - size / 1.6; // a circle\\n float X = min(abs(P.x - P.y), abs(P.x + P.y)) - size / 100.0; // bit of \"width\" for aa\\n return min(max(X, Xmask), almost);\\n}\\n#endif\\n\\n#ifdef USE_SQUARE_X\\n// square_x\\nfloat marker(vec2 P, float size)\\n{\\n float x = P.x - P.y;\\n float y = P.x + P.y;\\n // Define quadrants\\n float qs = size / 2.0; // quadrant size\\n float s1 = max(abs(x - qs), abs(y - qs)) - qs;\\n float s2 = max(abs(x + qs), abs(y - qs)) - qs;\\n float s3 = max(abs(x - qs), abs(y + qs)) - qs;\\n float s4 = max(abs(x + qs), abs(y + qs)) - qs;\\n // Intersect main shape with quadrants (to form cross)\\n float square = max(abs(P.x), abs(P.y)) - size/2.0;\\n float c1 = max(square, s1);\\n float c2 = max(square, s2);\\n float c3 = max(square, s3);\\n float c4 = max(square, s4);\\n // Union\\n return min(min(min(c1, c2), c3), c4);\\n}\\n#endif\\n\\nvec4 outline(float distance, float linewidth, float antialias, vec4 fg_color, vec4 bg_color)\\n{\\n vec4 frag_color;\\n float t = linewidth/2.0 - antialias;\\n float signed_distance = distance;\\n float border_distance = abs(signed_distance) - t;\\n float alpha = border_distance/antialias;\\n alpha = exp(-alpha*alpha);\\n\\n // If fg alpha is zero, it probably means no outline. To avoid a dark outline\\n // shining through due to aa, we set the fg color to the bg color. Avoid if (i.e. branching).\\n float select = float(bool(fg_color.a));\\n fg_color.rgb = select * fg_color.rgb + (1.0 - select) * bg_color.rgb;\\n // Similarly, if we want a transparent bg\\n select = float(bool(bg_color.a));\\n bg_color.rgb = select * bg_color.rgb + (1.0 - select) * fg_color.rgb;\\n\\n if( border_distance < 0.0)\\n frag_color = fg_color;\\n else if( signed_distance < 0.0 ) {\\n frag_color = mix(bg_color, fg_color, sqrt(alpha));\\n } else {\\n if( abs(signed_distance) < (linewidth/2.0 + antialias) ) {\\n frag_color = vec4(fg_color.rgb, fg_color.a * alpha);\\n } else {\\n discard;\\n }\\n }\\n return frag_color;\\n}\\n\\nvoid main()\\n{\\n vec2 P = gl_PointCoord.xy - vec2(0.5, 0.5);\\n P = vec2(v_rotation.x*P.x - v_rotation.y*P.y,\\n v_rotation.y*P.x + v_rotation.x*P.y);\\n float point_size = SQRT_2*v_size + 2.0 * (v_linewidth + 1.5*u_antialias);\\n float distance = marker(P*point_size, v_size);\\n gl_FragColor = outline(distance, v_linewidth, u_antialias, v_fg_color, v_bg_color);\\n}\\n'},\n", + " function _(e,l,i,s,t){s();const _=e(287);class p extends _.EllipseOvalView{}i.EllipseView=p,p.__name__=\"EllipseView\";class n extends _.EllipseOval{constructor(e){super(e)}static init_Ellipse(){this.prototype.default_view=p}}i.Ellipse=n,n.__name__=\"Ellipse\",n.init_Ellipse()},\n", + " function _(t,s,i,e,h){e();const r=t(1),a=t(288),n=r.__importStar(t(107)),l=t(24),o=t(59),_=r.__importStar(t(18));class d extends a.CenterRotatableView{_map_data(){\"data\"==this.model.properties.width.units?this.sw=this.sdist(this.renderer.xscale,this._x,this.width,\"center\"):this.sw=l.to_screen(this.width),\"data\"==this.model.properties.height.units?this.sh=this.sdist(this.renderer.yscale,this._y,this.height,\"center\"):this.sh=l.to_screen(this.height)}_render(t,s,i){const{sx:e,sy:h,sw:r,sh:a,angle:n}=null!=i?i:this;for(const i of s){const s=e[i],l=h[i],o=r[i],_=a[i],d=n.get(i);isNaN(s+l+o+_+d)||(t.beginPath(),t.ellipse(s,l,o/2,_/2,d,0,2*Math.PI),this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(t,i),t.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_vectorize(t,i),t.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(t,i),t.stroke()))}}_hit_point(t){let s,i,e,h,r,a,l,_,d;const{sx:c,sy:w}=t,x=this.renderer.xscale.invert(c),p=this.renderer.yscale.invert(w);\"data\"==this.model.properties.width.units?(s=x-this.max_width,i=x+this.max_width):(a=c-this.max_width,l=c+this.max_width,[s,i]=this.renderer.xscale.r_invert(a,l)),\"data\"==this.model.properties.height.units?(e=p-this.max_height,h=p+this.max_height):(_=w-this.max_height,d=w+this.max_height,[e,h]=this.renderer.yscale.r_invert(_,d));const m=this.index.indices({x0:s,x1:i,y0:e,y1:h}),v=[];for(const t of m)r=n.point_in_ellipse(c,w,this.angle.get(t),this.sh[t]/2,this.sw[t]/2,this.sx[t],this.sy[t]),r&&v.push(t);return new o.Selection({indices:v})}draw_legend_for_index(t,{x0:s,y0:i,x1:e,y1:h},r){const a=r+1,n=new Array(a);n[r]=(s+e)/2;const l=new Array(a);l[r]=(i+h)/2;const o=this.sw[r]/this.sh[r],d=.8*Math.min(Math.abs(e-s),Math.abs(h-i)),c=new Array(a),w=new Array(a);o>1?(c[r]=d,w[r]=d/o):(c[r]=d*o,w[r]=d);const x=new _.UniformScalar(0,a);this._render(t,[r],{sx:n,sy:l,sw:c,sh:w,angle:x})}}i.EllipseOvalView=d,d.__name__=\"EllipseOvalView\";class c extends a.CenterRotatable{constructor(t){super(t)}}i.EllipseOval=c,c.__name__=\"EllipseOval\"},\n", + " function _(t,e,i,a,n){a();const s=t(1),h=t(64),r=t(48),o=s.__importStar(t(18));class _ extends h.XYGlyphView{get max_w2(){return\"data\"==this.model.properties.width.units?this.max_width/2:0}get max_h2(){return\"data\"==this.model.properties.height.units?this.max_height/2:0}_bounds({x0:t,x1:e,y0:i,y1:a}){const{max_w2:n,max_h2:s}=this;return{x0:t-n,x1:e+n,y0:i-s,y1:a+s}}}i.CenterRotatableView=_,_.__name__=\"CenterRotatableView\";class l extends h.XYGlyph{constructor(t){super(t)}static init_CenterRotatable(){this.mixins([r.LineVector,r.FillVector,r.HatchVector]),this.define((({})=>({angle:[o.AngleSpec,0],width:[o.DistanceSpec,{field:\"width\"}],height:[o.DistanceSpec,{field:\"height\"}]})))}}i.CenterRotatable=l,l.__name__=\"CenterRotatable\",l.init_CenterRotatable()},\n", + " function _(t,e,s,i,h){i();const r=t(1),a=t(290),n=t(24),_=r.__importStar(t(18));class o extends a.BoxView{scenterxy(t){return[(this.sleft[t]+this.sright[t])/2,this.sy[t]]}_lrtb(t){const e=this._left[t],s=this._right[t],i=this._y[t],h=this.height.get(t)/2;return[Math.min(e,s),Math.max(e,s),i+h,i-h]}_map_data(){this.sy=this.renderer.yscale.v_compute(this._y),this.sh=this.sdist(this.renderer.yscale,this._y,this.height,\"center\"),this.sleft=this.renderer.xscale.v_compute(this._left),this.sright=this.renderer.xscale.v_compute(this._right);const t=this.sy.length;this.stop=new n.ScreenArray(t),this.sbottom=new n.ScreenArray(t);for(let e=0;e({left:[_.XCoordinateSpec,{value:0}],y:[_.YCoordinateSpec,{field:\"y\"}],height:[_.NumberSpec,{value:1}],right:[_.XCoordinateSpec,{field:\"right\"}]})))}}s.HBar=c,c.__name__=\"HBar\",c.init_HBar()},\n", + " function _(t,e,s,i,r){i();const n=t(48),o=t(98),a=t(106),h=t(59);class c extends o.GlyphView{get_anchor_point(t,e,s){const i=Math.min(this.sleft[e],this.sright[e]),r=Math.max(this.sright[e],this.sleft[e]),n=Math.min(this.stop[e],this.sbottom[e]),o=Math.max(this.sbottom[e],this.stop[e]);switch(t){case\"top_left\":return{x:i,y:n};case\"top\":case\"top_center\":return{x:(i+r)/2,y:n};case\"top_right\":return{x:r,y:n};case\"bottom_left\":return{x:i,y:o};case\"bottom\":case\"bottom_center\":return{x:(i+r)/2,y:o};case\"bottom_right\":return{x:r,y:o};case\"left\":case\"center_left\":return{x:i,y:(n+o)/2};case\"center\":case\"center_center\":return{x:(i+r)/2,y:(n+o)/2};case\"right\":case\"center_right\":return{x:r,y:(n+o)/2}}}_index_data(t){const{min:e,max:s}=Math,{data_size:i}=this;for(let r=0;r({r:[c.NumberSpec,{field:\"r\"}],q:[c.NumberSpec,{field:\"q\"}],scale:[c.NumberSpec,1],size:[e,1],aspect_scale:[e,1],orientation:[h.HexTileOrientation,\"pointytop\"]}))),this.override({line_color:null})}}s.HexTile=y,y.__name__=\"HexTile\",y.init_HexTile()},\n", + " function _(e,a,t,_,s){_();const i=e(293),n=e(203),r=e(214);class o extends i.ImageBaseView{connect_signals(){super.connect_signals(),this.connect(this.model.color_mapper.change,(()=>this._update_image()))}_update_image(){null!=this.image_data&&(this._set_data(null),this.renderer.request_render())}_flat_img_to_buf8(e){return this.model.color_mapper.rgba_mapper.v_compute(e)}}t.ImageView=o,o.__name__=\"ImageView\";class m extends i.ImageBase{constructor(e){super(e)}static init_Image(){this.prototype.default_view=o,this.define((({Ref:e})=>({color_mapper:[e(n.ColorMapper),()=>new r.LinearColorMapper({palette:[\"#000000\",\"#252525\",\"#525252\",\"#737373\",\"#969696\",\"#bdbdbd\",\"#d9d9d9\",\"#f0f0f0\",\"#ffffff\"]})]})))}}t.Image=m,m.__name__=\"Image\",m.init_Image()},\n", + " function _(e,t,i,s,a){s();const h=e(1),n=e(64),r=e(24),_=h.__importStar(e(18)),d=e(59),l=e(9),g=e(29),o=e(11);class c extends n.XYGlyphView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.global_alpha.change,(()=>this.renderer.request_render()))}_render(e,t,i){const{image_data:s,sx:a,sy:h,sw:n,sh:r}=null!=i?i:this,_=e.getImageSmoothingEnabled();e.setImageSmoothingEnabled(!1),e.globalAlpha=this.model.global_alpha;for(const i of t){const t=s[i],_=a[i],d=h[i],l=n[i],g=r[i];if(null==t||isNaN(_+d+l+g))continue;const o=d;e.translate(0,o),e.scale(1,-1),e.translate(0,-o),e.drawImage(t,0|_,0|d,l,g),e.translate(0,o),e.scale(1,-1),e.translate(0,-o)}e.setImageSmoothingEnabled(_)}_set_data(e){this._set_width_heigh_data();for(let t=0,i=this.image.length;t({image:[_.NDArraySpec,{field:\"image\"}],dw:[_.DistanceSpec,{field:\"dw\"}],dh:[_.DistanceSpec,{field:\"dh\"}],dilate:[e,!1],global_alpha:[t,1]})))}}i.ImageBase=m,m.__name__=\"ImageBase\",m.init_ImageBase()},\n", + " function _(e,a,t,_,i){_();const n=e(293),s=e(8);class r extends n.ImageBaseView{_flat_img_to_buf8(e){let a;return a=s.isArray(e)?new Uint32Array(e):e,new Uint8ClampedArray(a.buffer)}}t.ImageRGBAView=r,r.__name__=\"ImageRGBAView\";class m extends n.ImageBase{constructor(e){super(e)}static init_ImageRGBA(){this.prototype.default_view=r}}t.ImageRGBA=m,m.__name__=\"ImageRGBA\",m.init_ImageRGBA()},\n", + " function _(e,t,s,r,a){r();const i=e(1),n=e(64),o=e(24),c=e(20),_=i.__importStar(e(18)),h=e(12),l=e(296);class d extends n.XYGlyphView{constructor(){super(...arguments),this._images_rendered=!1,this._set_data_iteration=0}connect_signals(){super.connect_signals(),this.connect(this.model.properties.global_alpha.change,(()=>this.renderer.request_render()))}_index_data(e){const{data_size:t}=this;for(let s=0;s{this._set_data_iteration==r&&(this.image[a]=e,this.renderer.request_render())},attempts:t+1,timeout:s})}const a=\"data\"==this.model.properties.w.units,i=\"data\"==this.model.properties.h.units,n=this._x.length,c=new o.ScreenArray(a?2*n:n),_=new o.ScreenArray(i?2*n:n),{anchor:d}=this.model;function m(e,t){switch(d){case\"top_left\":case\"bottom_left\":case\"left\":case\"center_left\":return[e,e+t];case\"top\":case\"top_center\":case\"bottom\":case\"bottom_center\":case\"center\":case\"center_center\":return[e-t/2,e+t/2];case\"top_right\":case\"bottom_right\":case\"right\":case\"center_right\":return[e-t,e]}}function g(e,t){switch(d){case\"top_left\":case\"top\":case\"top_center\":case\"top_right\":return[e,e-t];case\"bottom_left\":case\"bottom\":case\"bottom_center\":case\"bottom_right\":return[e+t,e];case\"left\":case\"center_left\":case\"center\":case\"center_center\":case\"right\":case\"center_right\":return[e+t/2,e-t/2]}}if(a)for(let e=0;e({url:[_.StringSpec,{field:\"url\"}],anchor:[c.Anchor,\"top_left\"],global_alpha:[s,1],angle:[_.AngleSpec,0],w:[_.NullDistanceSpec,null],h:[_.NullDistanceSpec,null],dilate:[e,!1],retry_attempts:[t,0],retry_timeout:[t,0]})))}}s.ImageURL=m,m.__name__=\"ImageURL\",m.init_ImageURL()},\n", + " function _(i,e,t,s,o){s();const a=i(19);class n{constructor(i,e={}){this._image=new Image,this._finished=!1;const{attempts:t=1,timeout:s=1}=e;this.promise=new Promise(((o,n)=>{this._image.crossOrigin=\"anonymous\";let r=0;this._image.onerror=()=>{if(++r==t){const s=`unable to load ${i} image after ${t} attempts`;if(a.logger.warn(s),null==this._image.crossOrigin)return void(null!=e.failed&&e.failed());a.logger.warn(`attempting to load ${i} without a cross origin policy`),this._image.crossOrigin=null,r=0}setTimeout((()=>this._image.src=i),s)},this._image.onload=()=>{this._finished=!0,null!=e.loaded&&e.loaded(this._image),o(this._image)},this._image.src=i}))}get finished(){return this._finished}get image(){if(this._finished)return this._image;throw new Error(\"not loaded yet\")}}t.ImageLoader=n,n.__name__=\"ImageLoader\"},\n", + " function _(t,s,e,i,n){i();const o=t(1),l=t(101),r=t(98),h=t(106),_=t(12),a=t(12),c=t(48),d=o.__importStar(t(107)),x=o.__importStar(t(18)),y=t(59),f=t(11);class g extends r.GlyphView{_project_data(){}_index_data(t){const{min:s,max:e}=Math,{data_size:i}=this;for(let n=0;n1&&c.length>1)for(let e=1,i=n.length;e1){let l=!1;for(let t=1;t({xs:[x.XCoordinateSeqSeqSeqSpec,{field:\"xs\"}],ys:[x.YCoordinateSeqSeqSeqSpec,{field:\"ys\"}]}))),this.mixins([c.LineVector,c.FillVector,c.HatchVector])}}e.MultiPolygons=p,p.__name__=\"MultiPolygons\",p.init_MultiPolygons()},\n", + " function _(a,t,e,l,s){l();const _=a(287),i=a(12);class n extends _.EllipseOvalView{_map_data(){super._map_data(),i.mul(this.sw,.75)}}e.OvalView=n,n.__name__=\"OvalView\";class v extends _.EllipseOval{constructor(a){super(a)}static init_Oval(){this.prototype.default_view=n}}e.Oval=v,v.__name__=\"Oval\",v.init_Oval()},\n", + " function _(t,e,i,o,s){o();const r=t(1),_=t(290),d=r.__importStar(t(18));class n extends _.BoxView{scenterxy(t){return[this.sleft[t]/2+this.sright[t]/2,this.stop[t]/2+this.sbottom[t]/2]}_lrtb(t){return[this._left[t],this._right[t],this._top[t],this._bottom[t]]}}i.QuadView=n,n.__name__=\"QuadView\";class a extends _.Box{constructor(t){super(t)}static init_Quad(){this.prototype.default_view=n,this.define((({})=>({right:[d.XCoordinateSpec,{field:\"right\"}],bottom:[d.YCoordinateSpec,{field:\"bottom\"}],left:[d.XCoordinateSpec,{field:\"left\"}],top:[d.YCoordinateSpec,{field:\"top\"}]})))}}i.Quad=a,a.__name__=\"Quad\",a.init_Quad()},\n", + " function _(e,t,i,s,n){s();const a=e(1),c=e(48),o=e(65),r=e(98),_=e(106),d=a.__importStar(e(18));function l(e,t,i){if(t==(e+i)/2)return[e,i];{const s=(e-t)/(e-2*t+i),n=e*(1-s)**2+2*t*(1-s)*s+i*s**2;return[Math.min(e,i,n),Math.max(e,i,n)]}}class x extends r.GlyphView{_project_data(){o.inplace.project_xy(this._x0,this._y0),o.inplace.project_xy(this._x1,this._y1)}_index_data(e){const{_x0:t,_x1:i,_y0:s,_y1:n,_cx:a,_cy:c,data_size:o}=this;for(let r=0;r({x0:[d.XCoordinateSpec,{field:\"x0\"}],y0:[d.YCoordinateSpec,{field:\"y0\"}],x1:[d.XCoordinateSpec,{field:\"x1\"}],y1:[d.YCoordinateSpec,{field:\"y1\"}],cx:[d.XCoordinateSpec,{field:\"cx\"}],cy:[d.YCoordinateSpec,{field:\"cy\"}]}))),this.mixins(c.LineVector)}}i.Quadratic=y,y.__name__=\"Quadratic\",y.init_Quadratic()},\n", + " function _(e,t,s,i,n){i();const a=e(1),l=e(64),h=e(106),r=e(48),o=e(24),_=a.__importStar(e(18));class c extends l.XYGlyphView{_map_data(){\"data\"==this.model.properties.length.units?this.slength=this.sdist(this.renderer.xscale,this._x,this.length):this.slength=o.to_screen(this.length);const{width:e,height:t}=this.renderer.plot_view.frame.bbox,s=2*(e+t),{slength:i}=this;for(let e=0,t=i.length;e({length:[_.DistanceSpec,0],angle:[_.AngleSpec,0]})))}}s.Ray=g,g.__name__=\"Ray\",g.init_Ray()},\n", + " function _(t,s,e,i,h){i();const r=t(288),n=t(106),a=t(24),o=t(12),l=t(59);class _ extends r.CenterRotatableView{_map_data(){if(\"data\"==this.model.properties.width.units)[this.sw,this.sx0]=this._map_dist_corner_for_data_side_length(this._x,this.width,this.renderer.xscale);else{this.sw=a.to_screen(this.width);const t=this.sx.length;this.sx0=new a.ScreenArray(t);for(let s=0;s({dilate:[t,!1]})))}}e.Rect=c,c.__name__=\"Rect\",c.init_Rect()},\n", + " function _(e,t,r,s,i){s();const a=e(1),n=e(304),_=e(305),l=e(283),c=a.__importStar(e(18));class o extends n.MarkerView{_init_webgl(){const{webgl:e}=this.renderer.plot_view.canvas_view;if(null!=e){const t=new Set(this.marker);if(1==t.size){const[r]=[...t];if(l.MarkerGL.is_supported(r)){const{glglyph:t}=this;if(null==t||t.marker_type!=r)return void(this.glglyph=new l.MarkerGL(e.gl,this,r))}}}delete this.glglyph}_set_data(e){super._set_data(e),this._init_webgl()}_render(e,t,r){const{sx:s,sy:i,size:a,angle:n,marker:l}=null!=r?r:this;for(const r of t){const t=s[r],c=i[r],o=a.get(r),g=n.get(r),h=l.get(r);if(isNaN(t+c+o+g)||null==h)continue;const d=o/2;e.beginPath(),e.translate(t,c),g&&e.rotate(g),_.marker_funcs[h](e,r,d,this.visuals),g&&e.rotate(-g),e.translate(-t,-c)}}draw_legend_for_index(e,{x0:t,x1:r,y0:s,y1:i},a){const n=a+1,_=this.marker.get(a),l=Object.assign(Object.assign({},this._get_legend_args({x0:t,x1:r,y0:s,y1:i},a)),{marker:new c.UniformScalar(_,n)});this._render(e,[a],l)}}r.ScatterView=o,o.__name__=\"ScatterView\";class g extends n.Marker{constructor(e){super(e)}static init_Scatter(){this.prototype.default_view=o,this.define((()=>({marker:[c.MarkerSpec,{value:\"circle\"}]})))}}r.Scatter=g,g.__name__=\"Scatter\",g.init_Scatter()},\n", + " function _(e,t,s,i,n){i();const r=e(1),a=e(64),c=e(48),_=r.__importStar(e(107)),o=r.__importStar(e(18)),h=e(9),l=e(59);class x extends a.XYGlyphView{_render(e,t,s){const{sx:i,sy:n,size:r,angle:a}=null!=s?s:this;for(const s of t){const t=i[s],c=n[s],_=r.get(s),o=a.get(s);if(isNaN(t+c+_+o))continue;const h=_/2;e.beginPath(),e.translate(t,c),o&&e.rotate(o),this._render_one(e,s,h,this.visuals),o&&e.rotate(-o),e.translate(-t,-c)}}_mask_data(){const{x_target:e,y_target:t}=this.renderer.plot_view.frame,s=e.widen(this.max_size).map((e=>this.renderer.xscale.invert(e))),i=t.widen(this.max_size).map((e=>this.renderer.yscale.invert(e)));return this.index.indices({x0:s.start,x1:s.end,y0:i.start,y1:i.end})}_hit_point(e){const{sx:t,sy:s}=e,{max_size:i}=this,{hit_dilation:n}=this.model,r=t-i*n,a=t+i*n,[c,_]=this.renderer.xscale.r_invert(r,a),o=s-i*n,h=s+i*n,[x,d]=this.renderer.yscale.r_invert(o,h),y=this.index.indices({x0:c,x1:_,y0:x,y1:d}),g=[];for(const e of y){const i=this.size.get(e)/2*n;Math.abs(this.sx[e]-t)<=i&&Math.abs(this.sy[e]-s)<=i&&g.push(e)}return new l.Selection({indices:g})}_hit_span(e){const{sx:t,sy:s}=e,i=this.bounds(),n=this.max_size/2;let r,a,c,_;if(\"h\"==e.direction){c=i.y0,_=i.y1;const e=t-n,s=t+n;[r,a]=this.renderer.xscale.r_invert(e,s)}else{r=i.x0,a=i.x1;const e=s-n,t=s+n;[c,_]=this.renderer.yscale.r_invert(e,t)}const o=[...this.index.indices({x0:r,x1:a,y0:c,y1:_})];return new l.Selection({indices:o})}_hit_rect(e){const{sx0:t,sx1:s,sy0:i,sy1:n}=e,[r,a]=this.renderer.xscale.r_invert(t,s),[c,_]=this.renderer.yscale.r_invert(i,n),o=[...this.index.indices({x0:r,x1:a,y0:c,y1:_})];return new l.Selection({indices:o})}_hit_poly(e){const{sx:t,sy:s}=e,i=h.range(0,this.sx.length),n=[];for(let e=0,r=i.length;e({size:[o.ScreenDistanceSpec,{value:4}],angle:[o.AngleSpec,0],hit_dilation:[e,1]})))}}s.Marker=d,d.__name__=\"Marker\",d.init_Marker()},\n", + " function _(t,e,i,o,l){o();const n=Math.sqrt(3),c=Math.sqrt(5),r=(c+1)/4,s=Math.sqrt((5-c)/8),f=(c-1)/4,a=Math.sqrt((5+c)/8);function h(t,e){t.rotate(Math.PI/4),d(t,e),t.rotate(-Math.PI/4)}function v(t,e){const i=e*n,o=i/3;t.moveTo(-i/2,-o),t.lineTo(0,0),t.lineTo(i/2,-o),t.lineTo(0,0),t.lineTo(0,e)}function d(t,e){t.moveTo(0,e),t.lineTo(0,-e),t.moveTo(-e,0),t.lineTo(e,0)}function _(t,e){t.moveTo(0,e),t.lineTo(e/1.5,0),t.lineTo(0,-e),t.lineTo(-e/1.5,0),t.closePath()}function u(t,e){const i=e*n,o=i/3;t.moveTo(-e,o),t.lineTo(e,o),t.lineTo(0,o-i),t.closePath()}function z(t,e,i,o){t.arc(0,0,i,0,2*Math.PI,!1),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}function T(t,e,i,o){_(t,i),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}function k(t,e,i,o){!function(t,e){t.beginPath(),t.arc(0,0,e/4,0,2*Math.PI,!1),t.closePath()}(t,i),o.line.set_vectorize(t,e),t.fillStyle=t.strokeStyle,t.fill()}function P(t,e,i,o){!function(t,e){const i=e/2,o=n*i;t.moveTo(e,0),t.lineTo(i,-o),t.lineTo(-i,-o),t.lineTo(-e,0),t.lineTo(-i,o),t.lineTo(i,o),t.closePath()}(t,i),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}function m(t,e,i,o){const l=2*i;t.rect(-i,-i,l,l),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}function q(t,e,i,o){!function(t,e){const i=Math.sqrt(5-2*c)*e;t.moveTo(0,-e),t.lineTo(i*f,i*a-e),t.lineTo(i*(1+f),i*a-e),t.lineTo(i*(1+f-r),i*(a+s)-e),t.lineTo(i*(1+2*f-r),i*(2*a+s)-e),t.lineTo(0,2*i*a-e),t.lineTo(-i*(1+2*f-r),i*(2*a+s)-e),t.lineTo(-i*(1+f-r),i*(a+s)-e),t.lineTo(-i*(1+f),i*a-e),t.lineTo(-i*f,i*a-e),t.closePath()}(t,i),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}function M(t,e,i,o){u(t,i),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}i.marker_funcs={asterisk:function(t,e,i,o){d(t,i),h(t,i),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},circle:z,circle_cross:function(t,e,i,o){t.arc(0,0,i,0,2*Math.PI,!1),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),d(t,i),t.stroke())},circle_dot:function(t,e,i,o){z(t,e,i,o),k(t,e,i,o)},circle_y:function(t,e,i,o){t.arc(0,0,i,0,2*Math.PI,!1),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),v(t,i),t.stroke())},circle_x:function(t,e,i,o){t.arc(0,0,i,0,2*Math.PI,!1),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),h(t,i),t.stroke())},cross:function(t,e,i,o){d(t,i),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},diamond:T,diamond_dot:function(t,e,i,o){T(t,e,i,o),k(t,e,i,o)},diamond_cross:function(t,e,i,o){_(t,i),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.moveTo(0,i),t.lineTo(0,-i),t.moveTo(-i/1.5,0),t.lineTo(i/1.5,0),t.stroke())},dot:k,hex:P,hex_dot:function(t,e,i,o){P(t,e,i,o),k(t,e,i,o)},inverted_triangle:function(t,e,i,o){t.rotate(Math.PI),u(t,i),t.rotate(-Math.PI),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},plus:function(t,e,i,o){const l=3*i/8,n=[l,l,i,i,l,l,-l,-l,-i,-i,-l,-l],c=[i,l,l,-l,-l,-i,-i,-l,-l,l,l,i];t.beginPath();for(let e=0;e<12;e++)t.lineTo(n[e],c[e]);t.closePath(),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},square:m,square_cross:function(t,e,i,o){const l=2*i;t.rect(-i,-i,l,l),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),d(t,i),t.stroke())},square_dot:function(t,e,i,o){m(t,e,i,o),k(t,e,i,o)},square_pin:function(t,e,i,o){const l=3*i/8;t.moveTo(-i,-i),t.quadraticCurveTo(0,-l,i,-i),t.quadraticCurveTo(l,0,i,i),t.quadraticCurveTo(0,l,-i,i),t.quadraticCurveTo(-l,0,-i,-i),t.closePath(),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},square_x:function(t,e,i,o){const l=2*i;t.rect(-i,-i,l,l),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.moveTo(-i,i),t.lineTo(i,-i),t.moveTo(-i,-i),t.lineTo(i,i),t.stroke())},star:q,star_dot:function(t,e,i,o){q(t,e,i,o),k(t,e,i,o)},triangle:M,triangle_dot:function(t,e,i,o){M(t,e,i,o),k(t,e,i,o)},triangle_pin:function(t,e,i,o){const l=i*n,c=l/3,r=3*c/8;t.moveTo(-i,c),t.quadraticCurveTo(0,r,i,c),t.quadraticCurveTo(n*r/2,r/2,0,c-l),t.quadraticCurveTo(-n*r/2,r/2,-i,c),t.closePath(),o.fill.doit&&(o.fill.set_vectorize(t,e),t.fill()),o.hatch.doit&&(o.hatch.set_vectorize(t,e),t.fill()),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},dash:function(t,e,i,o){!function(t,e){t.moveTo(-e,0),t.lineTo(e,0)}(t,i),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},x:function(t,e,i,o){h(t,i),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())},y:function(t,e,i,o){v(t,i),o.line.doit&&(o.line.set_vectorize(t,e),t.stroke())}}},\n", + " function _(e,t,s,i,n){i();const r=e(1),_=r.__importStar(e(107)),o=r.__importStar(e(18)),h=e(48),a=e(65),c=e(98),d=e(106),x=e(59);class y extends c.GlyphView{_project_data(){a.inplace.project_xy(this._x0,this._y0),a.inplace.project_xy(this._x1,this._y1)}_index_data(e){const{min:t,max:s}=Math,{_x0:i,_x1:n,_y0:r,_y1:_,data_size:o}=this;for(let h=0;h({x0:[o.XCoordinateSpec,{field:\"x0\"}],y0:[o.YCoordinateSpec,{field:\"y0\"}],x1:[o.XCoordinateSpec,{field:\"x1\"}],y1:[o.YCoordinateSpec,{field:\"y1\"}]}))),this.mixins(h.LineVector)}}s.Segment=l,l.__name__=\"Segment\",l.init_Segment()},\n", + " function _(t,e,s,i,n){i();const _=t(1),l=t(64),o=_.__importStar(t(48)),a=t(308);class c extends l.XYGlyphView{_set_data(){const{tension:t,closed:e}=this.model;[this._xt,this._yt]=a.catmullrom_spline(this._x,this._y,20,t,e)}_map_data(){const{x_scale:t,y_scale:e}=this.renderer.coordinates;this.sxt=t.v_compute(this._xt),this.syt=e.v_compute(this._yt)}_render(t,e,s){const{sxt:i,syt:n}=null!=s?s:this;this.visuals.line.set_value(t);const _=i.length;for(let e=0;e<_;e++)0!=e?isNaN(i[e])||isNaN(n[e])?(t.stroke(),t.beginPath()):t.lineTo(i[e],n[e]):(t.beginPath(),t.moveTo(i[e],n[e]));t.stroke()}}s.SplineView=c,c.__name__=\"SplineView\";class h extends l.XYGlyph{constructor(t){super(t)}static init_Spline(){this.prototype.default_view=c,this.mixins(o.LineScalar),this.define((({Boolean:t,Number:e})=>({tension:[e,.5],closed:[t,!1]})))}}s.Spline=h,h.__name__=\"Spline\",h.init_Spline()},\n", + " function _(n,t,e,o,s){o();const c=n(24),l=n(11);e.catmullrom_spline=function(n,t,e=10,o=.5,s=!1){l.assert(n.length==t.length);const r=n.length,f=s?r+1:r,w=c.infer_type(n,t),i=new w(f+2),u=new w(f+2);i.set(n,1),u.set(t,1),s?(i[0]=n[r-1],u[0]=t[r-1],i[f]=n[0],u[f]=t[0],i[f+1]=n[1],u[f+1]=t[1]):(i[0]=n[0],u[0]=t[0],i[f+1]=n[r-1],u[f+1]=t[r-1]);const g=new w(4*(e+1));for(let n=0,t=0;n<=e;n++){const o=n/e,s=o**2,c=o*s;g[t++]=2*c-3*s+1,g[t++]=-2*c+3*s,g[t++]=c-2*s+o,g[t++]=c-s}const h=new w((f-1)*(e+1)),_=new w((f-1)*(e+1));for(let n=1,t=0;n1&&(e.stroke(),o=!1)}o?(e.lineTo(t,a),e.lineTo(r,_)):(e.beginPath(),e.moveTo(n[i],s[i]),o=!0),l=i}e.lineTo(n[r-1],s[r-1]),e.stroke()}}draw_legend_for_index(e,t,i){r.generic_line_scalar_legend(this.visuals,e,t)}}i.StepView=c,c.__name__=\"StepView\";class d extends l.XYGlyph{constructor(e){super(e)}static init_Step(){this.prototype.default_view=c,this.mixins(a.LineScalar),this.define((()=>({mode:[_.StepMode,\"before\"]})))}}i.Step=d,d.__name__=\"Step\",d.init_Step()},\n", + " function _(t,e,s,i,n){i();const o=t(1),_=t(64),h=t(48),l=o.__importStar(t(107)),r=o.__importStar(t(18)),a=t(143),c=t(11),x=t(59);class u extends _.XYGlyphView{_rotate_point(t,e,s,i,n){return[(t-s)*Math.cos(n)-(e-i)*Math.sin(n)+s,(t-s)*Math.sin(n)+(e-i)*Math.cos(n)+i]}_text_bounds(t,e,s,i){return[[t,t+s,t+s,t,t],[e,e,e-i,e-i,e]]}_render(t,e,s){const{sx:i,sy:n,x_offset:o,y_offset:_,angle:h,text:l}=null!=s?s:this;this._sys=[],this._sxs=[];for(const s of e){const e=this._sxs[s]=[],r=this._sys[s]=[],c=i[s],x=n[s],u=o.get(s),f=_.get(s),p=h.get(s),g=l.get(s);if(!isNaN(c+x+u+f+p)&&null!=g&&this.visuals.text.doit){const i=`${g}`;t.save(),t.translate(c+u,x+f),t.rotate(p),this.visuals.text.set_vectorize(t,s);const n=this.visuals.text.font_value(s),{height:o}=a.font_metrics(n),_=this.text_line_height.get(s)*o;if(-1==i.indexOf(\"\\n\")){t.fillText(i,0,0);const s=c+u,n=x+f,o=t.measureText(i).width,[h,l]=this._text_bounds(s,n,o,_);e.push(h),r.push(l)}else{const n=i.split(\"\\n\"),o=_*n.length,h=this.text_baseline.get(s);let l;switch(h){case\"top\":l=0;break;case\"middle\":l=-o/2+_/2;break;case\"bottom\":l=-o+_;break;default:l=0,console.warn(`'${h}' baseline not supported with multi line text`)}for(const s of n){t.fillText(s,0,l);const i=c+u,n=l+x+f,o=t.measureText(s).width,[h,a]=this._text_bounds(i,n,o,_);e.push(h),r.push(a),l+=_}}t.restore()}}}_hit_point(t){const{sx:e,sy:s}=t,i=[];for(let t=0;t({text:[r.NullStringSpec,{field:\"text\"}],angle:[r.AngleSpec,0],x_offset:[r.NumberSpec,0],y_offset:[r.NumberSpec,0]})))}}s.Text=f,f.__name__=\"Text\",f.init_Text()},\n", + " function _(t,s,e,i,r){i();const h=t(1),o=t(290),a=t(24),n=h.__importStar(t(18));class _ extends o.BoxView{scenterxy(t){return[this.sx[t],(this.stop[t]+this.sbottom[t])/2]}_lrtb(t){const s=this.width.get(t)/2,e=this._x[t],i=this._top[t],r=this._bottom[t];return[e-s,e+s,Math.max(i,r),Math.min(i,r)]}_map_data(){this.sx=this.renderer.xscale.v_compute(this._x),this.sw=this.sdist(this.renderer.xscale,this._x,this.width,\"center\"),this.stop=this.renderer.yscale.v_compute(this._top),this.sbottom=this.renderer.yscale.v_compute(this._bottom);const t=this.sx.length;this.sleft=new a.ScreenArray(t),this.sright=new a.ScreenArray(t);for(let s=0;s({x:[n.XCoordinateSpec,{field:\"x\"}],bottom:[n.YCoordinateSpec,{value:0}],width:[n.NumberSpec,{value:1}],top:[n.YCoordinateSpec,{field:\"top\"}]})))}}e.VBar=c,c.__name__=\"VBar\",c.init_VBar()},\n", + " function _(e,t,s,i,n){i();const r=e(1),a=e(64),l=e(106),c=e(48),d=e(24),h=e(20),o=r.__importStar(e(18)),_=e(10),u=e(59);class g extends a.XYGlyphView{_map_data(){\"data\"==this.model.properties.radius.units?this.sradius=this.sdist(this.renderer.xscale,this._x,this.radius):this.sradius=d.to_screen(this.radius)}_render(e,t,s){const{sx:i,sy:n,sradius:r,start_angle:a,end_angle:l}=null!=s?s:this,c=\"anticlock\"==this.model.direction;for(const s of t){const t=i[s],d=n[s],h=r[s],o=a.get(s),_=l.get(s);isNaN(t+d+h+o+_)||(e.beginPath(),e.arc(t,d,h,o,_,c),e.lineTo(t,d),e.closePath(),this.visuals.fill.doit&&(this.visuals.fill.set_vectorize(e,s),e.fill()),this.visuals.hatch.doit&&(this.visuals.hatch.set_vectorize(e,s),e.fill()),this.visuals.line.doit&&(this.visuals.line.set_vectorize(e,s),e.stroke()))}}_hit_point(e){let t,s,i,n,r,a,l,c,d;const{sx:h,sy:o}=e,g=this.renderer.xscale.invert(h),p=this.renderer.yscale.invert(o),x=2*this.max_radius;\"data\"===this.model.properties.radius.units?(a=g-x,l=g+x,c=p-x,d=p+x):(s=h-x,i=h+x,[a,l]=this.renderer.xscale.r_invert(s,i),n=o-x,r=o+x,[c,d]=this.renderer.yscale.r_invert(n,r));const f=[];for(const e of this.index.indices({x0:a,x1:l,y0:c,y1:d})){const a=this.sradius[e]**2;[s,i]=this.renderer.xscale.r_compute(g,this._x[e]),[n,r]=this.renderer.yscale.r_compute(p,this._y[e]),t=(s-i)**2+(n-r)**2,t<=a&&f.push(e)}const v=\"anticlock\"==this.model.direction,y=[];for(const e of f){const t=Math.atan2(o-this.sy[e],h-this.sx[e]);_.angle_between(-t,-this.start_angle.get(e),-this.end_angle.get(e),v)&&y.push(e)}return new u.Selection({indices:y})}draw_legend_for_index(e,t,s){l.generic_area_vector_legend(this.visuals,e,t,s)}scenterxy(e){const t=this.sradius[e]/2,s=(this.start_angle.get(e)+this.end_angle.get(e))/2;return[this.sx[e]+t*Math.cos(s),this.sy[e]+t*Math.sin(s)]}}s.WedgeView=g,g.__name__=\"WedgeView\";class p extends a.XYGlyph{constructor(e){super(e)}static init_Wedge(){this.prototype.default_view=g,this.mixins([c.LineVector,c.FillVector,c.HatchVector]),this.define((({})=>({direction:[h.Direction,\"anticlock\"],radius:[o.DistanceSpec,{field:\"radius\"}],start_angle:[o.AngleSpec,{field:\"start_angle\"}],end_angle:[o.AngleSpec,{field:\"end_angle\"}]})))}}s.Wedge=p,p.__name__=\"Wedge\",p.init_Wedge()},\n", + " function _(t,_,r,o,a){o();const e=t(1);e.__exportStar(t(126),r),e.__exportStar(t(125),r),e.__exportStar(t(314),r)},\n", + " function _(t,a,o,r,e){r();const n=t(125);class l extends n.LayoutProvider{constructor(t){super(t)}static init_StaticLayoutProvider(){this.define((({Number:t,Tuple:a,Dict:o})=>({graph_layout:[o(a(t,t)),{}]})))}get_node_coordinates(t){var a;const o=null!==(a=t.data.index)&&void 0!==a?a:[],r=o.length,e=new Float64Array(r),n=new Float64Array(r);for(let t=0;tthis.request_render()))}_draw_regions(i){if(!this.visuals.band_fill.doit&&!this.visuals.band_hatch.doit)return;const[e,t]=this.grid_coords(\"major\",!1);for(let s=0;st[1]&&(n=t[1]);else{[s,n]=t;for(const i of this.plot_view.axis_views)i.dimension==this.model.dimension&&i.model.x_range_name==this.model.x_range_name&&i.model.y_range_name==this.model.y_range_name&&([s,n]=i.computed_bounds)}return[s,n]}grid_coords(i,e=!0){const t=this.model.dimension,s=(t+1)%2,[n,r]=this.ranges();let[o,d]=this.computed_bounds();[o,d]=[Math.min(o,d),Math.max(o,d)];const l=[[],[]],_=this.model.get_ticker();if(null==_)return l;const a=_.get_ticks(o,d,n,r.min)[i],h=n.min,u=n.max,c=r.min,m=r.max;e||(a[0]!=h&&a.splice(0,0,h),a[a.length-1]!=u&&a.push(u));for(let i=0;i({bounds:[r(n(i,i),e),\"auto\"],dimension:[t(0,1),0],axis:[d(s(o.Axis)),null],ticker:[d(s(l.Ticker)),null]}))),this.override({level:\"underlay\",band_fill_color:null,band_fill_alpha:0,grid_line_color:\"#e5e5e5\",minor_grid_line_color:null})}get_ticker(){return null!=this.ticker?this.ticker:null!=this.axis?this.axis.ticker:null}}t.Grid=u,u.__name__=\"Grid\",u.init_Grid()},\n", + " function _(o,a,x,B,e){B(),e(\"Box\",o(318).Box),e(\"Column\",o(320).Column),e(\"GridBox\",o(321).GridBox),e(\"HTMLBox\",o(322).HTMLBox),e(\"LayoutDOM\",o(319).LayoutDOM),e(\"Panel\",o(323).Panel),e(\"Row\",o(324).Row),e(\"Spacer\",o(325).Spacer),e(\"Tabs\",o(326).Tabs),e(\"WidgetBox\",o(329).WidgetBox)},\n", + " function _(e,n,i,t,s){t();const o=e(319);class c extends o.LayoutDOMView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.children.change,(()=>this.rebuild()))}get child_models(){return this.model.children}}i.BoxView=c,c.__name__=\"BoxView\";class r extends o.LayoutDOM{constructor(e){super(e)}static init_Box(){this.define((({Number:e,Array:n,Ref:i})=>({children:[n(i(o.LayoutDOM)),[]],spacing:[e,0]})))}}i.Box=r,r.__name__=\"Box\",r.init_Box()},\n", + " function _(t,i,e,s,o){s();const l=t(53),n=t(20),h=t(43),a=t(19),r=t(8),_=t(22),d=t(143),c=t(122),u=t(240),m=t(221),p=t(44),g=t(249);class f extends u.DOMView{constructor(){super(...arguments),this._idle_notified=!1,this._offset_parent=null,this._viewport={}}get base_font_size(){const t=getComputedStyle(this.el).fontSize,i=d.parse_css_font_size(t);if(null!=i){const{value:t,unit:e}=i;if(\"px\"==e)return t}return 13}initialize(){super.initialize(),this.el.style.position=this.is_root?\"relative\":\"absolute\",this._child_views=new Map}async lazy_initialize(){await super.lazy_initialize(),await this.build_child_views()}remove(){for(const t of this.child_views)t.remove();this._child_views.clear(),super.remove()}connect_signals(){super.connect_signals(),this.is_root&&(this._on_resize=()=>this.resize_layout(),window.addEventListener(\"resize\",this._on_resize),this._parent_observer=setInterval((()=>{const t=this.el.offsetParent;this._offset_parent!=t&&(this._offset_parent=t,null!=t&&(this.compute_viewport(),this.invalidate_layout()))}),250));const t=this.model.properties;this.on_change([t.width,t.height,t.min_width,t.min_height,t.max_width,t.max_height,t.margin,t.width_policy,t.height_policy,t.sizing_mode,t.aspect_ratio,t.visible],(()=>this.invalidate_layout())),this.on_change([t.background,t.css_classes],(()=>this.invalidate_render()))}disconnect_signals(){null!=this._parent_observer&&clearTimeout(this._parent_observer),null!=this._on_resize&&window.removeEventListener(\"resize\",this._on_resize),super.disconnect_signals()}css_classes(){return super.css_classes().concat(this.model.css_classes)}get child_views(){return this.child_models.map((t=>this._child_views.get(t)))}async build_child_views(){await c.build_views(this._child_views,this.child_models,{parent:this})}render(){super.render(),h.empty(this.el);const{background:t}=this.model;this.el.style.backgroundColor=null!=t?_.color2css(t):\"\",h.classes(this.el).clear().add(...this.css_classes());for(const t of this.child_views)this.el.appendChild(t.el),t.render()}update_layout(){for(const t of this.child_views)t.update_layout();this._update_layout()}update_position(){this.el.style.display=this.model.visible?\"block\":\"none\";const t=this.is_root?this.layout.sizing.margin:void 0;h.position(this.el,this.layout.bbox,t);for(const t of this.child_views)t.update_position()}after_layout(){for(const t of this.child_views)t.after_layout();this._has_finished=!0}compute_viewport(){this._viewport=this._viewport_size()}renderTo(t){t.appendChild(this.el),this._offset_parent=this.el.offsetParent,this.compute_viewport(),this.build()}build(){return this.assert_root(),this.render(),this.update_layout(),this.compute_layout(),this}async rebuild(){await this.build_child_views(),this.invalidate_render()}compute_layout(){const t=Date.now();this.layout.compute(this._viewport),this.update_position(),this.after_layout(),a.logger.debug(`layout computed in ${Date.now()-t} ms`),this.notify_finished()}resize_layout(){this.root.compute_viewport(),this.root.compute_layout()}invalidate_layout(){this.root.update_layout(),this.root.compute_layout()}invalidate_render(){this.render(),this.invalidate_layout()}has_finished(){if(!super.has_finished())return!1;for(const t of this.child_views)if(!t.has_finished())return!1;return!0}notify_finished(){this.is_root?!this._idle_notified&&this.has_finished()&&null!=this.model.document&&(this._idle_notified=!0,this.model.document.notify_idle(this.model)):this.root.notify_finished()}_width_policy(){return null!=this.model.width?\"fixed\":\"fit\"}_height_policy(){return null!=this.model.height?\"fixed\":\"fit\"}box_sizing(){let{width_policy:t,height_policy:i,aspect_ratio:e}=this.model;\"auto\"==t&&(t=this._width_policy()),\"auto\"==i&&(i=this._height_policy());const{sizing_mode:s}=this.model;if(null!=s)if(\"fixed\"==s)t=i=\"fixed\";else if(\"stretch_both\"==s)t=i=\"max\";else if(\"stretch_width\"==s)t=\"max\";else if(\"stretch_height\"==s)i=\"max\";else switch(null==e&&(e=\"auto\"),s){case\"scale_width\":t=\"max\",i=\"min\";break;case\"scale_height\":t=\"min\",i=\"max\";break;case\"scale_both\":t=\"max\",i=\"max\"}const o={width_policy:t,height_policy:i},{min_width:l,min_height:n}=this.model;null!=l&&(o.min_width=l),null!=n&&(o.min_height=n);const{width:h,height:a}=this.model;null!=h&&(o.width=h),null!=a&&(o.height=a);const{max_width:_,max_height:d}=this.model;null!=_&&(o.max_width=_),null!=d&&(o.max_height=d),\"auto\"==e&&null!=h&&null!=a?o.aspect=h/a:r.isNumber(e)&&(o.aspect=e);const{margin:c}=this.model;if(null!=c)if(r.isNumber(c))o.margin={top:c,right:c,bottom:c,left:c};else if(2==c.length){const[t,i]=c;o.margin={top:t,right:i,bottom:t,left:i}}else{const[t,i,e,s]=c;o.margin={top:t,right:i,bottom:e,left:s}}o.visible=this.model.visible;const{align:u}=this.model;return r.isArray(u)?[o.halign,o.valign]=u:o.halign=o.valign=u,o}_viewport_size(){return h.undisplayed(this.el,(()=>{let t=this.el;for(;t=t.parentElement;){if(t.classList.contains(p.root))continue;if(t==document.body){const{margin:{left:t,right:i,top:e,bottom:s}}=h.extents(document.body);return{width:Math.ceil(document.documentElement.clientWidth-t-i),height:Math.ceil(document.documentElement.clientHeight-e-s)}}const{padding:{left:i,right:e,top:s,bottom:o}}=h.extents(t),{width:l,height:n}=t.getBoundingClientRect(),a=Math.ceil(l-i-e),r=Math.ceil(n-s-o);if(a>0||r>0)return{width:a>0?a:void 0,height:r>0?r:void 0}}return{}}))}export(t,i=!0){const e=\"png\"==t?\"canvas\":\"svg\",s=new g.CanvasLayer(e,i),{width:o,height:l}=this.layout.bbox;s.resize(o,l);for(const e of this.child_views){const o=e.export(t,i),{x:l,y:n}=e.layout.bbox;s.ctx.drawImage(o.canvas,l,n)}return s}serializable_state(){return Object.assign(Object.assign({},super.serializable_state()),{bbox:this.layout.bbox.box,children:this.child_views.map((t=>t.serializable_state()))})}}e.LayoutDOMView=f,f.__name__=\"LayoutDOMView\";class w extends l.Model{constructor(t){super(t)}static init_LayoutDOM(){this.define((t=>{const{Boolean:i,Number:e,String:s,Auto:o,Color:l,Array:h,Tuple:a,Or:r,Null:_,Nullable:d}=t,c=a(e,e),u=a(e,e,e,e);return{width:[d(e),null],height:[d(e),null],min_width:[d(e),null],min_height:[d(e),null],max_width:[d(e),null],max_height:[d(e),null],margin:[d(r(e,c,u)),[0,0,0,0]],width_policy:[r(m.SizingPolicy,o),\"auto\"],height_policy:[r(m.SizingPolicy,o),\"auto\"],aspect_ratio:[r(e,o,_),null],sizing_mode:[d(n.SizingMode),null],visible:[i,!0],disabled:[i,!1],align:[r(n.Align,a(n.Align,n.Align)),\"start\"],background:[d(l),null],css_classes:[h(s),[]]}}))}}e.LayoutDOM=w,w.__name__=\"LayoutDOM\",w.init_LayoutDOM()},\n", + " function _(t,s,i,o,n){o();const e=t(318),l=t(223);class u extends e.BoxView{_update_layout(){const t=this.child_views.map((t=>t.layout));this.layout=new l.Column(t),this.layout.rows=this.model.rows,this.layout.spacing=[this.model.spacing,0],this.layout.set_sizing(this.box_sizing())}}i.ColumnView=u,u.__name__=\"ColumnView\";class a extends e.Box{constructor(t){super(t)}static init_Column(){this.prototype.default_view=u,this.define((({Any:t})=>({rows:[t,\"auto\"]})))}}i.Column=a,a.__name__=\"Column\",a.init_Column()},\n", + " function _(t,s,i,o,e){o();const n=t(319),l=t(223);class a extends n.LayoutDOMView{connect_signals(){super.connect_signals();const{children:t,rows:s,cols:i,spacing:o}=this.model.properties;this.on_change([t,s,i,o],(()=>this.rebuild()))}get child_models(){return this.model.children.map((([t])=>t))}_update_layout(){this.layout=new l.Grid,this.layout.rows=this.model.rows,this.layout.cols=this.model.cols,this.layout.spacing=this.model.spacing;for(const[t,s,i,o,e]of this.model.children){const n=this._child_views.get(t);this.layout.items.push({layout:n.layout,row:s,col:i,row_span:o,col_span:e})}this.layout.set_sizing(this.box_sizing())}}i.GridBoxView=a,a.__name__=\"GridBoxView\";class r extends n.LayoutDOM{constructor(t){super(t)}static init_GridBox(){this.prototype.default_view=a,this.define((({Any:t,Int:s,Number:i,Tuple:o,Array:e,Ref:l,Or:a,Opt:r})=>({children:[e(o(l(n.LayoutDOM),s,s,r(s),r(s))),[]],rows:[t,\"auto\"],cols:[t,\"auto\"],spacing:[a(i,o(i,i)),0]})))}}i.GridBox=r,r.__name__=\"GridBox\",r.init_GridBox()},\n", + " function _(t,e,o,s,n){s();const _=t(319),i=t(221);class a extends _.LayoutDOMView{get child_models(){return[]}_update_layout(){this.layout=new i.ContentBox(this.el),this.layout.set_sizing(this.box_sizing())}}o.HTMLBoxView=a,a.__name__=\"HTMLBoxView\";class u extends _.LayoutDOM{constructor(t){super(t)}}o.HTMLBox=u,u.__name__=\"HTMLBox\"},\n", + " function _(e,n,t,i,l){i();const a=e(53),o=e(319);class s extends a.Model{constructor(e){super(e)}static init_Panel(){this.define((({Boolean:e,String:n,Ref:t})=>({title:[n,\"\"],child:[t(o.LayoutDOM)],closable:[e,!1]})))}}t.Panel=s,s.__name__=\"Panel\",s.init_Panel()},\n", + " function _(t,s,i,o,e){o();const n=t(318),a=t(223);class _ extends n.BoxView{_update_layout(){const t=this.child_views.map((t=>t.layout));this.layout=new a.Row(t),this.layout.cols=this.model.cols,this.layout.spacing=[0,this.model.spacing],this.layout.set_sizing(this.box_sizing())}}i.RowView=_,_.__name__=\"RowView\";class l extends n.Box{constructor(t){super(t)}static init_Row(){this.prototype.default_view=_,this.define((({Any:t})=>({cols:[t,\"auto\"]})))}}i.Row=l,l.__name__=\"Row\",l.init_Row()},\n", + " function _(t,e,a,i,s){i();const _=t(319),c=t(221);class n extends _.LayoutDOMView{get child_models(){return[]}_update_layout(){this.layout=new c.LayoutItem,this.layout.set_sizing(this.box_sizing())}}a.SpacerView=n,n.__name__=\"SpacerView\";class o extends _.LayoutDOM{constructor(t){super(t)}static init_Spacer(){this.prototype.default_view=n}}a.Spacer=o,o.__name__=\"Spacer\",o.init_Spacer()},\n", + " function _(e,t,s,i,l){i();const h=e(1),a=e(221),o=e(43),r=e(9),c=e(10),d=e(20),n=e(319),_=e(323),p=h.__importStar(e(327)),b=p,u=h.__importStar(e(328)),m=u,g=h.__importStar(e(243)),v=g;class w extends n.LayoutDOMView{constructor(){super(...arguments),this._scroll_index=0}connect_signals(){super.connect_signals(),this.connect(this.model.properties.tabs.change,(()=>this.rebuild())),this.connect(this.model.properties.active.change,(()=>this.on_active_change()))}styles(){return[...super.styles(),u.default,g.default,p.default]}get child_models(){return this.model.tabs.map((e=>e.child))}_update_layout(){const e=this.model.tabs_location,t=\"above\"==e||\"below\"==e,{scroll_el:s,headers_el:i}=this;this.header=new class extends a.ContentBox{_measure(e){const l=o.size(s),h=o.children(i).slice(0,3).map((e=>o.size(e))),{width:a,height:c}=super._measure(e);if(t){const t=l.width+r.sum(h.map((e=>e.width)));return{width:e.width!=1/0?e.width:t,height:c}}{const t=l.height+r.sum(h.map((e=>e.height)));return{width:a,height:e.height!=1/0?e.height:t}}}}(this.header_el),t?this.header.set_sizing({width_policy:\"fit\",height_policy:\"fixed\"}):this.header.set_sizing({width_policy:\"fixed\",height_policy:\"fit\"});let l=1,h=1;switch(e){case\"above\":l-=1;break;case\"below\":l+=1;break;case\"left\":h-=1;break;case\"right\":h+=1}const c={layout:this.header,row:l,col:h},d=this.child_views.map((e=>({layout:e.layout,row:1,col:1})));this.layout=new a.Grid([c,...d]),this.layout.set_sizing(this.box_sizing())}update_position(){super.update_position(),this.header_el.style.position=\"absolute\",o.position(this.header_el,this.header.bbox);const e=this.model.tabs_location,t=\"above\"==e||\"below\"==e,s=o.size(this.scroll_el),i=o.scroll_size(this.headers_el);if(t){const{width:e}=this.header.bbox;i.width>e?(this.wrapper_el.style.maxWidth=e-s.width+\"px\",o.display(this.scroll_el),this.do_scroll(this.model.active)):(this.wrapper_el.style.maxWidth=\"\",o.undisplay(this.scroll_el))}else{const{height:e}=this.header.bbox;i.height>e?(this.wrapper_el.style.maxHeight=e-s.height+\"px\",o.display(this.scroll_el),this.do_scroll(this.model.active)):(this.wrapper_el.style.maxHeight=\"\",o.undisplay(this.scroll_el))}const{child_views:l}=this;for(const e of l)o.hide(e.el);const h=l[this.model.active];null!=h&&o.show(h.el)}render(){super.render();const{active:e}=this.model,t=this.model.tabs.map(((t,s)=>{const i=o.div({class:[b.tab,s==e?b.active:null]},t.title);if(i.addEventListener(\"click\",(e=>{e.target==e.currentTarget&&this.change_active(s)})),t.closable){const e=o.div({class:b.close});e.addEventListener(\"click\",(e=>{if(e.target==e.currentTarget){this.model.tabs=r.remove_at(this.model.tabs,s);const e=this.model.tabs.length;this.model.active>e-1&&(this.model.active=e-1)}})),i.appendChild(e)}return i}));this.headers_el=o.div({class:[b.headers]},t),this.wrapper_el=o.div({class:b.headers_wrapper},this.headers_el),this.left_el=o.div({class:[m.btn,m.btn_default],disabled:\"\"},o.div({class:[v.caret,b.left]})),this.right_el=o.div({class:[m.btn,m.btn_default]},o.div({class:[v.caret,b.right]})),this.left_el.addEventListener(\"click\",(()=>this.do_scroll(\"left\"))),this.right_el.addEventListener(\"click\",(()=>this.do_scroll(\"right\"))),this.scroll_el=o.div({class:m.btn_group},this.left_el,this.right_el);const s=this.model.tabs_location;this.header_el=o.div({class:[b.tabs_header,b[s]]},this.scroll_el,this.wrapper_el),this.el.appendChild(this.header_el)}do_scroll(e){const t=this.model.tabs.length;\"left\"==e?this._scroll_index-=1:\"right\"==e?this._scroll_index+=1:this._scroll_index=e,this._scroll_index=c.clamp(this._scroll_index,0,t-1),0==this._scroll_index?this.left_el.setAttribute(\"disabled\",\"\"):this.left_el.removeAttribute(\"disabled\"),this._scroll_index==t-1?this.right_el.setAttribute(\"disabled\",\"\"):this.right_el.removeAttribute(\"disabled\");const s=o.children(this.headers_el).slice(0,this._scroll_index).map((e=>e.getBoundingClientRect())),i=this.model.tabs_location;if(\"above\"==i||\"below\"==i){const e=-r.sum(s.map((e=>e.width)));this.headers_el.style.left=`${e}px`}else{const e=-r.sum(s.map((e=>e.height)));this.headers_el.style.top=`${e}px`}}change_active(e){e!=this.model.active&&(this.model.active=e)}on_active_change(){const e=this.model.active,t=o.children(this.headers_el);for(const e of t)e.classList.remove(b.active);t[e].classList.add(b.active);const{child_views:s}=this;for(const e of s)o.hide(e.el);o.show(s[e].el)}}s.TabsView=w,w.__name__=\"TabsView\";class f extends n.LayoutDOM{constructor(e){super(e)}static init_Tabs(){this.prototype.default_view=w,this.define((({Int:e,Array:t,Ref:s})=>({tabs:[t(s(_.Panel)),[]],tabs_location:[d.Location,\"above\"],active:[e,0]})))}}s.Tabs=f,f.__name__=\"Tabs\",f.init_Tabs()},\n", + " function _(e,r,b,o,t){o(),b.root=\"bk-root\",b.tabs_header=\"bk-tabs-header\",b.btn_group=\"bk-btn-group\",b.btn=\"bk-btn\",b.headers_wrapper=\"bk-headers-wrapper\",b.above=\"bk-above\",b.right=\"bk-right\",b.below=\"bk-below\",b.left=\"bk-left\",b.headers=\"bk-headers\",b.tab=\"bk-tab\",b.active=\"bk-active\",b.close=\"bk-close\",b.default='.bk-root .bk-tabs-header{display:flex;display:-webkit-flex;flex-wrap:nowrap;-webkit-flex-wrap:nowrap;align-items:center;-webkit-align-items:center;overflow:hidden;user-select:none;-ms-user-select:none;-moz-user-select:none;-webkit-user-select:none;}.bk-root .bk-tabs-header .bk-btn-group{height:auto;margin-right:5px;}.bk-root .bk-tabs-header .bk-btn-group > .bk-btn{flex-grow:0;-webkit-flex-grow:0;height:auto;padding:4px 4px;}.bk-root .bk-tabs-header .bk-headers-wrapper{flex-grow:1;-webkit-flex-grow:1;overflow:hidden;color:#666666;}.bk-root .bk-tabs-header.bk-above .bk-headers-wrapper{border-bottom:1px solid #e6e6e6;}.bk-root .bk-tabs-header.bk-right .bk-headers-wrapper{border-left:1px solid #e6e6e6;}.bk-root .bk-tabs-header.bk-below .bk-headers-wrapper{border-top:1px solid #e6e6e6;}.bk-root .bk-tabs-header.bk-left .bk-headers-wrapper{border-right:1px solid #e6e6e6;}.bk-root .bk-tabs-header.bk-above,.bk-root .bk-tabs-header.bk-below{flex-direction:row;-webkit-flex-direction:row;}.bk-root .bk-tabs-header.bk-above .bk-headers,.bk-root .bk-tabs-header.bk-below .bk-headers{flex-direction:row;-webkit-flex-direction:row;}.bk-root .bk-tabs-header.bk-left,.bk-root .bk-tabs-header.bk-right{flex-direction:column;-webkit-flex-direction:column;}.bk-root .bk-tabs-header.bk-left .bk-headers,.bk-root .bk-tabs-header.bk-right .bk-headers{flex-direction:column;-webkit-flex-direction:column;}.bk-root .bk-tabs-header .bk-headers{position:relative;display:flex;display:-webkit-flex;flex-wrap:nowrap;-webkit-flex-wrap:nowrap;align-items:center;-webkit-align-items:center;}.bk-root .bk-tabs-header .bk-tab{padding:4px 8px;border:solid transparent;white-space:nowrap;cursor:pointer;}.bk-root .bk-tabs-header .bk-tab:hover{background-color:#f2f2f2;}.bk-root .bk-tabs-header .bk-tab.bk-active{color:#4d4d4d;background-color:white;border-color:#e6e6e6;}.bk-root .bk-tabs-header .bk-tab .bk-close{margin-left:10px;}.bk-root .bk-tabs-header.bk-above .bk-tab{border-width:3px 1px 0px 1px;border-radius:4px 4px 0 0;}.bk-root .bk-tabs-header.bk-right .bk-tab{border-width:1px 3px 1px 0px;border-radius:0 4px 4px 0;}.bk-root .bk-tabs-header.bk-below .bk-tab{border-width:0px 1px 3px 1px;border-radius:0 0 4px 4px;}.bk-root .bk-tabs-header.bk-left .bk-tab{border-width:1px 0px 1px 3px;border-radius:4px 0 0 4px;}.bk-root .bk-close{display:inline-block;width:10px;height:10px;vertical-align:middle;background-image:url(\\'data:image/svg+xml;utf8, \\');}.bk-root .bk-close:hover{background-image:url(\\'data:image/svg+xml;utf8, \\');}'},\n", + " function _(o,b,r,t,e){t(),r.root=\"bk-root\",r.btn=\"bk-btn\",r.active=\"bk-active\",r.btn_default=\"bk-btn-default\",r.btn_primary=\"bk-btn-primary\",r.btn_success=\"bk-btn-success\",r.btn_warning=\"bk-btn-warning\",r.btn_danger=\"bk-btn-danger\",r.btn_light=\"bk-btn-light\",r.btn_group=\"bk-btn-group\",r.dropdown_toggle=\"bk-dropdown-toggle\",r.default=\".bk-root .bk-btn{height:100%;display:inline-block;text-align:center;vertical-align:middle;white-space:nowrap;cursor:pointer;padding:6px 12px;font-size:12px;border:1px solid transparent;border-radius:4px;outline:0;user-select:none;-ms-user-select:none;-moz-user-select:none;-webkit-user-select:none;}.bk-root .bk-btn:hover,.bk-root .bk-btn:focus{text-decoration:none;}.bk-root .bk-btn:active,.bk-root .bk-btn.bk-active{background-image:none;box-shadow:inset 0 3px 5px rgba(0, 0, 0, 0.125);}.bk-root .bk-btn[disabled]{cursor:not-allowed;pointer-events:none;opacity:0.65;box-shadow:none;}.bk-root .bk-btn-default{color:#333;background-color:#fff;border-color:#ccc;}.bk-root .bk-btn-default:hover{background-color:#f5f5f5;border-color:#b8b8b8;}.bk-root .bk-btn-default.bk-active{background-color:#ebebeb;border-color:#adadad;}.bk-root .bk-btn-default[disabled],.bk-root .bk-btn-default[disabled]:hover,.bk-root .bk-btn-default[disabled]:focus,.bk-root .bk-btn-default[disabled]:active,.bk-root .bk-btn-default[disabled].bk-active{background-color:#e6e6e6;border-color:#ccc;}.bk-root .bk-btn-primary{color:#fff;background-color:#428bca;border-color:#357ebd;}.bk-root .bk-btn-primary:hover{background-color:#3681c1;border-color:#2c699e;}.bk-root .bk-btn-primary.bk-active{background-color:#3276b1;border-color:#285e8e;}.bk-root .bk-btn-primary[disabled],.bk-root .bk-btn-primary[disabled]:hover,.bk-root .bk-btn-primary[disabled]:focus,.bk-root .bk-btn-primary[disabled]:active,.bk-root .bk-btn-primary[disabled].bk-active{background-color:#506f89;border-color:#357ebd;}.bk-root .bk-btn-success{color:#fff;background-color:#5cb85c;border-color:#4cae4c;}.bk-root .bk-btn-success:hover{background-color:#4eb24e;border-color:#409240;}.bk-root .bk-btn-success.bk-active{background-color:#47a447;border-color:#398439;}.bk-root .bk-btn-success[disabled],.bk-root .bk-btn-success[disabled]:hover,.bk-root .bk-btn-success[disabled]:focus,.bk-root .bk-btn-success[disabled]:active,.bk-root .bk-btn-success[disabled].bk-active{background-color:#667b66;border-color:#4cae4c;}.bk-root .bk-btn-warning{color:#fff;background-color:#f0ad4e;border-color:#eea236;}.bk-root .bk-btn-warning:hover{background-color:#eea43b;border-color:#e89014;}.bk-root .bk-btn-warning.bk-active{background-color:#ed9c28;border-color:#d58512;}.bk-root .bk-btn-warning[disabled],.bk-root .bk-btn-warning[disabled]:hover,.bk-root .bk-btn-warning[disabled]:focus,.bk-root .bk-btn-warning[disabled]:active,.bk-root .bk-btn-warning[disabled].bk-active{background-color:#c89143;border-color:#eea236;}.bk-root .bk-btn-danger{color:#fff;background-color:#d9534f;border-color:#d43f3a;}.bk-root .bk-btn-danger:hover{background-color:#d5433e;border-color:#bd2d29;}.bk-root .bk-btn-danger.bk-active{background-color:#d2322d;border-color:#ac2925;}.bk-root .bk-btn-danger[disabled],.bk-root .bk-btn-danger[disabled]:hover,.bk-root .bk-btn-danger[disabled]:focus,.bk-root .bk-btn-danger[disabled]:active,.bk-root .bk-btn-danger[disabled].bk-active{background-color:#a55350;border-color:#d43f3a;}.bk-root .bk-btn-light{color:#333;background-color:#fff;border-color:#ccc;border-color:transparent;}.bk-root .bk-btn-light:hover{background-color:#f5f5f5;border-color:#b8b8b8;}.bk-root .bk-btn-light.bk-active{background-color:#ebebeb;border-color:#adadad;}.bk-root .bk-btn-light[disabled],.bk-root .bk-btn-light[disabled]:hover,.bk-root .bk-btn-light[disabled]:focus,.bk-root .bk-btn-light[disabled]:active,.bk-root .bk-btn-light[disabled].bk-active{background-color:#e6e6e6;border-color:#ccc;}.bk-root .bk-btn-group{height:100%;display:flex;display:-webkit-flex;flex-wrap:nowrap;-webkit-flex-wrap:nowrap;align-items:center;-webkit-align-items:center;flex-direction:row;-webkit-flex-direction:row;}.bk-root .bk-btn-group > .bk-btn{flex-grow:1;-webkit-flex-grow:1;}.bk-root .bk-btn-group > .bk-btn + .bk-btn{margin-left:-1px;}.bk-root .bk-btn-group > .bk-btn:first-child:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0;}.bk-root .bk-btn-group > .bk-btn:not(:first-child):last-child{border-bottom-left-radius:0;border-top-left-radius:0;}.bk-root .bk-btn-group > .bk-btn:not(:first-child):not(:last-child){border-radius:0;}.bk-root .bk-btn-group .bk-dropdown-toggle{flex:0 0 0;-webkit-flex:0 0 0;padding:6px 6px;}\"},\n", + " function _(t,e,i,o,n){o();const _=t(320);class s extends _.ColumnView{}i.WidgetBoxView=s,s.__name__=\"WidgetBoxView\";class d extends _.Column{constructor(t){super(t)}static init_WidgetBox(){this.prototype.default_view=s}}i.WidgetBox=d,d.__name__=\"WidgetBox\",d.init_WidgetBox()},\n", + " function _(p,o,t,a,n){a(),n(\"MapOptions\",p(331).MapOptions),n(\"GMapOptions\",p(331).GMapOptions),n(\"GMapPlot\",p(331).GMapPlot),n(\"Plot\",p(332).Plot)},\n", + " function _(t,i,n,e,a){e();const s=t(332),o=t(53),p=t(156),_=t(337);a(\"GMapPlotView\",_.GMapPlotView);class l extends o.Model{constructor(t){super(t)}static init_MapOptions(){this.define((({Int:t,Number:i})=>({lat:[i],lng:[i],zoom:[t,12]})))}}n.MapOptions=l,l.__name__=\"MapOptions\",l.init_MapOptions();class r extends l{constructor(t){super(t)}static init_GMapOptions(){this.define((({Boolean:t,Int:i,String:n})=>({map_type:[n,\"roadmap\"],scale_control:[t,!1],styles:[n],tilt:[i,45]})))}}n.GMapOptions=r,r.__name__=\"GMapOptions\",r.init_GMapOptions();class c extends s.Plot{constructor(t){super(t),this.use_map=!0}static init_GMapPlot(){this.prototype.default_view=_.GMapPlotView,this.define((({String:t,Ref:i})=>({map_options:[i(r)],api_key:[t],api_version:[t,\"3.43\"]}))),this.override({x_range:()=>new p.Range1d,y_range:()=>new p.Range1d})}}n.GMapPlot=c,c.__name__=\"GMapPlot\",c.init_GMapPlot()},\n", + " function _(e,t,i,n,r){n();const o=e(1),a=o.__importStar(e(48)),s=o.__importStar(e(18)),l=e(15),_=e(20),h=e(9),c=e(13),d=e(8),u=e(319),g=e(163),p=e(316),f=e(40),b=e(138),w=e(218),m=e(235),y=e(105),v=e(146),x=e(130),A=e(41),R=e(62),S=e(61),P=e(159),D=e(333);r(\"PlotView\",D.PlotView);class L extends u.LayoutDOM{constructor(e){super(e),this.use_map=!1}static init_Plot(){this.prototype.default_view=D.PlotView,this.mixins([[\"outline_\",a.Line],[\"background_\",a.Fill],[\"border_\",a.Fill]]),this.define((({Boolean:e,Number:t,String:i,Array:n,Dict:r,Or:o,Ref:a,Null:l,Nullable:h})=>({toolbar:[a(m.Toolbar),()=>new m.Toolbar],toolbar_location:[h(_.Location),\"right\"],toolbar_sticky:[e,!0],plot_width:[s.Alias(\"width\")],plot_height:[s.Alias(\"height\")],frame_width:[h(t),null],frame_height:[h(t),null],title:[o(a(b.Title),i,l),()=>new b.Title({text:\"\"})],title_location:[h(_.Location),\"above\"],above:[n(o(a(f.Annotation),a(g.Axis))),[]],below:[n(o(a(f.Annotation),a(g.Axis))),[]],left:[n(o(a(f.Annotation),a(g.Axis))),[]],right:[n(o(a(f.Annotation),a(g.Axis))),[]],center:[n(o(a(f.Annotation),a(p.Grid))),[]],renderers:[n(a(A.Renderer)),[]],x_range:[a(y.Range),()=>new P.DataRange1d],extra_x_ranges:[r(a(y.Range)),{}],y_range:[a(y.Range),()=>new P.DataRange1d],extra_y_ranges:[r(a(y.Range)),{}],x_scale:[a(v.Scale),()=>new w.LinearScale],y_scale:[a(v.Scale),()=>new w.LinearScale],lod_factor:[t,10],lod_interval:[t,300],lod_threshold:[h(t),2e3],lod_timeout:[t,500],hidpi:[e,!0],output_backend:[_.OutputBackend,\"canvas\"],min_border:[h(t),5],min_border_top:[h(t),null],min_border_left:[h(t),null],min_border_bottom:[h(t),null],min_border_right:[h(t),null],inner_width:[t,0],inner_height:[t,0],outer_width:[t,0],outer_height:[t,0],match_aspect:[e,!1],aspect_scale:[t,1],reset_policy:[_.ResetPolicy,\"standard\"]}))),this.override({width:600,height:600,outline_line_color:\"#e5e5e5\",border_fill_color:\"#ffffff\",background_fill_color:\"#ffffff\"})}_doc_attached(){super._doc_attached(),this._push_changes([[this.properties.inner_height,null,this.inner_height],[this.properties.inner_width,null,this.inner_width]])}initialize(){super.initialize(),this.reset=new l.Signal0(this,\"reset\");for(const e of c.values(this.extra_x_ranges).concat(this.x_range)){let t=e.plots;d.isArray(t)&&(t=t.concat(this),e.setv({plots:t},{silent:!0}))}for(const e of c.values(this.extra_y_ranges).concat(this.y_range)){let t=e.plots;d.isArray(t)&&(t=t.concat(this),e.setv({plots:t},{silent:!0}))}}add_layout(e,t=\"center\"){const i=this.properties[t].get_value();this.setv({[t]:[...i,e]})}remove_layout(e){const t=t=>{h.remove_by(t,(t=>t==e))};t(this.left),t(this.right),t(this.above),t(this.below),t(this.center)}get data_renderers(){return this.renderers.filter((e=>e instanceof R.DataRenderer))}add_renderers(...e){this.renderers=this.renderers.concat(e)}add_glyph(e,t=new x.ColumnDataSource,i={}){const n=new S.GlyphRenderer(Object.assign(Object.assign({},i),{data_source:t,glyph:e}));return this.add_renderers(n),n}add_tools(...e){this.toolbar.tools=this.toolbar.tools.concat(e)}get panels(){return[...this.side_panels,...this.center]}get side_panels(){const{above:e,below:t,left:i,right:n}=this;return h.concat([e,t,i,n])}}i.Plot=L,L.__name__=\"Plot\",L.init_Plot()},\n", + " function _(e,t,i,s,a){s();const n=e(1),o=e(144),l=e(262),r=e(319),_=e(40),h=e(138),d=e(163),u=e(234),c=e(264),p=e(122),v=e(45),b=e(19),g=e(334),m=e(8),w=e(9),y=e(249),f=e(222),x=e(225),z=e(223),k=e(140),q=e(99),M=e(335),V=e(336),P=e(28);class R extends r.LayoutDOMView{constructor(){super(...arguments),this._outer_bbox=new q.BBox,this._inner_bbox=new q.BBox,this._needs_paint=!0,this._needs_layout=!1,this._invalidated_painters=new Set,this._invalidate_all=!0}get canvas(){return this.canvas_view}get state(){return this._state_manager}set invalidate_dataranges(e){this._range_manager.invalidate_dataranges=e}renderer_view(e){const t=this.renderer_views.get(e);if(null==t)for(const[,t]of this.renderer_views){const i=t.renderer_view(e);if(null!=i)return i}return t}get is_paused(){return null!=this._is_paused&&0!==this._is_paused}get child_models(){return[]}pause(){null==this._is_paused?this._is_paused=1:this._is_paused+=1}unpause(e=!1){if(null==this._is_paused)throw new Error(\"wasn't paused\");this._is_paused-=1,0!=this._is_paused||e||this.request_paint(\"everything\")}request_render(){this.request_paint(\"everything\")}request_paint(e){this.invalidate_painters(e),this.schedule_paint()}invalidate_painters(e){if(\"everything\"==e)this._invalidate_all=!0;else if(m.isArray(e))for(const t of e)this._invalidated_painters.add(t);else this._invalidated_painters.add(e)}schedule_paint(){if(!this.is_paused){const e=this.throttled_paint();this._ready=this._ready.then((()=>e))}}request_layout(){this._needs_layout=!0,this.request_paint(\"everything\")}reset(){\"standard\"==this.model.reset_policy&&(this.state.clear(),this.reset_range(),this.reset_selection()),this.model.trigger_event(new c.Reset)}remove(){p.remove_views(this.renderer_views),p.remove_views(this.tool_views),this.canvas_view.remove(),super.remove()}render(){super.render(),this.el.appendChild(this.canvas_view.el),this.canvas_view.render()}initialize(){this.pause(),super.initialize(),this.lod_started=!1,this.visuals=new v.Visuals(this),this._initial_state={selection:new Map,dimensions:{width:0,height:0}},this.visibility_callbacks=[],this.renderer_views=new Map,this.tool_views=new Map,this.frame=new o.CartesianFrame(this.model.x_scale,this.model.y_scale,this.model.x_range,this.model.y_range,this.model.extra_x_ranges,this.model.extra_y_ranges),this._range_manager=new M.RangeManager(this),this._state_manager=new V.StateManager(this,this._initial_state),this.throttled_paint=g.throttle((()=>this.repaint()),1e3/60);const{title_location:e,title:t}=this.model;null!=e&&null!=t&&(this._title=t instanceof h.Title?t:new h.Title({text:t}));const{toolbar_location:i,toolbar:s}=this.model;null!=i&&null!=s&&(this._toolbar=new u.ToolbarPanel({toolbar:s}),s.toolbar_location=i)}async lazy_initialize(){await super.lazy_initialize();const{hidpi:e,output_backend:t}=this.model,i=new l.Canvas({hidpi:e,output_backend:t});this.canvas_view=await p.build_view(i,{parent:this}),this.canvas_view.plot_views=[this],await this.build_renderer_views(),await this.build_tool_views(),this._range_manager.update_dataranges(),this.unpause(!0),b.logger.debug(\"PlotView initialized\")}_width_policy(){return null==this.model.frame_width?super._width_policy():\"min\"}_height_policy(){return null==this.model.frame_height?super._height_policy():\"min\"}_update_layout(){var e,t,i,s,a;this.layout=new x.BorderLayout,this.layout.set_sizing(this.box_sizing());const n=w.copy(this.model.above),o=w.copy(this.model.below),l=w.copy(this.model.left),r=w.copy(this.model.right),d=e=>{switch(e){case\"above\":return n;case\"below\":return o;case\"left\":return l;case\"right\":return r}},{title_location:c,title:p}=this.model;null!=c&&null!=p&&d(c).push(this._title);const{toolbar_location:v,toolbar:b}=this.model;if(null!=v&&null!=b){const e=d(v);let t=!0;if(this.model.toolbar_sticky)for(let i=0;i{var i;const s=this.renderer_view(t);return s.panel=new k.Panel(e),null===(i=s.update_layout)||void 0===i||i.call(s),s.layout},y=(e,t)=>{const i=\"above\"==e||\"below\"==e,s=[];for(const a of t)if(m.isArray(a)){const t=a.map((t=>{const s=g(e,t);if(t instanceof u.ToolbarPanel){const e=i?\"width_policy\":\"height_policy\";s.set_sizing(Object.assign(Object.assign({},s.sizing),{[e]:\"min\"}))}return s}));let n;i?(n=new z.Row(t),n.set_sizing({width_policy:\"max\",height_policy:\"min\"})):(n=new z.Column(t),n.set_sizing({width_policy:\"min\",height_policy:\"max\"})),n.absolute=!0,s.push(n)}else s.push(g(e,a));return s},q=null!==(e=this.model.min_border)&&void 0!==e?e:0;this.layout.min_border={left:null!==(t=this.model.min_border_left)&&void 0!==t?t:q,top:null!==(i=this.model.min_border_top)&&void 0!==i?i:q,right:null!==(s=this.model.min_border_right)&&void 0!==s?s:q,bottom:null!==(a=this.model.min_border_bottom)&&void 0!==a?a:q};const M=new f.NodeLayout,V=new f.VStack,P=new f.VStack,R=new f.HStack,O=new f.HStack;M.absolute=!0,V.absolute=!0,P.absolute=!0,R.absolute=!0,O.absolute=!0,M.children=this.model.center.filter((e=>e instanceof _.Annotation)).map((e=>{var t;const i=this.renderer_view(e);return null===(t=i.update_layout)||void 0===t||t.call(i),i.layout})).filter((e=>null!=e));const{frame_width:S,frame_height:j}=this.model;M.set_sizing(Object.assign(Object.assign({},null!=S?{width_policy:\"fixed\",width:S}:{width_policy:\"fit\"}),null!=j?{height_policy:\"fixed\",height:j}:{height_policy:\"fit\"})),M.on_resize((e=>this.frame.set_geometry(e))),V.children=w.reversed(y(\"above\",n)),P.children=y(\"below\",o),R.children=w.reversed(y(\"left\",l)),O.children=y(\"right\",r),V.set_sizing({width_policy:\"fit\",height_policy:\"min\"}),P.set_sizing({width_policy:\"fit\",height_policy:\"min\"}),R.set_sizing({width_policy:\"min\",height_policy:\"fit\"}),O.set_sizing({width_policy:\"min\",height_policy:\"fit\"}),this.layout.center_panel=M,this.layout.top_panel=V,this.layout.bottom_panel=P,this.layout.left_panel=R,this.layout.right_panel=O}get axis_views(){const e=[];for(const[,t]of this.renderer_views)t instanceof d.AxisView&&e.push(t);return e}set_toolbar_visibility(e){for(const t of this.visibility_callbacks)t(e)}update_range(e,t){this.pause(),this._range_manager.update(e,t),this.unpause()}reset_range(){this.update_range(null)}get_selection(){const e=new Map;for(const t of this.model.data_renderers){const{selected:i}=t.selection_manager.source;e.set(t,i)}return e}update_selection(e){for(const t of this.model.data_renderers){const i=t.selection_manager.source;if(null!=e){const s=e.get(t);null!=s&&i.selected.update(s,!0)}else i.selection_manager.clear()}}reset_selection(){this.update_selection(null)}_invalidate_layout(){(()=>{var e;for(const t of this.model.side_panels){const i=this.renderer_views.get(t);if(null===(e=i.layout)||void 0===e?void 0:e.has_size_changed())return this.invalidate_painters(i),!0}return!1})()&&this.root.compute_layout()}get_renderer_views(){return this.computed_renderers.map((e=>this.renderer_views.get(e)))}*_compute_renderers(){const{above:e,below:t,left:i,right:s,center:a,renderers:n}=this.model;yield*n,yield*e,yield*t,yield*i,yield*s,yield*a,null!=this._title&&(yield this._title),null!=this._toolbar&&(yield this._toolbar);for(const e of this.model.toolbar.tools)null!=e.overlay&&(yield e.overlay),yield*e.synthetic_renderers}async build_renderer_views(){this.computed_renderers=[...this._compute_renderers()],await p.build_views(this.renderer_views,this.computed_renderers,{parent:this})}async build_tool_views(){const e=this.model.toolbar.tools;(await p.build_views(this.tool_views,e,{parent:this})).map((e=>this.canvas_view.ui_event_bus.register_tool(e)))}connect_signals(){super.connect_signals();const{x_ranges:e,y_ranges:t}=this.frame;for(const[,t]of e)this.connect(t.change,(()=>{this._needs_layout=!0,this.request_paint(\"everything\")}));for(const[,e]of t)this.connect(e.change,(()=>{this._needs_layout=!0,this.request_paint(\"everything\")}));const{above:i,below:s,left:a,right:n,center:o,renderers:l}=this.model.properties;this.on_change([i,s,a,n,o,l],(async()=>await this.build_renderer_views())),this.connect(this.model.toolbar.properties.tools.change,(async()=>{await this.build_renderer_views(),await this.build_tool_views()})),this.connect(this.model.change,(()=>this.request_paint(\"everything\"))),this.connect(this.model.reset,(()=>this.reset()))}has_finished(){if(!super.has_finished())return!1;if(this.model.visible)for(const[,e]of this.renderer_views)if(!e.has_finished())return!1;return!0}after_layout(){var e;super.after_layout();for(const[,t]of this.renderer_views)t instanceof _.AnnotationView&&(null===(e=t.after_layout)||void 0===e||e.call(t));if(this._needs_layout=!1,this.model.setv({inner_width:Math.round(this.frame.bbox.width),inner_height:Math.round(this.frame.bbox.height),outer_width:Math.round(this.layout.bbox.width),outer_height:Math.round(this.layout.bbox.height)},{no_change:!0}),!1!==this.model.match_aspect&&(this.pause(),this._range_manager.update_dataranges(),this.unpause(!0)),!this._outer_bbox.equals(this.layout.bbox)){const{width:e,height:t}=this.layout.bbox;this.canvas_view.resize(e,t),this._outer_bbox=this.layout.bbox,this._invalidate_all=!0,this._needs_paint=!0}const{inner_bbox:t}=this.layout;this._inner_bbox.equals(t)||(this._inner_bbox=t,this._needs_paint=!0),this._needs_paint&&this.paint()}repaint(){this._needs_layout&&this._invalidate_layout(),this.paint()}paint(){var e;if(this.is_paused||!this.model.visible)return;b.logger.trace(`PlotView.paint() for ${this.model.id}`);const{document:t}=this.model;if(null!=t){const e=t.interactive_duration();e>=0&&e{t.interactive_duration()>this.model.lod_timeout&&t.interactive_stop(),this.request_paint(\"everything\")}),this.model.lod_timeout):t.interactive_stop()}this._range_manager.invalidate_dataranges&&(this._range_manager.update_dataranges(),this._invalidate_layout());let i=!1,s=!1;if(this._invalidate_all)i=!0,s=!0;else for(const e of this._invalidated_painters){const{level:t}=e.model;if(\"overlay\"!=t?i=!0:s=!0,i&&s)break}this._invalidated_painters.clear(),this._invalidate_all=!1;const a=[this.frame.bbox.left,this.frame.bbox.top,this.frame.bbox.width,this.frame.bbox.height],{primary:n,overlays:o}=this.canvas_view;i&&(n.prepare(),this.canvas_view.prepare_webgl(a),this._map_hook(n.ctx,a),this._paint_empty(n.ctx,a),this._paint_outline(n.ctx,a),this._paint_levels(n.ctx,\"image\",a,!0),this._paint_levels(n.ctx,\"underlay\",a,!0),this._paint_levels(n.ctx,\"glyph\",a,!0),this._paint_levels(n.ctx,\"guide\",a,!1),this._paint_levels(n.ctx,\"annotation\",a,!1),n.finish()),(s||P.settings.wireframe)&&(o.prepare(),this._paint_levels(o.ctx,\"overlay\",a,!1),P.settings.wireframe&&this._paint_layout(o.ctx,this.layout),o.finish()),null==this._initial_state.range&&(this._initial_state.range=null!==(e=this._range_manager.compute_initial())&&void 0!==e?e:void 0),this._needs_paint=!1}_paint_levels(e,t,i,s){for(const a of this.computed_renderers){if(a.level!=t)continue;const n=this.renderer_views.get(a);e.save(),(s||n.needs_clip)&&(e.beginPath(),e.rect(...i),e.clip()),n.render(),e.restore(),n.has_webgl&&n.needs_webgl_blit&&this.canvas_view.blit_webgl(e)}}_paint_layout(e,t){const{x:i,y:s,width:a,height:n}=t.bbox;e.strokeStyle=\"blue\",e.strokeRect(i,s,a,n);for(const a of t)e.save(),t.absolute||e.translate(i,s),this._paint_layout(e,a),e.restore()}_map_hook(e,t){}_paint_empty(e,t){const[i,s,a,n]=[0,0,this.layout.bbox.width,this.layout.bbox.height],[o,l,r,_]=t;this.visuals.border_fill.doit&&(this.visuals.border_fill.set_value(e),e.fillRect(i,s,a,n),e.clearRect(o,l,r,_)),this.visuals.background_fill.doit&&(this.visuals.background_fill.set_value(e),e.fillRect(o,l,r,_))}_paint_outline(e,t){if(this.visuals.outline_line.doit){e.save(),this.visuals.outline_line.set_value(e);let[i,s,a,n]=t;i+a==this.layout.bbox.width&&(a-=1),s+n==this.layout.bbox.height&&(n-=1),e.strokeRect(i,s,a,n),e.restore()}}to_blob(){return this.canvas_view.to_blob()}export(e,t=!0){const i=\"png\"==e?\"canvas\":\"svg\",s=new y.CanvasLayer(i,t),{width:a,height:n}=this.layout.bbox;s.resize(a,n);const{canvas:o}=this.canvas_view.compose();return s.ctx.drawImage(o,0,0),s}serializable_state(){const e=super.serializable_state(),{children:t}=e,i=n.__rest(e,[\"children\"]),s=this.get_renderer_views().map((e=>e.serializable_state())).filter((e=>null!=e.bbox));return Object.assign(Object.assign({},i),{children:[...null!=t?t:[],...s]})}}i.PlotView=R,R.__name__=\"PlotView\"},\n", + " function _(t,n,e,o,u){o(),e.throttle=function(t,n){let e=null,o=0,u=!1;return function(){return new Promise(((r,i)=>{const l=function(){o=Date.now(),e=null,u=!1;try{t(),r()}catch(t){i(t)}},a=Date.now(),c=n-(a-o);c<=0&&!u?(null!=e&&clearTimeout(e),u=!0,requestAnimationFrame(l)):e||u?r():e=setTimeout((()=>requestAnimationFrame(l)),c)}))}}},\n", + " function _(t,n,e,s,a){s();const o=t(159),r=t(19);class l{constructor(t){this.parent=t,this.invalidate_dataranges=!0}get frame(){return this.parent.frame}update(t,n){const{x_ranges:e,y_ranges:s}=this.frame;if(null==t){for(const[,t]of e)t.reset();for(const[,t]of s)t.reset();this.update_dataranges()}else{const a=[];for(const[n,s]of e)a.push([s,t.xrs.get(n)]);for(const[n,e]of s)a.push([e,t.yrs.get(n)]);(null==n?void 0:n.scrolling)&&this._update_ranges_together(a),this._update_ranges_individually(a,n)}}reset(){this.update(null)}update_dataranges(){const t=new Map,n=new Map;let e=!1;for(const[,t]of this.frame.x_ranges)t instanceof o.DataRange1d&&\"log\"==t.scale_hint&&(e=!0);for(const[,t]of this.frame.y_ranges)t instanceof o.DataRange1d&&\"log\"==t.scale_hint&&(e=!0);for(const s of this.parent.model.data_renderers){const a=this.parent.renderer_view(s);if(null==a)continue;const o=a.glyph_view.bounds();if(null!=o&&t.set(s,o),e){const t=a.glyph_view.log_bounds();null!=t&&n.set(s,t)}}let s=!1,a=!1;const{width:l,height:i}=this.frame.bbox;let d;!1!==this.parent.model.match_aspect&&0!=l&&0!=i&&(d=1/this.parent.model.aspect_scale*(l/i));for(const[,e]of this.frame.x_ranges){if(e instanceof o.DataRange1d){const a=\"log\"==e.scale_hint?n:t;e.update(a,0,this.parent.model,d),e.follow&&(s=!0)}null!=e.bounds&&(a=!0)}for(const[,e]of this.frame.y_ranges){if(e instanceof o.DataRange1d){const a=\"log\"==e.scale_hint?n:t;e.update(a,1,this.parent.model,d),e.follow&&(s=!0)}null!=e.bounds&&(a=!0)}if(s&&a){r.logger.warn(\"Follow enabled so bounds are unset.\");for(const[,t]of this.frame.x_ranges)t.bounds=null;for(const[,t]of this.frame.y_ranges)t.bounds=null}this.invalidate_dataranges=!1}compute_initial(){let t=!0;const{x_ranges:n,y_ranges:e}=this.frame,s=new Map,a=new Map;for(const[e,a]of n){const{start:n,end:o}=a;if(null==n||null==o||isNaN(n+o)){t=!1;break}s.set(e,{start:n,end:o})}if(t)for(const[n,s]of e){const{start:e,end:o}=s;if(null==e||null==o||isNaN(e+o)){t=!1;break}a.set(n,{start:e,end:o})}return t?{xrs:s,yrs:a}:(r.logger.warn(\"could not set initial ranges\"),null)}_update_ranges_together(t){let n=1;for(const[e,s]of t)n=Math.min(n,this._get_weight_to_constrain_interval(e,s));if(n<1)for(const[e,s]of t)s.start=n*s.start+(1-n)*e.start,s.end=n*s.end+(1-n)*e.end}_update_ranges_individually(t,n){const e=!!(null==n?void 0:n.panning),s=!!(null==n?void 0:n.scrolling);let a=!1;for(const[n,o]of t){if(!s){const t=this._get_weight_to_constrain_interval(n,o);t<1&&(o.start=t*o.start+(1-t)*n.start,o.end=t*o.end+(1-t)*n.end)}if(null!=n.bounds&&\"auto\"!=n.bounds){const[t,r]=n.bounds,l=Math.abs(o.end-o.start);n.is_reversed?(null!=t&&t>=o.end&&(a=!0,o.end=t,(e||s)&&(o.start=t+l)),null!=r&&r<=o.start&&(a=!0,o.start=r,(e||s)&&(o.end=r-l))):(null!=t&&t>=o.start&&(a=!0,o.start=t,(e||s)&&(o.end=t+l)),null!=r&&r<=o.end&&(a=!0,o.end=r,(e||s)&&(o.start=r-l)))}}if(!(s&&a&&(null==n?void 0:n.maintain_focus)))for(const[n,e]of t)n.have_updated_interactively=!0,n.start==e.start&&n.end==e.end||n.setv(e)}_get_weight_to_constrain_interval(t,n){const{min_interval:e}=t;let{max_interval:s}=t;if(null!=t.bounds&&\"auto\"!=t.bounds){const[n,e]=t.bounds;if(null!=n&&null!=e){const t=Math.abs(e-n);s=null!=s?Math.min(s,t):t}}let a=1;if(null!=e||null!=s){const o=Math.abs(t.end-t.start),r=Math.abs(n.end-n.start);null!=e&&e>0&&r0&&r>s&&(a=(s-o)/(r-o)),a=Math.max(0,Math.min(1,a))}return a}}e.RangeManager=l,l.__name__=\"RangeManager\"},\n", + " function _(t,i,s,e,n){e();const h=t(15);class a{constructor(t,i){this.parent=t,this.initial_state=i,this.changed=new h.Signal0(this.parent,\"state_changed\"),this.history=[],this.index=-1}_do_state_change(t){const i=null!=this.history[t]?this.history[t].state:this.initial_state;null!=i.range&&this.parent.update_range(i.range),null!=i.selection&&this.parent.update_selection(i.selection)}push(t,i){const{history:s,index:e}=this,n=null!=s[e]?s[e].state:{},h=Object.assign(Object.assign(Object.assign({},this.initial_state),n),i);this.history=this.history.slice(0,this.index+1),this.history.push({type:t,state:h}),this.index=this.history.length-1,this.changed.emit()}clear(){this.history=[],this.index=-1,this.changed.emit()}undo(){this.can_undo&&(this.index-=1,this._do_state_change(this.index),this.changed.emit())}redo(){this.can_redo&&(this.index+=1,this._do_state_change(this.index),this.changed.emit())}get can_undo(){return this.index>=0}get can_redo(){return this.indexm.emit();const s=encodeURIComponent,o=document.createElement(\"script\");o.type=\"text/javascript\",o.src=`https://maps.googleapis.com/maps/api/js?v=${s(e)}&key=${s(t)}&callback=_bokeh_gmaps_callback`,document.body.appendChild(o)}(t,e)}m.connect((()=>this.request_paint(\"everything\")))}this.unpause()}remove(){p.remove(this.map_el),super.remove()}update_range(t,e){var s,o;if(null==t)this.map.setCenter({lat:this.initial_lat,lng:this.initial_lng}),this.map.setOptions({zoom:this.initial_zoom}),super.update_range(null,e);else if(null!=t.sdx||null!=t.sdy)this.map.panBy(null!==(s=t.sdx)&&void 0!==s?s:0,null!==(o=t.sdy)&&void 0!==o?o:0),super.update_range(t,e);else if(null!=t.factor){if(10!==this.zoom_count)return void(this.zoom_count+=1);this.zoom_count=0,this.pause(),super.update_range(t,e);const s=t.factor<0?-1:1,o=this.map.getZoom(),i=o+s;if(i>=2){this.map.setZoom(i);const[t,e,,]=this._get_projected_bounds();e-t<0&&this.map.setZoom(o)}this.unpause()}this._set_bokeh_ranges()}_build_map(){const{maps:t}=google;this.map_types={satellite:t.MapTypeId.SATELLITE,terrain:t.MapTypeId.TERRAIN,roadmap:t.MapTypeId.ROADMAP,hybrid:t.MapTypeId.HYBRID};const e=this.model.map_options,s={center:new t.LatLng(e.lat,e.lng),zoom:e.zoom,disableDefaultUI:!0,mapTypeId:this.map_types[e.map_type],scaleControl:e.scale_control,tilt:e.tilt};null!=e.styles&&(s.styles=JSON.parse(e.styles)),this.map_el=p.div({style:{position:\"absolute\"}}),this.canvas_view.add_underlay(this.map_el),this.map=new t.Map(this.map_el,s),t.event.addListener(this.map,\"idle\",(()=>this._set_bokeh_ranges())),t.event.addListener(this.map,\"bounds_changed\",(()=>this._set_bokeh_ranges())),t.event.addListenerOnce(this.map,\"tilesloaded\",(()=>this._render_finished())),this.connect(this.model.properties.map_options.change,(()=>this._update_options())),this.connect(this.model.map_options.properties.styles.change,(()=>this._update_styles())),this.connect(this.model.map_options.properties.lat.change,(()=>this._update_center(\"lat\"))),this.connect(this.model.map_options.properties.lng.change,(()=>this._update_center(\"lng\"))),this.connect(this.model.map_options.properties.zoom.change,(()=>this._update_zoom())),this.connect(this.model.map_options.properties.map_type.change,(()=>this._update_map_type())),this.connect(this.model.map_options.properties.scale_control.change,(()=>this._update_scale_control())),this.connect(this.model.map_options.properties.tilt.change,(()=>this._update_tilt()))}_render_finished(){this._tiles_loaded=!0,this.notify_finished()}has_finished(){return super.has_finished()&&!0===this._tiles_loaded}_get_latlon_bounds(){const t=this.map.getBounds(),e=t.getNorthEast(),s=t.getSouthWest();return[s.lng(),e.lng(),s.lat(),e.lat()]}_get_projected_bounds(){const[t,e,s,o]=this._get_latlon_bounds(),[i,a]=l.wgs84_mercator.compute(t,s),[n,p]=l.wgs84_mercator.compute(e,o);return[i,n,a,p]}_set_bokeh_ranges(){const[t,e,s,o]=this._get_projected_bounds();this.frame.x_range.setv({start:t,end:e}),this.frame.y_range.setv({start:s,end:o})}_update_center(t){const e=this.map.getCenter().toJSON();e[t]=this.model.map_options[t],this.map.setCenter(e),this._set_bokeh_ranges()}_update_map_type(){this.map.setOptions({mapTypeId:this.map_types[this.model.map_options.map_type]})}_update_scale_control(){this.map.setOptions({scaleControl:this.model.map_options.scale_control})}_update_tilt(){this.map.setOptions({tilt:this.model.map_options.tilt})}_update_options(){this._update_styles(),this._update_center(\"lat\"),this._update_center(\"lng\"),this._update_zoom(),this._update_map_type()}_update_styles(){this.map.setOptions({styles:JSON.parse(this.model.map_options.styles)})}_update_zoom(){this.map.setOptions({zoom:this.model.map_options.zoom}),this._set_bokeh_ranges()}_map_hook(t,e){if(null==this.map&&\"undefined\"!=typeof google&&null!=google.maps&&this._build_map(),null!=this.map_el){const[t,s,o,i]=e;this.map_el.style.top=`${s}px`,this.map_el.style.left=`${t}px`,this.map_el.style.width=`${o}px`,this.map_el.style.height=`${i}px`}}_paint_empty(t,e){const s=this.layout.bbox.width,o=this.layout.bbox.height,[i,a,n,p]=e;t.clearRect(0,0,s,o),t.beginPath(),t.moveTo(0,0),t.lineTo(0,o),t.lineTo(s,o),t.lineTo(s,0),t.lineTo(0,0),t.moveTo(i,a),t.lineTo(i+n,a),t.lineTo(i+n,a+p),t.lineTo(i,a+p),t.lineTo(i,a),t.closePath(),null!=this.model.border_fill_color&&(t.fillStyle=_.color2css(this.model.border_fill_color),t.fill())}}s.GMapPlotView=d,d.__name__=\"GMapPlotView\"},\n", + " function _(t,_,n,o,r){o();t(1).__exportStar(t(169),n)},\n", + " function _(e,r,d,n,R){n(),R(\"GlyphRenderer\",e(61).GlyphRenderer),R(\"GraphRenderer\",e(123).GraphRenderer),R(\"GuideRenderer\",e(164).GuideRenderer),R(\"Renderer\",e(41).Renderer)},\n", + " function _(e,t,n,o,c){o();e(1).__exportStar(e(129),n),c(\"Selection\",e(59).Selection)},\n", + " function _(a,e,S,o,r){o(),r(\"ServerSentDataSource\",a(342).ServerSentDataSource),r(\"AjaxDataSource\",a(344).AjaxDataSource),r(\"ColumnDataSource\",a(130).ColumnDataSource),r(\"ColumnarDataSource\",a(57).ColumnarDataSource),r(\"CDSView\",a(120).CDSView),r(\"DataSource\",a(58).DataSource),r(\"GeoJSONDataSource\",a(345).GeoJSONDataSource),r(\"WebDataSource\",a(343).WebDataSource)},\n", + " function _(e,t,i,a,s){a();const n=e(343);class r extends n.WebDataSource{constructor(e){super(e),this.initialized=!1}setup(){if(!this.initialized){this.initialized=!0;new EventSource(this.data_url).onmessage=e=>{var t;this.load_data(JSON.parse(e.data),this.mode,null!==(t=this.max_size)&&void 0!==t?t:void 0)}}}}i.ServerSentDataSource=r,r.__name__=\"ServerSentDataSource\"},\n", + " function _(t,e,a,n,s){n();const r=t(130),i=t(20);class l extends r.ColumnDataSource{constructor(t){super(t)}get_column(t){const e=this.data[t];return null!=e?e:[]}get_length(){var t;return null!==(t=super.get_length())&&void 0!==t?t:0}initialize(){super.initialize(),this.setup()}load_data(t,e,a){const{adapter:n}=this;let s;switch(s=null!=n?n.execute(this,{response:t}):t,e){case\"replace\":this.data=s;break;case\"append\":{const t=this.data;for(const e of this.columns()){const n=Array.from(t[e]),r=Array.from(s[e]),i=n.concat(r);s[e]=null!=a?i.slice(-a):i}this.data=s;break}}}static init_WebDataSource(){this.define((({Any:t,Int:e,String:a,Nullable:n})=>({max_size:[n(e),null],mode:[i.UpdateMode,\"replace\"],adapter:[n(t),null],data_url:[a]})))}}a.WebDataSource=l,l.__name__=\"WebDataSource\",l.init_WebDataSource()},\n", + " function _(t,e,i,s,a){s();const n=t(343),r=t(20),o=t(19),l=t(13);class d extends n.WebDataSource{constructor(t){super(t),this.interval=null,this.initialized=!1}static init_AjaxDataSource(){this.define((({Boolean:t,Int:e,String:i,Dict:s,Nullable:a})=>({polling_interval:[a(e),null],content_type:[i,\"application/json\"],http_headers:[s(i),{}],method:[r.HTTPMethod,\"POST\"],if_modified:[t,!1]})))}destroy(){null!=this.interval&&clearInterval(this.interval),super.destroy()}setup(){if(!this.initialized&&(this.initialized=!0,this.get_data(this.mode),null!=this.polling_interval)){const t=()=>this.get_data(this.mode,this.max_size,this.if_modified);this.interval=setInterval(t,this.polling_interval)}}get_data(t,e=null,i=!1){const s=this.prepare_request();s.addEventListener(\"load\",(()=>this.do_load(s,t,null!=e?e:void 0))),s.addEventListener(\"error\",(()=>this.do_error(s))),s.send()}prepare_request(){const t=new XMLHttpRequest;t.open(this.method,this.data_url,!0),t.withCredentials=!1,t.setRequestHeader(\"Content-Type\",this.content_type);const e=this.http_headers;for(const[i,s]of l.entries(e))t.setRequestHeader(i,s);return t}do_load(t,e,i){if(200===t.status){const s=JSON.parse(t.responseText);this.load_data(s,e,i)}}do_error(t){o.logger.error(`Failed to fetch JSON from ${this.data_url} with code ${t.status}`)}}i.AjaxDataSource=d,d.__name__=\"AjaxDataSource\",d.init_AjaxDataSource()},\n", + " function _(e,t,o,r,n){r();const s=e(57),a=e(19),i=e(9),l=e(13);function c(e){return null!=e?e:NaN}const{hasOwnProperty:_}=Object.prototype;class g extends s.ColumnarDataSource{constructor(e){super(e)}static init_GeoJSONDataSource(){this.define((({String:e})=>({geojson:[e]}))),this.internal((({Dict:e,Arrayable:t})=>({data:[e(t),{}]})))}initialize(){super.initialize(),this._update_data()}connect_signals(){super.connect_signals(),this.connect(this.properties.geojson.change,(()=>this._update_data()))}_update_data(){this.data=this.geojson_to_column_data()}_get_new_list_array(e){return i.range(0,e).map((e=>[]))}_get_new_nan_array(e){return i.range(0,e).map((e=>NaN))}_add_properties(e,t,o,r){var n;const s=null!==(n=e.properties)&&void 0!==n?n:{};for(const[e,n]of l.entries(s))_.call(t,e)||(t[e]=this._get_new_nan_array(r)),t[e][o]=c(n)}_add_geometry(e,t,o){function r(e,t){return e.concat([[NaN,NaN,NaN]]).concat(t)}switch(e.type){case\"Point\":{const[r,n,s]=e.coordinates;t.x[o]=r,t.y[o]=n,t.z[o]=c(s);break}case\"LineString\":{const{coordinates:r}=e;for(let e=0;e1&&a.logger.warn(\"Bokeh does not support Polygons with holes in, only exterior ring used.\");const r=e.coordinates[0];for(let e=0;e1&&a.logger.warn(\"Bokeh does not support Polygons with holes in, only exterior ring used.\"),n.push(t[0]);const s=n.reduce(r);for(let e=0;e({use_latlon:[e,!1]})))}get_image_url(e,t,r){const i=this.string_lookup_replace(this.url,this.extra_url_vars);let o,l,n,s;return this.use_latlon?[l,s,o,n]=this.get_tile_geographic_bounds(e,t,r):[l,s,o,n]=this.get_tile_meter_bounds(e,t,r),i.replace(\"{XMIN}\",l.toString()).replace(\"{YMIN}\",s.toString()).replace(\"{XMAX}\",o.toString()).replace(\"{YMAX}\",n.toString())}}r.BBoxTileSource=n,n.__name__=\"BBoxTileSource\",n.init_BBoxTileSource()},\n", + " function _(t,e,i,_,s){_();const r=t(349),o=t(9),n=t(350);class l extends r.TileSource{constructor(t){super(t)}static init_MercatorTileSource(){this.define((({Boolean:t})=>({snap_to_zoom:[t,!1],wrap_around:[t,!0]}))),this.override({x_origin_offset:20037508.34,y_origin_offset:20037508.34,initial_resolution:156543.03392804097})}initialize(){super.initialize(),this._resolutions=o.range(this.min_zoom,this.max_zoom+1).map((t=>this.get_resolution(t)))}_computed_initial_resolution(){return null!=this.initial_resolution?this.initial_resolution:2*Math.PI*6378137/this.tile_size}is_valid_tile(t,e,i){return!(!this.wrap_around&&(t<0||t>=2**i))&&!(e<0||e>=2**i)}parent_by_tile_xyz(t,e,i){const _=this.tile_xyz_to_quadkey(t,e,i),s=_.substring(0,_.length-1);return this.quadkey_to_tile_xyz(s)}get_resolution(t){return this._computed_initial_resolution()/2**t}get_resolution_by_extent(t,e,i){return[(t[2]-t[0])/i,(t[3]-t[1])/e]}get_level_by_extent(t,e,i){const _=(t[2]-t[0])/i,s=(t[3]-t[1])/e,r=Math.max(_,s);let o=0;for(const t of this._resolutions){if(r>t){if(0==o)return 0;if(o>0)return o-1}o+=1}return o-1}get_closest_level_by_extent(t,e,i){const _=(t[2]-t[0])/i,s=(t[3]-t[1])/e,r=Math.max(_,s),o=this._resolutions.reduce((function(t,e){return Math.abs(e-r)e?(u=o-s,a*=t):(u*=e,a=n-r)}const h=(u-(o-s))/2,c=(a-(n-r))/2;return[s-h,r-c,o+h,n+c]}tms_to_wmts(t,e,i){return[t,2**i-1-e,i]}wmts_to_tms(t,e,i){return[t,2**i-1-e,i]}pixels_to_meters(t,e,i){const _=this.get_resolution(i);return[t*_-this.x_origin_offset,e*_-this.y_origin_offset]}meters_to_pixels(t,e,i){const _=this.get_resolution(i);return[(t+this.x_origin_offset)/_,(e+this.y_origin_offset)/_]}pixels_to_tile(t,e){let i=Math.ceil(t/this.tile_size);i=0===i?i:i-1;return[i,Math.max(Math.ceil(e/this.tile_size)-1,0)]}pixels_to_raster(t,e,i){return[t,(this.tile_size<=l;t--)for(let i=n;i<=u;i++)this.is_valid_tile(i,t,e)&&h.push([i,t,e,this.get_tile_meter_bounds(i,t,e)]);return this.sort_tiles_from_center(h,[n,l,u,a]),h}quadkey_to_tile_xyz(t){let e=0,i=0;const _=t.length;for(let s=_;s>0;s--){const r=1<0;s--){const i=1<0;)if(s=s.substring(0,s.length-1),[t,e,i]=this.quadkey_to_tile_xyz(s),[t,e,i]=this.denormalize_xyz(t,e,i,_),this.tiles.has(this.tile_xyz_to_key(t,e,i)))return[t,e,i];return[0,0,0]}normalize_xyz(t,e,i){if(this.wrap_around){const _=2**i;return[(t%_+_)%_,e,i]}return[t,e,i]}denormalize_xyz(t,e,i,_){return[t+_*2**i,e,i]}denormalize_meters(t,e,i,_){return[t+2*_*Math.PI*6378137,e]}calculate_world_x_by_tile_xyz(t,e,i){return Math.floor(t/2**i)}}i.MercatorTileSource=l,l.__name__=\"MercatorTileSource\",l.init_MercatorTileSource()},\n", + " function _(e,t,r,i,n){i();const l=e(53),s=e(13);class a extends l.Model{constructor(e){super(e)}static init_TileSource(){this.define((({Number:e,String:t,Dict:r,Nullable:i})=>({url:[t,\"\"],tile_size:[e,256],max_zoom:[e,30],min_zoom:[e,0],extra_url_vars:[r(t),{}],attribution:[t,\"\"],x_origin_offset:[e],y_origin_offset:[e],initial_resolution:[i(e),null]})))}initialize(){super.initialize(),this.tiles=new Map,this._normalize_case()}connect_signals(){super.connect_signals(),this.connect(this.change,(()=>this._clear_cache()))}string_lookup_replace(e,t){let r=e;for(const[e,i]of s.entries(t))r=r.replace(`{${e}}`,i);return r}_normalize_case(){const e=this.url.replace(\"{x}\",\"{X}\").replace(\"{y}\",\"{Y}\").replace(\"{z}\",\"{Z}\").replace(\"{q}\",\"{Q}\").replace(\"{xmin}\",\"{XMIN}\").replace(\"{ymin}\",\"{YMIN}\").replace(\"{xmax}\",\"{XMAX}\").replace(\"{ymax}\",\"{YMAX}\");this.url=e}_clear_cache(){this.tiles=new Map}tile_xyz_to_key(e,t,r){return`${e}:${t}:${r}`}key_to_tile_xyz(e){const[t,r,i]=e.split(\":\").map((e=>parseInt(e)));return[t,r,i]}sort_tiles_from_center(e,t){const[r,i,n,l]=t,s=(n-r)/2+r,a=(l-i)/2+i;e.sort((function(e,t){return Math.sqrt((s-e[0])**2+(a-e[1])**2)-Math.sqrt((s-t[0])**2+(a-t[1])**2)}))}get_image_url(e,t,r){return this.string_lookup_replace(this.url,this.extra_url_vars).replace(\"{X}\",e.toString()).replace(\"{Y}\",t.toString()).replace(\"{Z}\",r.toString())}}r.TileSource=a,a.__name__=\"TileSource\",a.init_TileSource()},\n", + " function _(t,e,r,n,o){n();const c=t(65);function _(t,e){return c.wgs84_mercator.compute(t,e)}function g(t,e){return c.wgs84_mercator.invert(t,e)}r.geographic_to_meters=_,r.meters_to_geographic=g,r.geographic_extent_to_meters=function(t){const[e,r,n,o]=t,[c,g]=_(e,r),[i,u]=_(n,o);return[c,g,i,u]},r.meters_extent_to_geographic=function(t){const[e,r,n,o]=t,[c,_]=g(e,r),[i,u]=g(n,o);return[c,_,i,u]}},\n", + " function _(e,t,r,s,_){s();const o=e(348);class c extends o.MercatorTileSource{constructor(e){super(e)}get_image_url(e,t,r){const s=this.string_lookup_replace(this.url,this.extra_url_vars),[_,o,c]=this.tms_to_wmts(e,t,r),i=this.tile_xyz_to_quadkey(_,o,c);return s.replace(\"{Q}\",i)}}r.QUADKEYTileSource=c,c.__name__=\"QUADKEYTileSource\"},\n", + " function _(t,e,i,s,_){s();const n=t(1),a=t(349),h=t(353),r=t(41),o=t(156),l=t(43),d=t(296),m=t(9),c=t(8),p=n.__importStar(t(354));class g extends r.RendererView{initialize(){this._tiles=[],super.initialize()}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.request_render())),this.connect(this.model.tile_source.change,(()=>this.request_render()))}styles(){return[...super.styles(),p.default]}get_extent(){return[this.x_range.start,this.y_range.start,this.x_range.end,this.y_range.end]}get map_plot(){return this.plot_model}get map_canvas(){return this.layer.ctx}get map_frame(){return this.plot_view.frame}get x_range(){return this.map_plot.x_range}get y_range(){return this.map_plot.y_range}_set_data(){this.extent=this.get_extent(),this._last_height=void 0,this._last_width=void 0}_update_attribution(){null!=this.attribution_el&&l.removeElement(this.attribution_el);const{attribution:t}=this.model.tile_source;if(c.isString(t)&&t.length>0){const{layout:e,frame:i}=this.plot_view,s=e.bbox.width-i.bbox.right,_=e.bbox.height-i.bbox.bottom,n=i.bbox.width;this.attribution_el=l.div({class:p.tile_attribution,style:{position:\"absolute\",right:`${s}px`,bottom:`${_}px`,\"max-width\":n-4+\"px\",padding:\"2px\",\"background-color\":\"rgba(255,255,255,0.5)\",\"font-size\":\"9px\",\"line-height\":\"1.05\",\"white-space\":\"nowrap\",overflow:\"hidden\",\"text-overflow\":\"ellipsis\"}}),this.plot_view.canvas_view.add_event(this.attribution_el),this.attribution_el.innerHTML=t,this.attribution_el.title=this.attribution_el.textContent.replace(/\\s*\\n\\s*/g,\" \")}}_map_data(){this.initial_extent=this.get_extent();const t=this.model.tile_source.get_level_by_extent(this.initial_extent,this.map_frame.bbox.height,this.map_frame.bbox.width),e=this.model.tile_source.snap_to_zoom_level(this.initial_extent,this.map_frame.bbox.height,this.map_frame.bbox.width,t);this.x_range.start=e[0],this.y_range.start=e[1],this.x_range.end=e[2],this.y_range.end=e[3],this.x_range instanceof o.Range1d&&(this.x_range.reset_start=e[0],this.x_range.reset_end=e[2]),this.y_range instanceof o.Range1d&&(this.y_range.reset_start=e[1],this.y_range.reset_end=e[3]),this._update_attribution()}_create_tile(t,e,i,s,_=!1){const[n,a,h]=this.model.tile_source.normalize_xyz(t,e,i),r={img:void 0,tile_coords:[t,e,i],normalized_coords:[n,a,h],quadkey:this.model.tile_source.tile_xyz_to_quadkey(t,e,i),cache_key:this.model.tile_source.tile_xyz_to_key(t,e,i),bounds:s,loaded:!1,finished:!1,x_coord:s[0],y_coord:s[3]},o=this.model.tile_source.get_image_url(n,a,h);new d.ImageLoader(o,{loaded:t=>{Object.assign(r,{img:t,loaded:!0}),_?(r.finished=!0,this.notify_finished()):this.request_render()},failed(){r.finished=!0}}),this.model.tile_source.tiles.set(r.cache_key,r),this._tiles.push(r)}_enforce_aspect_ratio(){if(this._last_height!==this.map_frame.bbox.height||this._last_width!==this.map_frame.bbox.width){const t=this.get_extent(),e=this.model.tile_source.get_level_by_extent(t,this.map_frame.bbox.height,this.map_frame.bbox.width),i=this.model.tile_source.snap_to_zoom_level(t,this.map_frame.bbox.height,this.map_frame.bbox.width,e);this.x_range.setv({start:i[0],end:i[2]}),this.y_range.setv({start:i[1],end:i[3]}),this.extent=i,this._last_height=this.map_frame.bbox.height,this._last_width=this.map_frame.bbox.width}}has_finished(){if(!super.has_finished())return!1;if(0===this._tiles.length)return!1;for(const t of this._tiles)if(!t.finished)return!1;return!0}_render(){null==this.map_initialized&&(this._set_data(),this._map_data(),this.map_initialized=!0),this._enforce_aspect_ratio(),this._update(),null!=this.prefetch_timer&&clearTimeout(this.prefetch_timer),this.prefetch_timer=setTimeout(this._prefetch_tiles.bind(this),500),this.has_finished()&&this.notify_finished()}_draw_tile(t){const e=this.model.tile_source.tiles.get(t);if(null!=e&&e.loaded){const[[t],[i]]=this.coordinates.map_to_screen([e.bounds[0]],[e.bounds[3]]),[[s],[_]]=this.coordinates.map_to_screen([e.bounds[2]],[e.bounds[1]]),n=s-t,a=_-i,h=t,r=i,o=this.map_canvas.getImageSmoothingEnabled();this.map_canvas.setImageSmoothingEnabled(this.model.smoothing),this.map_canvas.drawImage(e.img,h,r,n,a),this.map_canvas.setImageSmoothingEnabled(o),e.finished=!0}}_set_rect(){const t=this.plot_model.outline_line_width,e=this.map_frame.bbox.left+t/2,i=this.map_frame.bbox.top+t/2,s=this.map_frame.bbox.width-t,_=this.map_frame.bbox.height-t;this.map_canvas.rect(e,i,s,_),this.map_canvas.clip()}_render_tiles(t){this.map_canvas.save(),this._set_rect(),this.map_canvas.globalAlpha=this.model.alpha;for(const e of t)this._draw_tile(e);this.map_canvas.restore()}_prefetch_tiles(){const{tile_source:t}=this.model,e=this.get_extent(),i=this.map_frame.bbox.height,s=this.map_frame.bbox.width,_=this.model.tile_source.get_level_by_extent(e,i,s),n=this.model.tile_source.get_tiles_by_extent(e,_);for(let e=0,i=Math.min(10,n.length);ei&&(s=this.extent,h=i,r=!0),r&&(this.x_range.setv({start:s[0],end:s[2]}),this.y_range.setv({start:s[1],end:s[3]})),this.extent=s;const o=t.get_tiles_by_extent(s,h),l=[],d=[],c=[],p=[];for(const e of o){const[i,s,n]=e,a=t.tile_xyz_to_key(i,s,n),h=t.tiles.get(a);if(null!=h&&h.loaded)d.push(a);else if(this.model.render_parents){const[e,a,h]=t.get_closest_parent_by_tile_xyz(i,s,n),r=t.tile_xyz_to_key(e,a,h),o=t.tiles.get(r);if(null!=o&&o.loaded&&!m.includes(c,r)&&c.push(r),_){const e=t.children_by_tile_xyz(i,s,n);for(const[i,s,_]of e){const e=t.tile_xyz_to_key(i,s,_);t.tiles.has(e)&&p.push(e)}}}null==h&&l.push(e)}this._render_tiles(c),this._render_tiles(p),this._render_tiles(d),null!=this.render_timer&&clearTimeout(this.render_timer),this.render_timer=setTimeout((()=>this._fetch_tiles(l)),65)}}i.TileRendererView=g,g.__name__=\"TileRendererView\";class u extends r.Renderer{constructor(t){super(t)}static init_TileRenderer(){this.prototype.default_view=g,this.define((({Boolean:t,Number:e,Ref:i})=>({alpha:[e,1],smoothing:[t,!0],tile_source:[i(a.TileSource),()=>new h.WMTSTileSource],render_parents:[t,!0]}))),this.override({level:\"image\"})}}i.TileRenderer=u,u.__name__=\"TileRenderer\",u.init_TileRenderer()},\n", + " function _(t,e,r,o,s){o();const c=t(348);class i extends c.MercatorTileSource{constructor(t){super(t)}get_image_url(t,e,r){const o=this.string_lookup_replace(this.url,this.extra_url_vars),[s,c,i]=this.tms_to_wmts(t,e,r);return o.replace(\"{X}\",s.toString()).replace(\"{Y}\",c.toString()).replace(\"{Z}\",i.toString())}}r.WMTSTileSource=i,i.__name__=\"WMTSTileSource\"},\n", + " function _(t,o,i,b,r){b(),i.root=\"bk-root\",i.tile_attribution=\"bk-tile-attribution\",i.default=\".bk-root .bk-tile-attribution a{color:black;}\"},\n", + " function _(e,r,t,c,o){c();const i=e(348);class l extends i.MercatorTileSource{constructor(e){super(e)}get_image_url(e,r,t){return this.string_lookup_replace(this.url,this.extra_url_vars).replace(\"{X}\",e.toString()).replace(\"{Y}\",r.toString()).replace(\"{Z}\",t.toString())}}t.TMSTileSource=l,l.__name__=\"TMSTileSource\"},\n", + " function _(e,t,u,a,r){a(),r(\"CanvasTexture\",e(357).CanvasTexture),r(\"ImageURLTexture\",e(359).ImageURLTexture),r(\"Texture\",e(358).Texture)},\n", + " function _(t,e,n,c,s){c();const a=t(358),i=t(34);class r extends a.Texture{constructor(t){super(t)}static init_CanvasTexture(){this.define((({String:t})=>({code:[t]})))}get func(){const t=i.use_strict(this.code);return new Function(\"ctx\",\"color\",\"scale\",\"weight\",t)}get_pattern(t,e,n){const c=document.createElement(\"canvas\");c.width=e,c.height=e;const s=c.getContext(\"2d\");return this.func.call(this,s,t,e,n),c}}n.CanvasTexture=r,r.__name__=\"CanvasTexture\",r.init_CanvasTexture()},\n", + " function _(e,t,i,n,r){n();const s=e(53),u=e(20);class o extends s.Model{constructor(e){super(e)}static init_Texture(){this.define((()=>({repetition:[u.TextureRepetition,\"repeat\"]})))}}i.Texture=o,o.__name__=\"Texture\",o.init_Texture()},\n", + " function _(e,t,i,r,n){r();const a=e(358),s=e(296);class u extends a.Texture{constructor(e){super(e)}static init_ImageURLTexture(){this.define((({String:e})=>({url:[e]})))}initialize(){super.initialize(),this._loader=new s.ImageLoader(this.url)}get_pattern(e,t,i){const{_loader:r}=this;return this._loader.finished?r.image:r.promise}}i.ImageURLTexture=u,u.__name__=\"ImageURLTexture\",u.init_ImageURLTexture()},\n", + " function _(o,l,T,e,t){e(),t(\"ActionTool\",o(251).ActionTool),t(\"CustomAction\",o(361).CustomAction),t(\"HelpTool\",o(252).HelpTool),t(\"RedoTool\",o(362).RedoTool),t(\"ResetTool\",o(363).ResetTool),t(\"SaveTool\",o(364).SaveTool),t(\"UndoTool\",o(365).UndoTool),t(\"ZoomInTool\",o(366).ZoomInTool),t(\"ZoomOutTool\",o(369).ZoomOutTool),t(\"ButtonTool\",o(238).ButtonTool),t(\"EditTool\",o(370).EditTool),t(\"BoxEditTool\",o(371).BoxEditTool),t(\"FreehandDrawTool\",o(372).FreehandDrawTool),t(\"PointDrawTool\",o(373).PointDrawTool),t(\"PolyDrawTool\",o(374).PolyDrawTool),t(\"PolyTool\",o(375).PolyTool),t(\"PolyEditTool\",o(376).PolyEditTool),t(\"BoxSelectTool\",o(377).BoxSelectTool),t(\"BoxZoomTool\",o(379).BoxZoomTool),t(\"GestureTool\",o(237).GestureTool),t(\"LassoSelectTool\",o(380).LassoSelectTool),t(\"LineEditTool\",o(382).LineEditTool),t(\"PanTool\",o(384).PanTool),t(\"PolySelectTool\",o(381).PolySelectTool),t(\"RangeTool\",o(385).RangeTool),t(\"SelectTool\",o(378).SelectTool),t(\"TapTool\",o(386).TapTool),t(\"WheelPanTool\",o(387).WheelPanTool),t(\"WheelZoomTool\",o(388).WheelZoomTool),t(\"CrosshairTool\",o(389).CrosshairTool),t(\"CustomJSHover\",o(390).CustomJSHover),t(\"HoverTool\",o(391).HoverTool),t(\"InspectTool\",o(247).InspectTool),t(\"Tool\",o(236).Tool),t(\"ToolProxy\",o(392).ToolProxy),t(\"Toolbar\",o(235).Toolbar),t(\"ToolbarBase\",o(248).ToolbarBase),t(\"ProxyToolbar\",o(393).ProxyToolbar),t(\"ToolbarBox\",o(393).ToolbarBox)},\n", + " function _(t,o,i,s,n){s();const e=t(251);class c extends e.ActionToolButtonView{css_classes(){return super.css_classes().concat(\"bk-toolbar-button-custom-action\")}}i.CustomActionButtonView=c,c.__name__=\"CustomActionButtonView\";class u extends e.ActionToolView{doit(){var t;null===(t=this.model.callback)||void 0===t||t.execute(this.model)}}i.CustomActionView=u,u.__name__=\"CustomActionView\";class l extends e.ActionTool{constructor(t){super(t),this.tool_name=\"Custom Action\",this.button_view=c}static init_CustomAction(){this.prototype.default_view=u,this.define((({Any:t,String:o,Nullable:i})=>({callback:[i(t)],icon:[o]}))),this.override({description:\"Perform a Custom Action\"})}}i.CustomAction=l,l.__name__=\"CustomAction\",l.init_CustomAction()},\n", + " function _(o,e,t,i,s){i();const n=o(251),d=o(242);class l extends n.ActionToolView{connect_signals(){super.connect_signals(),this.connect(this.plot_view.state.changed,(()=>this.model.disabled=!this.plot_view.state.can_redo))}doit(){this.plot_view.state.redo()}}t.RedoToolView=l,l.__name__=\"RedoToolView\";class _ extends n.ActionTool{constructor(o){super(o),this.tool_name=\"Redo\",this.icon=d.tool_icon_redo}static init_RedoTool(){this.prototype.default_view=l,this.override({disabled:!0}),this.register_alias(\"redo\",(()=>new _))}}t.RedoTool=_,_.__name__=\"RedoTool\",_.init_RedoTool()},\n", + " function _(e,t,o,s,i){s();const _=e(251),n=e(242);class l extends _.ActionToolView{doit(){this.plot_view.reset()}}o.ResetToolView=l,l.__name__=\"ResetToolView\";class c extends _.ActionTool{constructor(e){super(e),this.tool_name=\"Reset\",this.icon=n.tool_icon_reset}static init_ResetTool(){this.prototype.default_view=l,this.register_alias(\"reset\",(()=>new c))}}o.ResetTool=c,c.__name__=\"ResetTool\",c.init_ResetTool()},\n", + " function _(o,e,t,a,i){a();const n=o(251),s=o(242);class c extends n.ActionToolView{async copy(){const o=await this.plot_view.to_blob(),e=new ClipboardItem({[o.type]:o});await navigator.clipboard.write([e])}async save(o){const e=await this.plot_view.to_blob(),t=document.createElement(\"a\");t.href=URL.createObjectURL(e),t.download=o,t.target=\"_blank\",t.dispatchEvent(new MouseEvent(\"click\"))}doit(o=\"save\"){switch(o){case\"save\":this.save(\"bokeh_plot\");break;case\"copy\":this.copy()}}}t.SaveToolView=c,c.__name__=\"SaveToolView\";class l extends n.ActionTool{constructor(o){super(o),this.tool_name=\"Save\",this.icon=s.tool_icon_save}static init_SaveTool(){this.prototype.default_view=c,this.register_alias(\"save\",(()=>new l))}get menu(){return[{icon:\"bk-tool-icon-copy-to-clipboard\",tooltip:\"Copy image to clipboard\",if:()=>\"undefined\"!=typeof ClipboardItem,handler:()=>{this.do.emit(\"copy\")}}]}}t.SaveTool=l,l.__name__=\"SaveTool\",l.init_SaveTool()},\n", + " function _(o,t,n,i,e){i();const s=o(251),d=o(242);class l extends s.ActionToolView{connect_signals(){super.connect_signals(),this.connect(this.plot_view.state.changed,(()=>this.model.disabled=!this.plot_view.state.can_undo))}doit(){this.plot_view.state.undo()}}n.UndoToolView=l,l.__name__=\"UndoToolView\";class _ extends s.ActionTool{constructor(o){super(o),this.tool_name=\"Undo\",this.icon=d.tool_icon_undo}static init_UndoTool(){this.prototype.default_view=l,this.override({disabled:!0}),this.register_alias(\"undo\",(()=>new _))}}n.UndoTool=_,_.__name__=\"UndoTool\",_.init_UndoTool()},\n", + " function _(o,i,n,s,e){s();const t=o(367),_=o(242);class m extends t.ZoomBaseToolView{}n.ZoomInToolView=m,m.__name__=\"ZoomInToolView\";class l extends t.ZoomBaseTool{constructor(o){super(o),this.sign=1,this.tool_name=\"Zoom In\",this.icon=_.tool_icon_zoom_in}static init_ZoomInTool(){this.prototype.default_view=m,this.register_alias(\"zoom_in\",(()=>new l({dimensions:\"both\"}))),this.register_alias(\"xzoom_in\",(()=>new l({dimensions:\"width\"}))),this.register_alias(\"yzoom_in\",(()=>new l({dimensions:\"height\"})))}}n.ZoomInTool=l,l.__name__=\"ZoomInTool\",l.init_ZoomInTool()},\n", + " function _(o,t,e,i,s){i();const n=o(251),l=o(20),a=o(368);class _ extends n.ActionToolView{doit(){var o;const t=this.plot_view.frame,e=this.model.dimensions,i=\"width\"==e||\"both\"==e,s=\"height\"==e||\"both\"==e,n=a.scale_range(t,this.model.sign*this.model.factor,i,s);this.plot_view.state.push(\"zoom_out\",{range:n}),this.plot_view.update_range(n,{scrolling:!0}),null===(o=this.model.document)||void 0===o||o.interactive_start(this.plot_model)}}e.ZoomBaseToolView=_,_.__name__=\"ZoomBaseToolView\";class m extends n.ActionTool{constructor(o){super(o)}static init_ZoomBaseTool(){this.define((({Percent:o})=>({factor:[o,.1],dimensions:[l.Dimensions,\"both\"]})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}e.ZoomBaseTool=m,m.__name__=\"ZoomBaseTool\",m.init_ZoomBaseTool()},\n", + " function _(n,t,o,r,s){r();const c=n(10);function e(n,t,o){const[r,s]=[n.start,n.end],c=null!=o?o:(s+r)/2;return[r-(r-c)*t,s-(s-c)*t]}function a(n,[t,o]){const r=new Map;for(const[s,c]of n){const[n,e]=c.r_invert(t,o);r.set(s,{start:n,end:e})}return r}o.scale_highlow=e,o.get_info=a,o.scale_range=function(n,t,o=!0,r=!0,s){t=c.clamp(t,-.9,.9);const l=o?t:0,[u,i]=e(n.bbox.h_range,l,null!=s?s.x:void 0),_=a(n.x_scales,[u,i]),f=r?t:0,[g,x]=e(n.bbox.v_range,f,null!=s?s.y:void 0);return{xrs:_,yrs:a(n.y_scales,[g,x]),factor:t}}},\n", + " function _(o,t,i,s,e){s();const n=o(367),_=o(242);class m extends n.ZoomBaseToolView{}i.ZoomOutToolView=m,m.__name__=\"ZoomOutToolView\";class l extends n.ZoomBaseTool{constructor(o){super(o),this.sign=-1,this.tool_name=\"Zoom Out\",this.icon=_.tool_icon_zoom_out}static init_ZoomOutTool(){this.prototype.default_view=m,this.register_alias(\"zoom_out\",(()=>new l({dimensions:\"both\"}))),this.register_alias(\"xzoom_out\",(()=>new l({dimensions:\"width\"}))),this.register_alias(\"yzoom_out\",(()=>new l({dimensions:\"height\"})))}}i.ZoomOutTool=l,l.__name__=\"ZoomOutTool\",l.init_ZoomOutTool()},\n", + " function _(e,t,s,o,n){o();const i=e(9),r=e(8),c=e(11),a=e(61),_=e(237);class l extends _.GestureToolView{constructor(){super(...arguments),this._mouse_in_frame=!0}_select_mode(e){const{shiftKey:t,ctrlKey:s}=e;return t||s?t&&!s?\"append\":!t&&s?\"intersect\":t&&s?\"subtract\":void c.unreachable():\"replace\"}_move_enter(e){this._mouse_in_frame=!0}_move_exit(e){this._mouse_in_frame=!1}_map_drag(e,t,s){if(!this.plot_view.frame.bbox.contains(e,t))return null;const o=this.plot_view.renderer_view(s);if(null==o)return null;return[o.coordinates.x_scale.invert(e),o.coordinates.y_scale.invert(t)]}_delete_selected(e){const t=e.data_source,s=t.selected.indices;s.sort();for(const e of t.columns()){const o=t.get_array(e);for(let e=0;e({custom_icon:[n(t),null],empty_value:[e],renderers:[s(o(a.GlyphRenderer)),[]]})))}get computed_icon(){var e;return null!==(e=this.custom_icon)&&void 0!==e?e:this.icon}}s.EditTool=d,d.__name__=\"EditTool\",d.init_EditTool()},\n", + " function _(e,t,s,i,_){i();const o=e(43),n=e(20),a=e(370),d=e(242);class l extends a.EditToolView{_tap(e){null==this._draw_basepoint&&null==this._basepoint&&this._select_event(e,this._select_mode(e),this.model.renderers)}_keyup(e){if(this.model.active&&this._mouse_in_frame)for(const t of this.model.renderers)if(e.keyCode===o.Keys.Backspace)this._delete_selected(t);else if(e.keyCode==o.Keys.Esc){t.data_source.selection_manager.clear()}}_set_extent([e,t],[s,i],_,o=!1){const n=this.model.renderers[0],a=this.plot_view.renderer_view(n);if(null==a)return;const d=n.glyph,l=n.data_source,[r,h]=a.coordinates.x_scale.r_invert(e,t),[p,u]=a.coordinates.y_scale.r_invert(s,i),[c,m]=[(r+h)/2,(p+u)/2],[f,b]=[h-r,u-p],[x,y]=[d.x.field,d.y.field],[w,v]=[d.width.field,d.height.field];if(_)this._pop_glyphs(l,this.model.num_objects),x&&l.get_array(x).push(c),y&&l.get_array(y).push(m),w&&l.get_array(w).push(f),v&&l.get_array(v).push(b),this._pad_empty_columns(l,[x,y,w,v]);else{const e=l.data[x].length-1;x&&(l.data[x][e]=c),y&&(l.data[y][e]=m),w&&(l.data[w][e]=f),v&&(l.data[v][e]=b)}this._emit_cds_changes(l,!0,!1,o)}_update_box(e,t=!1,s=!1){if(null==this._draw_basepoint)return;const i=[e.sx,e.sy],_=this.plot_view.frame,o=this.model.dimensions,n=this.model._get_dim_limits(this._draw_basepoint,i,_,o);if(null!=n){const[e,i]=n;this._set_extent(e,i,t,s)}}_doubletap(e){this.model.active&&(null!=this._draw_basepoint?(this._update_box(e,!1,!0),this._draw_basepoint=null):(this._draw_basepoint=[e.sx,e.sy],this._select_event(e,\"append\",this.model.renderers),this._update_box(e,!0,!1)))}_move(e){this._update_box(e,!1,!1)}_pan_start(e){if(e.shiftKey){if(null!=this._draw_basepoint)return;this._draw_basepoint=[e.sx,e.sy],this._update_box(e,!0,!1)}else{if(null!=this._basepoint)return;this._select_event(e,\"append\",this.model.renderers),this._basepoint=[e.sx,e.sy]}}_pan(e,t=!1,s=!1){if(e.shiftKey){if(null==this._draw_basepoint)return;this._update_box(e,t,s)}else{if(null==this._basepoint)return;this._drag_points(e,this.model.renderers)}}_pan_end(e){if(this._pan(e,!1,!0),e.shiftKey)this._draw_basepoint=null;else{this._basepoint=null;for(const e of this.model.renderers)this._emit_cds_changes(e.data_source,!1,!0,!0)}}}s.BoxEditToolView=l,l.__name__=\"BoxEditToolView\";class r extends a.EditTool{constructor(e){super(e),this.tool_name=\"Box Edit Tool\",this.icon=d.tool_icon_box_edit,this.event_type=[\"tap\",\"pan\",\"move\"],this.default_order=1}static init_BoxEditTool(){this.prototype.default_view=l,this.define((({Int:e})=>({dimensions:[n.Dimensions,\"both\"],num_objects:[e,0]})))}}s.BoxEditTool=r,r.__name__=\"BoxEditTool\",r.init_BoxEditTool()},\n", + " function _(e,t,a,s,r){s();const _=e(43),i=e(8),o=e(370),d=e(242);class n extends o.EditToolView{_draw(e,t,a=!1){if(!this.model.active)return;const s=this.model.renderers[0],r=this._map_drag(e.sx,e.sy,s);if(null==r)return;const[_,o]=r,d=s.data_source,n=s.glyph,[h,l]=[n.xs.field,n.ys.field];if(\"new\"==t)this._pop_glyphs(d,this.model.num_objects),h&&d.get_array(h).push([_]),l&&d.get_array(l).push([o]),this._pad_empty_columns(d,[h,l]);else if(\"add\"==t){if(h){const e=d.data[h].length-1;let t=d.get_array(h)[e];i.isArray(t)||(t=Array.from(t),d.data[h][e]=t),t.push(_)}if(l){const e=d.data[l].length-1;let t=d.get_array(l)[e];i.isArray(t)||(t=Array.from(t),d.data[l][e]=t),t.push(o)}}this._emit_cds_changes(d,!0,!0,a)}_pan_start(e){this._draw(e,\"new\")}_pan(e){this._draw(e,\"add\")}_pan_end(e){this._draw(e,\"add\",!0)}_tap(e){this._select_event(e,this._select_mode(e),this.model.renderers)}_keyup(e){if(this.model.active&&this._mouse_in_frame)for(const t of this.model.renderers)e.keyCode===_.Keys.Esc?t.data_source.selection_manager.clear():e.keyCode===_.Keys.Backspace&&this._delete_selected(t)}}a.FreehandDrawToolView=n,n.__name__=\"FreehandDrawToolView\";class h extends o.EditTool{constructor(e){super(e),this.tool_name=\"Freehand Draw Tool\",this.icon=d.tool_icon_freehand_draw,this.event_type=[\"pan\",\"tap\"],this.default_order=3}static init_FreehandDrawTool(){this.prototype.default_view=n,this.define((({Int:e})=>({num_objects:[e,0]}))),this.register_alias(\"freehand_draw\",(()=>new h))}}a.FreehandDrawTool=h,h.__name__=\"FreehandDrawTool\",h.init_FreehandDrawTool()},\n", + " function _(e,t,s,o,i){o();const a=e(43),n=e(370),_=e(242);class r extends n.EditToolView{_tap(e){if(this._select_event(e,this._select_mode(e),this.model.renderers).length||!this.model.add)return;const t=this.model.renderers[0],s=this._map_drag(e.sx,e.sy,t);if(null==s)return;const o=t.glyph,i=t.data_source,[a,n]=[o.x.field,o.y.field],[_,r]=s;this._pop_glyphs(i,this.model.num_objects),a&&i.get_array(a).push(_),n&&i.get_array(n).push(r),this._pad_empty_columns(i,[a,n]),i.change.emit(),i.data=i.data,i.properties.data.change.emit()}_keyup(e){if(this.model.active&&this._mouse_in_frame)for(const t of this.model.renderers)e.keyCode===a.Keys.Backspace?this._delete_selected(t):e.keyCode==a.Keys.Esc&&t.data_source.selection_manager.clear()}_pan_start(e){this.model.drag&&(this._select_event(e,\"append\",this.model.renderers),this._basepoint=[e.sx,e.sy])}_pan(e){this.model.drag&&null!=this._basepoint&&this._drag_points(e,this.model.renderers)}_pan_end(e){if(this.model.drag){this._pan(e);for(const e of this.model.renderers)this._emit_cds_changes(e.data_source,!1,!0,!0);this._basepoint=null}}}s.PointDrawToolView=r,r.__name__=\"PointDrawToolView\";class d extends n.EditTool{constructor(e){super(e),this.tool_name=\"Point Draw Tool\",this.icon=_.tool_icon_point_draw,this.event_type=[\"tap\",\"pan\",\"move\"],this.default_order=2}static init_PointDrawTool(){this.prototype.default_view=r,this.define((({Boolean:e,Int:t})=>({add:[e,!0],drag:[e,!0],num_objects:[t,0]})))}}s.PointDrawTool=d,d.__name__=\"PointDrawTool\",d.init_PointDrawTool()},\n", + " function _(e,t,s,i,a){i();const o=e(43),r=e(8),n=e(375),_=e(242);class d extends n.PolyToolView{constructor(){super(...arguments),this._drawing=!1,this._initialized=!1}_tap(e){this._drawing?this._draw(e,\"add\",!0):this._select_event(e,this._select_mode(e),this.model.renderers)}_draw(e,t,s=!1){const i=this.model.renderers[0],a=this._map_drag(e.sx,e.sy,i);if(this._initialized||this.activate(),null==a)return;const[o,n]=this._snap_to_vertex(e,...a),_=i.data_source,d=i.glyph,[l,h]=[d.xs.field,d.ys.field];if(\"new\"==t)this._pop_glyphs(_,this.model.num_objects),l&&_.get_array(l).push([o,o]),h&&_.get_array(h).push([n,n]),this._pad_empty_columns(_,[l,h]);else if(\"edit\"==t){if(l){const e=_.data[l][_.data[l].length-1];e[e.length-1]=o}if(h){const e=_.data[h][_.data[h].length-1];e[e.length-1]=n}}else if(\"add\"==t){if(l){const e=_.data[l].length-1;let t=_.get_array(l)[e];const s=t[t.length-1];t[t.length-1]=o,r.isArray(t)||(t=Array.from(t),_.data[l][e]=t),t.push(s)}if(h){const e=_.data[h].length-1;let t=_.get_array(h)[e];const s=t[t.length-1];t[t.length-1]=n,r.isArray(t)||(t=Array.from(t),_.data[h][e]=t),t.push(s)}}this._emit_cds_changes(_,!0,!1,s)}_show_vertices(){if(!this.model.active)return;const e=[],t=[];for(let s=0;sthis._show_vertices()))}this._initialized=!0}}deactivate(){this._drawing&&(this._remove(),this._drawing=!1),this.model.vertex_renderer&&this._hide_vertices()}}s.PolyDrawToolView=d,d.__name__=\"PolyDrawToolView\";class l extends n.PolyTool{constructor(e){super(e),this.tool_name=\"Polygon Draw Tool\",this.icon=_.tool_icon_poly_draw,this.event_type=[\"pan\",\"tap\",\"move\"],this.default_order=3}static init_PolyDrawTool(){this.prototype.default_view=d,this.define((({Boolean:e,Int:t})=>({drag:[e,!0],num_objects:[t,0]})))}}s.PolyDrawTool=l,l.__name__=\"PolyDrawTool\",l.init_PolyDrawTool()},\n", + " function _(e,t,r,o,s){o();const i=e(8),l=e(370);class _ extends l.EditToolView{_set_vertices(e,t){const r=this.model.vertex_renderer.glyph,o=this.model.vertex_renderer.data_source,[s,l]=[r.x.field,r.y.field];s&&(i.isArray(e)?o.data[s]=e:r.x={value:e}),l&&(i.isArray(t)?o.data[l]=t:r.y={value:t}),this._emit_cds_changes(o,!0,!0,!1)}_hide_vertices(){this._set_vertices([],[])}_snap_to_vertex(e,t,r){if(this.model.vertex_renderer){const o=this._select_event(e,\"replace\",[this.model.vertex_renderer]),s=this.model.vertex_renderer.data_source,i=this.model.vertex_renderer.glyph,[l,_]=[i.x.field,i.y.field];if(o.length){const e=s.selected.indices[0];l&&(t=s.data[l][e]),_&&(r=s.data[_][e]),s.selection_manager.clear()}}return[t,r]}}r.PolyToolView=_,_.__name__=\"PolyToolView\";class d extends l.EditTool{constructor(e){super(e)}static init_PolyTool(){this.define((({AnyRef:e})=>({vertex_renderer:[e()]})))}}r.PolyTool=d,d.__name__=\"PolyTool\",d.init_PolyTool()},\n", + " function _(e,t,s,r,i){r();const _=e(43),d=e(8),n=e(375),l=e(242);class a extends n.PolyToolView{constructor(){super(...arguments),this._drawing=!1,this._cur_index=null}_doubletap(e){if(!this.model.active)return;const t=this._map_drag(e.sx,e.sy,this.model.vertex_renderer);if(null==t)return;const[s,r]=t,i=this._select_event(e,\"replace\",[this.model.vertex_renderer]),_=this.model.vertex_renderer.data_source,d=this.model.vertex_renderer.glyph,[n,l]=[d.x.field,d.y.field];if(i.length&&null!=this._selected_renderer){const e=_.selected.indices[0];this._drawing?(this._drawing=!1,_.selection_manager.clear()):(_.selected.indices=[e+1],n&&_.get_array(n).splice(e+1,0,s),l&&_.get_array(l).splice(e+1,0,r),this._drawing=!0),_.change.emit(),this._emit_cds_changes(this._selected_renderer.data_source)}else this._show_vertices(e)}_show_vertices(e){if(!this.model.active)return;const t=this.model.renderers[0],s=()=>this._update_vertices(t),r=null==t?void 0:t.data_source,i=this._select_event(e,\"replace\",this.model.renderers);if(!i.length)return this._set_vertices([],[]),this._selected_renderer=null,this._drawing=!1,this._cur_index=null,void(null!=r&&r.disconnect(r.properties.data.change,s));null!=r&&r.connect(r.properties.data.change,s),this._cur_index=i[0].data_source.selected.indices[0],this._update_vertices(i[0])}_update_vertices(e){const t=e.glyph,s=e.data_source,r=this._cur_index,[i,_]=[t.xs.field,t.ys.field];if(this._drawing)return;if(null==r&&(i||_))return;let n,l;i&&null!=r?(n=s.data[i][r],d.isArray(n)||(s.data[i][r]=n=Array.from(n))):n=t.xs.value,_&&null!=r?(l=s.data[_][r],d.isArray(l)||(s.data[_][r]=l=Array.from(l))):l=t.ys.value,this._selected_renderer=e,this._set_vertices(n,l)}_move(e){if(this._drawing&&null!=this._selected_renderer){const t=this.model.vertex_renderer,s=t.data_source,r=t.glyph,i=this._map_drag(e.sx,e.sy,t);if(null==i)return;let[_,d]=i;const n=s.selected.indices;[_,d]=this._snap_to_vertex(e,_,d),s.selected.indices=n;const[l,a]=[r.x.field,r.y.field],c=n[0];l&&(s.data[l][c]=_),a&&(s.data[a][c]=d),s.change.emit(),this._selected_renderer.data_source.change.emit()}}_tap(e){const t=this.model.vertex_renderer,s=this._map_drag(e.sx,e.sy,t);if(null==s)return;if(this._drawing&&this._selected_renderer){let[r,i]=s;const _=t.data_source,d=t.glyph,[n,l]=[d.x.field,d.y.field],a=_.selected.indices;[r,i]=this._snap_to_vertex(e,r,i);const c=a[0];if(_.selected.indices=[c+1],n){const e=_.get_array(n),t=e[c];e[c]=r,e.splice(c+1,0,t)}if(l){const e=_.get_array(l),t=e[c];e[c]=i,e.splice(c+1,0,t)}return _.change.emit(),void this._emit_cds_changes(this._selected_renderer.data_source,!0,!1,!0)}const r=this._select_mode(e);this._select_event(e,r,[t]),this._select_event(e,r,this.model.renderers)}_remove_vertex(){if(!this._drawing||!this._selected_renderer)return;const e=this.model.vertex_renderer,t=e.data_source,s=e.glyph,r=t.selected.indices[0],[i,_]=[s.x.field,s.y.field];i&&t.get_array(i).splice(r,1),_&&t.get_array(_).splice(r,1),t.change.emit(),this._emit_cds_changes(this._selected_renderer.data_source)}_pan_start(e){this._select_event(e,\"append\",[this.model.vertex_renderer]),this._basepoint=[e.sx,e.sy]}_pan(e){null!=this._basepoint&&(this._drag_points(e,[this.model.vertex_renderer]),this._selected_renderer&&this._selected_renderer.data_source.change.emit())}_pan_end(e){null!=this._basepoint&&(this._drag_points(e,[this.model.vertex_renderer]),this._emit_cds_changes(this.model.vertex_renderer.data_source,!1,!0,!0),this._selected_renderer&&this._emit_cds_changes(this._selected_renderer.data_source),this._basepoint=null)}_keyup(e){if(!this.model.active||!this._mouse_in_frame)return;let t;t=this._selected_renderer?[this.model.vertex_renderer]:this.model.renderers;for(const s of t)e.keyCode===_.Keys.Backspace?(this._delete_selected(s),this._selected_renderer&&this._emit_cds_changes(this._selected_renderer.data_source)):e.keyCode==_.Keys.Esc&&(this._drawing?(this._remove_vertex(),this._drawing=!1):this._selected_renderer&&this._hide_vertices(),s.data_source.selection_manager.clear())}deactivate(){this._selected_renderer&&(this._drawing&&(this._remove_vertex(),this._drawing=!1),this._hide_vertices())}}s.PolyEditToolView=a,a.__name__=\"PolyEditToolView\";class c extends n.PolyTool{constructor(e){super(e),this.tool_name=\"Poly Edit Tool\",this.icon=l.tool_icon_poly_edit,this.event_type=[\"tap\",\"pan\",\"move\"],this.default_order=4}static init_PolyEditTool(){this.prototype.default_view=a}}s.PolyEditTool=c,c.__name__=\"PolyEditTool\",c.init_PolyEditTool()},\n", + " function _(e,t,o,s,i){s();const l=e(378),n=e(136),_=e(20),c=e(242);class h extends l.SelectToolView{_compute_limits(e){const t=this.plot_view.frame,o=this.model.dimensions;let s=this._base_point;if(\"center\"==this.model.origin){const[t,o]=s,[i,l]=e;s=[t-(i-t),o-(l-o)]}return this.model._get_dim_limits(s,e,t,o)}_pan_start(e){const{sx:t,sy:o}=e;this._base_point=[t,o]}_pan(e){const{sx:t,sy:o}=e,s=[t,o],[i,l]=this._compute_limits(s);this.model.overlay.update({left:i[0],right:i[1],top:l[0],bottom:l[1]}),this.model.select_every_mousemove&&this._do_select(i,l,!1,this._select_mode(e))}_pan_end(e){const{sx:t,sy:o}=e,s=[t,o],[i,l]=this._compute_limits(s);this._do_select(i,l,!0,this._select_mode(e)),this.model.overlay.update({left:null,right:null,top:null,bottom:null}),this._base_point=null,this.plot_view.state.push(\"box_select\",{selection:this.plot_view.get_selection()})}_do_select([e,t],[o,s],i,l=\"replace\"){const n={type:\"rect\",sx0:e,sx1:t,sy0:o,sy1:s};this._select(n,i,l)}}o.BoxSelectToolView=h,h.__name__=\"BoxSelectToolView\";const r=()=>new n.BoxAnnotation({level:\"overlay\",top_units:\"screen\",left_units:\"screen\",bottom_units:\"screen\",right_units:\"screen\",fill_color:\"lightgrey\",fill_alpha:.5,line_color:\"black\",line_alpha:1,line_width:2,line_dash:[4,4]});class a extends l.SelectTool{constructor(e){super(e),this.tool_name=\"Box Select\",this.icon=c.tool_icon_box_select,this.event_type=\"pan\",this.default_order=30}static init_BoxSelectTool(){this.prototype.default_view=h,this.define((({Boolean:e,Ref:t})=>({dimensions:[_.Dimensions,\"both\"],select_every_mousemove:[e,!1],overlay:[t(n.BoxAnnotation),r],origin:[_.BoxOrigin,\"corner\"]}))),this.register_alias(\"box_select\",(()=>new a)),this.register_alias(\"xbox_select\",(()=>new a({dimensions:\"width\"}))),this.register_alias(\"ybox_select\",(()=>new a({dimensions:\"height\"})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}o.BoxSelectTool=a,a.__name__=\"BoxSelectTool\",a.init_BoxSelectTool()},\n", + " function _(e,t,s,n,o){n();const r=e(237),c=e(61),i=e(123),l=e(62),a=e(161),_=e(20),d=e(43),h=e(264),p=e(15),u=e(11);class m extends r.GestureToolView{connect_signals(){super.connect_signals(),this.model.clear.connect((()=>this._clear()))}get computed_renderers(){const{renderers:e,names:t}=this.model,s=this.plot_model.data_renderers;return a.compute_renderers(e,s,t)}_computed_renderers_by_data_source(){var e;const t=new Map;for(const s of this.computed_renderers){let n;if(s instanceof c.GlyphRenderer)n=s.data_source;else{if(!(s instanceof i.GraphRenderer))continue;n=s.node_renderer.data_source}const o=null!==(e=t.get(n))&&void 0!==e?e:[];t.set(n,[...o,s])}return t}_select_mode(e){const{shiftKey:t,ctrlKey:s}=e;return t||s?t&&!s?\"append\":!t&&s?\"intersect\":t&&s?\"subtract\":void u.unreachable():this.model.mode}_keyup(e){e.keyCode==d.Keys.Esc&&this._clear()}_clear(){for(const e of this.computed_renderers)e.get_selection_manager().clear();const e=this.computed_renderers.map((e=>this.plot_view.renderer_view(e)));this.plot_view.request_paint(e)}_select(e,t,s){const n=this._computed_renderers_by_data_source();for(const[,o]of n){const n=o[0].get_selection_manager(),r=[];for(const e of o){const t=this.plot_view.renderer_view(e);null!=t&&r.push(t)}n.select(r,e,t,s)}null!=this.model.callback&&this._emit_callback(e),this._emit_selection_event(e,t)}_emit_selection_event(e,t=!0){const{x_scale:s,y_scale:n}=this.plot_view.frame;let o;switch(e.type){case\"point\":{const{sx:t,sy:r}=e,c=s.invert(t),i=n.invert(r);o=Object.assign(Object.assign({},e),{x:c,y:i});break}case\"span\":{const{sx:t,sy:r}=e,c=s.invert(t),i=n.invert(r);o=Object.assign(Object.assign({},e),{x:c,y:i});break}case\"rect\":{const{sx0:t,sx1:r,sy0:c,sy1:i}=e,[l,a]=s.r_invert(t,r),[_,d]=n.r_invert(c,i);o=Object.assign(Object.assign({},e),{x0:l,y0:_,x1:a,y1:d});break}case\"poly\":{const{sx:t,sy:r}=e,c=s.v_invert(t),i=n.v_invert(r);o=Object.assign(Object.assign({},e),{x:c,y:i});break}}this.plot_model.trigger_event(new h.SelectionGeometry(o,t))}}s.SelectToolView=m,m.__name__=\"SelectToolView\";class v extends r.GestureTool{constructor(e){super(e)}initialize(){super.initialize(),this.clear=new p.Signal0(this,\"clear\")}static init_SelectTool(){this.define((({String:e,Array:t,Ref:s,Or:n,Auto:o})=>({renderers:[n(t(s(l.DataRenderer)),o),\"auto\"],names:[t(e),[]],mode:[_.SelectionMode,\"replace\"]})))}get menu(){return[{icon:\"bk-tool-icon-replace-mode\",tooltip:\"Replace the current selection\",active:()=>\"replace\"==this.mode,handler:()=>{this.mode=\"replace\",this.active=!0}},{icon:\"bk-tool-icon-append-mode\",tooltip:\"Append to the current selection (Shift)\",active:()=>\"append\"==this.mode,handler:()=>{this.mode=\"append\",this.active=!0}},{icon:\"bk-tool-icon-intersect-mode\",tooltip:\"Intersect with the current selection (Ctrl)\",active:()=>\"intersect\"==this.mode,handler:()=>{this.mode=\"intersect\",this.active=!0}},{icon:\"bk-tool-icon-subtract-mode\",tooltip:\"Subtract from the current selection (Shift+Ctrl)\",active:()=>\"subtract\"==this.mode,handler:()=>{this.mode=\"subtract\",this.active=!0}},null,{icon:\"bk-tool-icon-clear-selection\",tooltip:\"Clear the current selection (Esc)\",handler:()=>{this.clear.emit()}}]}}s.SelectTool=v,v.__name__=\"SelectTool\",v.init_SelectTool()},\n", + " function _(t,o,e,s,i){s();const n=t(237),_=t(136),a=t(20),l=t(242);class r extends n.GestureToolView{_match_aspect(t,o,e){const s=e.bbox.aspect,i=e.bbox.h_range.end,n=e.bbox.h_range.start,_=e.bbox.v_range.end,a=e.bbox.v_range.start;let l=Math.abs(t[0]-o[0]),r=Math.abs(t[1]-o[1]);const h=0==r?0:l/r,[c]=h>=s?[1,h/s]:[s/h,1];let m,p,d,b;return t[0]<=o[0]?(m=t[0],p=t[0]+l*c,p>i&&(p=i)):(p=t[0],m=t[0]-l*c,m_&&(d=_)):(d=t[1],b=t[1]-l/s,bnew _.BoxAnnotation({level:\"overlay\",top_units:\"screen\",left_units:\"screen\",bottom_units:\"screen\",right_units:\"screen\",fill_color:\"lightgrey\",fill_alpha:.5,line_color:\"black\",line_alpha:1,line_width:2,line_dash:[4,4]});class c extends n.GestureTool{constructor(t){super(t),this.tool_name=\"Box Zoom\",this.icon=l.tool_icon_box_zoom,this.event_type=\"pan\",this.default_order=20}static init_BoxZoomTool(){this.prototype.default_view=r,this.define((({Boolean:t,Ref:o})=>({dimensions:[a.Dimensions,\"both\"],overlay:[o(_.BoxAnnotation),h],match_aspect:[t,!1],origin:[a.BoxOrigin,\"corner\"]}))),this.register_alias(\"box_zoom\",(()=>new c({dimensions:\"both\"}))),this.register_alias(\"xbox_zoom\",(()=>new c({dimensions:\"width\"}))),this.register_alias(\"ybox_zoom\",(()=>new c({dimensions:\"height\"})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}e.BoxZoomTool=c,c.__name__=\"BoxZoomTool\",c.init_BoxZoomTool()},\n", + " function _(s,e,t,o,i){o();const l=s(378),_=s(231),a=s(381),c=s(43),n=s(242);class h extends l.SelectToolView{constructor(){super(...arguments),this.sxs=[],this.sys=[]}connect_signals(){super.connect_signals(),this.connect(this.model.properties.active.change,(()=>this._active_change()))}_active_change(){this.model.active||this._clear_overlay()}_keyup(s){s.keyCode==c.Keys.Enter&&this._clear_overlay()}_pan_start(s){this.sxs=[],this.sys=[];const{sx:e,sy:t}=s;this._append_overlay(e,t)}_pan(s){const[e,t]=this.plot_view.frame.bbox.clip(s.sx,s.sy);this._append_overlay(e,t),this.model.select_every_mousemove&&this._do_select(this.sxs,this.sys,!1,this._select_mode(s))}_pan_end(s){const{sxs:e,sys:t}=this;this._clear_overlay(),this._do_select(e,t,!0,this._select_mode(s)),this.plot_view.state.push(\"lasso_select\",{selection:this.plot_view.get_selection()})}_append_overlay(s,e){const{sxs:t,sys:o}=this;t.push(s),o.push(e),this.model.overlay.update({xs:t,ys:o})}_clear_overlay(){this.sxs=[],this.sys=[],this.model.overlay.update({xs:this.sxs,ys:this.sys})}_do_select(s,e,t,o){const i={type:\"poly\",sx:s,sy:e};this._select(i,t,o)}}t.LassoSelectToolView=h,h.__name__=\"LassoSelectToolView\";class r extends l.SelectTool{constructor(s){super(s),this.tool_name=\"Lasso Select\",this.icon=n.tool_icon_lasso_select,this.event_type=\"pan\",this.default_order=12}static init_LassoSelectTool(){this.prototype.default_view=h,this.define((({Boolean:s,Ref:e})=>({select_every_mousemove:[s,!0],overlay:[e(_.PolyAnnotation),a.DEFAULT_POLY_OVERLAY]}))),this.register_alias(\"lasso_select\",(()=>new r))}}t.LassoSelectTool=r,r.__name__=\"LassoSelectTool\",r.init_LassoSelectTool()},\n", + " function _(e,t,s,l,o){l();const i=e(378),a=e(231),_=e(43),c=e(9),n=e(242);class h extends i.SelectToolView{initialize(){super.initialize(),this.data={sx:[],sy:[]}}connect_signals(){super.connect_signals(),this.connect(this.model.properties.active.change,(()=>this._active_change()))}_active_change(){this.model.active||this._clear_data()}_keyup(e){e.keyCode==_.Keys.Enter&&this._clear_data()}_doubletap(e){this._do_select(this.data.sx,this.data.sy,!0,this._select_mode(e)),this.plot_view.state.push(\"poly_select\",{selection:this.plot_view.get_selection()}),this._clear_data()}_clear_data(){this.data={sx:[],sy:[]},this.model.overlay.update({xs:[],ys:[]})}_tap(e){const{sx:t,sy:s}=e;this.plot_view.frame.bbox.contains(t,s)&&(this.data.sx.push(t),this.data.sy.push(s),this.model.overlay.update({xs:c.copy(this.data.sx),ys:c.copy(this.data.sy)}))}_do_select(e,t,s,l){const o={type:\"poly\",sx:e,sy:t};this._select(o,s,l)}}s.PolySelectToolView=h,h.__name__=\"PolySelectToolView\";s.DEFAULT_POLY_OVERLAY=()=>new a.PolyAnnotation({level:\"overlay\",xs_units:\"screen\",ys_units:\"screen\",fill_color:\"lightgrey\",fill_alpha:.5,line_color:\"black\",line_alpha:1,line_width:2,line_dash:[4,4]});class y extends i.SelectTool{constructor(e){super(e),this.tool_name=\"Poly Select\",this.icon=n.tool_icon_polygon_select,this.event_type=\"tap\",this.default_order=11}static init_PolySelectTool(){this.prototype.default_view=h,this.define((({Ref:e})=>({overlay:[e(a.PolyAnnotation),s.DEFAULT_POLY_OVERLAY]}))),this.register_alias(\"poly_select\",(()=>new y))}}s.PolySelectTool=y,y.__name__=\"PolySelectTool\",y.init_PolySelectTool()},\n", + " function _(e,t,i,s,n){s();const r=e(20),_=e(383),d=e(242);class o extends _.LineToolView{constructor(){super(...arguments),this._drawing=!1}_doubletap(e){if(!this.model.active)return;const t=this.model.renderers;for(const i of t){1==this._select_event(e,\"replace\",[i]).length&&(this._selected_renderer=i)}this._show_intersections(),this._update_line_cds()}_show_intersections(){if(!this.model.active)return;if(null==this._selected_renderer)return;if(!this.model.renderers.length)return this._set_intersection([],[]),this._selected_renderer=null,void(this._drawing=!1);const e=this._selected_renderer.data_source,t=this._selected_renderer.glyph,[i,s]=[t.x.field,t.y.field],n=e.get_array(i),r=e.get_array(s);this._set_intersection(n,r)}_tap(e){const t=this.model.intersection_renderer;if(null==this._map_drag(e.sx,e.sy,t))return;if(this._drawing&&this._selected_renderer){const i=this._select_mode(e);if(0==this._select_event(e,i,[t]).length)return}const i=this._select_mode(e);this._select_event(e,i,[t]),this._select_event(e,i,this.model.renderers)}_update_line_cds(){if(null==this._selected_renderer)return;const e=this.model.intersection_renderer.glyph,t=this.model.intersection_renderer.data_source,[i,s]=[e.x.field,e.y.field];if(i&&s){const e=t.data[i],n=t.data[s];this._selected_renderer.data_source.data[i]=e,this._selected_renderer.data_source.data[s]=n}this._emit_cds_changes(this._selected_renderer.data_source,!0,!0,!1)}_pan_start(e){this._select_event(e,\"append\",[this.model.intersection_renderer]),this._basepoint=[e.sx,e.sy]}_pan(e){null!=this._basepoint&&(this._drag_points(e,[this.model.intersection_renderer],this.model.dimensions),this._selected_renderer&&this._selected_renderer.data_source.change.emit())}_pan_end(e){null!=this._basepoint&&(this._drag_points(e,[this.model.intersection_renderer]),this._emit_cds_changes(this.model.intersection_renderer.data_source,!1,!0,!0),this._selected_renderer&&this._emit_cds_changes(this._selected_renderer.data_source),this._basepoint=null)}activate(){this._drawing=!0}deactivate(){this._selected_renderer&&(this._drawing&&(this._drawing=!1),this._hide_intersections())}}i.LineEditToolView=o,o.__name__=\"LineEditToolView\";class l extends _.LineTool{constructor(e){super(e),this.tool_name=\"Line Edit Tool\",this.icon=d.tool_icon_line_edit,this.event_type=[\"tap\",\"pan\",\"move\"],this.default_order=4}static init_LineEditTool(){this.prototype.default_view=o,this.define((()=>({dimensions:[r.Dimensions,\"both\"]})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}i.LineEditTool=l,l.__name__=\"LineEditTool\",l.init_LineEditTool()},\n", + " function _(e,i,t,n,o){n();const s=e(8),_=e(370);class r extends _.EditToolView{_set_intersection(e,i){const t=this.model.intersection_renderer.glyph,n=this.model.intersection_renderer.data_source,[o,_]=[t.x.field,t.y.field];o&&(s.isArray(e)?n.data[o]=e:t.x={value:e}),_&&(s.isArray(i)?n.data[_]=i:t.y={value:i}),this._emit_cds_changes(n,!0,!0,!1)}_hide_intersections(){this._set_intersection([],[])}}t.LineToolView=r,r.__name__=\"LineToolView\";class c extends _.EditTool{constructor(e){super(e)}static init_LineTool(){this.define((({AnyRef:e})=>({intersection_renderer:[e()]})))}}t.LineTool=c,c.__name__=\"LineTool\",c.init_LineTool()},\n", + " function _(t,s,i,n,e){n();const o=t(1),a=t(237),_=t(20),h=o.__importStar(t(242));function l(t,s,i){const n=new Map;for(const[e,o]of t){const[t,a]=o.r_invert(s,i);n.set(e,{start:t,end:a})}return n}i.update_ranges=l;class r extends a.GestureToolView{_pan_start(t){var s;this.last_dx=0,this.last_dy=0;const{sx:i,sy:n}=t,e=this.plot_view.frame.bbox;if(!e.contains(i,n)){const t=e.h_range,s=e.v_range;(it.end)&&(this.v_axis_only=!0),(ns.end)&&(this.h_axis_only=!0)}null===(s=this.model.document)||void 0===s||s.interactive_start(this.plot_model)}_pan(t){var s;this._update(t.deltaX,t.deltaY),null===(s=this.model.document)||void 0===s||s.interactive_start(this.plot_model)}_pan_end(t){this.h_axis_only=!1,this.v_axis_only=!1,null!=this.pan_info&&this.plot_view.state.push(\"pan\",{range:this.pan_info})}_update(t,s){const i=this.plot_view.frame,n=t-this.last_dx,e=s-this.last_dy,o=i.bbox.h_range,a=o.start-n,_=o.end-n,h=i.bbox.v_range,r=h.start-e,d=h.end-e,p=this.model.dimensions;let c,m,u,x,v,y;\"width\"!=p&&\"both\"!=p||this.v_axis_only?(c=o.start,m=o.end,u=0):(c=a,m=_,u=-n),\"height\"!=p&&\"both\"!=p||this.h_axis_only?(x=h.start,v=h.end,y=0):(x=r,v=d,y=-e),this.last_dx=t,this.last_dy=s;const{x_scales:g,y_scales:w}=i,f=l(g,c,m),b=l(w,x,v);this.pan_info={xrs:f,yrs:b,sdx:u,sdy:y},this.plot_view.update_range(this.pan_info,{panning:!0})}}i.PanToolView=r,r.__name__=\"PanToolView\";class d extends a.GestureTool{constructor(t){super(t),this.tool_name=\"Pan\",this.event_type=\"pan\",this.default_order=10}static init_PanTool(){this.prototype.default_view=r,this.define((()=>({dimensions:[_.Dimensions,\"both\",{on_update(t,s){switch(t){case\"both\":s.icon=h.tool_icon_pan;break;case\"width\":s.icon=h.tool_icon_xpan;break;case\"height\":s.icon=h.tool_icon_ypan}}}]}))),this.register_alias(\"pan\",(()=>new d({dimensions:\"both\"}))),this.register_alias(\"xpan\",(()=>new d({dimensions:\"width\"}))),this.register_alias(\"ypan\",(()=>new d({dimensions:\"height\"})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}i.PanTool=d,d.__name__=\"PanTool\",d.init_PanTool()},\n", + " function _(t,e,i,s,n){s();const l=t(136),a=t(156),r=t(19),o=t(237),_=t(242);function h(t){switch(t){case 1:return 2;case 2:return 1;case 4:return 5;case 5:return 4;default:return t}}function d(t,e,i,s){if(null==e)return!1;const n=i.compute(e);return Math.abs(t-n)n.right)&&(l=!1)}if(null!=n.bottom&&null!=n.top){const t=s.invert(e);(tn.top)&&(l=!1)}return l}function c(t,e,i){let s=0;return t>=i.start&&t<=i.end&&(s+=1),e>=i.start&&e<=i.end&&(s+=1),s}function g(t,e,i,s){const n=e.compute(t),l=e.invert(n+i);return l>=s.start&&l<=s.end?l:t}function y(t,e,i){return t>e.start?(e.end=t,i):(e.end=e.start,e.start=t,h(i))}function f(t,e,i){return t=o&&(t.start=a,t.end=r)}i.flip_side=h,i.is_near=d,i.is_inside=u,i.sides_inside=c,i.compute_value=g,i.update_range_end_side=y,i.update_range_start_side=f,i.update_range=m;class v extends o.GestureToolView{initialize(){super.initialize(),this.side=0,this.model.update_overlay_from_ranges()}connect_signals(){super.connect_signals(),null!=this.model.x_range&&this.connect(this.model.x_range.change,(()=>this.model.update_overlay_from_ranges())),null!=this.model.y_range&&this.connect(this.model.y_range.change,(()=>this.model.update_overlay_from_ranges()))}_pan_start(t){this.last_dx=0,this.last_dy=0;const e=this.model.x_range,i=this.model.y_range,{frame:s}=this.plot_view,n=s.x_scale,a=s.y_scale,r=this.model.overlay,{left:o,right:_,top:h,bottom:c}=r,g=this.model.overlay.line_width+l.EDGE_TOLERANCE;null!=e&&this.model.x_interaction&&(d(t.sx,o,n,g)?this.side=1:d(t.sx,_,n,g)?this.side=2:u(t.sx,t.sy,n,a,r)&&(this.side=3)),null!=i&&this.model.y_interaction&&(0==this.side&&d(t.sy,c,a,g)&&(this.side=4),0==this.side&&d(t.sy,h,a,g)?this.side=5:u(t.sx,t.sy,n,a,this.model.overlay)&&(3==this.side?this.side=7:this.side=6))}_pan(t){const e=this.plot_view.frame,i=t.deltaX-this.last_dx,s=t.deltaY-this.last_dy,n=this.model.x_range,l=this.model.y_range,a=e.x_scale,r=e.y_scale;if(null!=n)if(3==this.side||7==this.side)m(n,a,i,e.x_range);else if(1==this.side){const t=g(n.start,a,i,e.x_range);this.side=f(t,n,this.side)}else if(2==this.side){const t=g(n.end,a,i,e.x_range);this.side=y(t,n,this.side)}if(null!=l)if(6==this.side||7==this.side)m(l,r,s,e.y_range);else if(4==this.side){const t=g(l.start,r,s,e.y_range);this.side=f(t,l,this.side)}else if(5==this.side){const t=g(l.end,r,s,e.y_range);this.side=y(t,l,this.side)}this.last_dx=t.deltaX,this.last_dy=t.deltaY}_pan_end(t){this.side=0}}i.RangeToolView=v,v.__name__=\"RangeToolView\";const p=()=>new l.BoxAnnotation({level:\"overlay\",fill_color:\"lightgrey\",fill_alpha:.5,line_color:\"black\",line_alpha:1,line_width:.5,line_dash:[2,2]});class x extends o.GestureTool{constructor(t){super(t),this.tool_name=\"Range Tool\",this.icon=_.tool_icon_range,this.event_type=\"pan\",this.default_order=1}static init_RangeTool(){this.prototype.default_view=v,this.define((({Boolean:t,Ref:e,Nullable:i})=>({x_range:[i(e(a.Range1d)),null],x_interaction:[t,!0],y_range:[i(e(a.Range1d)),null],y_interaction:[t,!0],overlay:[e(l.BoxAnnotation),p]})))}initialize(){super.initialize(),this.overlay.in_cursor=\"grab\",this.overlay.ew_cursor=null!=this.x_range&&this.x_interaction?\"ew-resize\":null,this.overlay.ns_cursor=null!=this.y_range&&this.y_interaction?\"ns-resize\":null}update_overlay_from_ranges(){null==this.x_range&&null==this.y_range&&(this.overlay.left=null,this.overlay.right=null,this.overlay.bottom=null,this.overlay.top=null,r.logger.warn(\"RangeTool not configured with any Ranges.\")),null==this.x_range?(this.overlay.left=null,this.overlay.right=null):(this.overlay.left=this.x_range.start,this.overlay.right=this.x_range.end),null==this.y_range?(this.overlay.bottom=null,this.overlay.top=null):(this.overlay.bottom=this.y_range.start,this.overlay.top=this.y_range.end)}}i.RangeTool=x,x.__name__=\"RangeTool\",x.init_RangeTool()},\n", + " function _(e,t,s,o,i){o();const l=e(378),a=e(20),n=e(242);class c extends l.SelectToolView{_tap(e){\"tap\"==this.model.gesture&&this._handle_tap(e)}_doubletap(e){\"doubletap\"==this.model.gesture&&this._handle_tap(e)}_handle_tap(e){const{sx:t,sy:s}=e,o={type:\"point\",sx:t,sy:s};this._select(o,!0,this._select_mode(e))}_select(e,t,s){const{callback:o}=this.model;if(\"select\"==this.model.behavior){const i=this._computed_renderers_by_data_source();for(const[,l]of i){const i=l[0].get_selection_manager(),a=l.map((e=>this.plot_view.renderer_view(e))).filter((e=>null!=e));if(i.select(a,e,t,s)&&null!=o){const t=a[0].coordinates.x_scale.invert(e.sx),s=a[0].coordinates.y_scale.invert(e.sy),l={geometries:Object.assign(Object.assign({},e),{x:t,y:s}),source:i.source};o.execute(this.model,l)}}this._emit_selection_event(e),this.plot_view.state.push(\"tap\",{selection:this.plot_view.get_selection()})}else for(const t of this.computed_renderers){const s=this.plot_view.renderer_view(t);if(null==s)continue;const i=t.get_selection_manager();if(i.inspect(s,e)&&null!=o){const t=s.coordinates.x_scale.invert(e.sx),l=s.coordinates.y_scale.invert(e.sy),a={geometries:Object.assign(Object.assign({},e),{x:t,y:l}),source:i.source};o.execute(this.model,a)}}}}s.TapToolView=c,c.__name__=\"TapToolView\";class _ extends l.SelectTool{constructor(e){super(e),this.tool_name=\"Tap\",this.icon=n.tool_icon_tap_select,this.event_type=\"tap\",this.default_order=10}static init_TapTool(){this.prototype.default_view=c,this.define((({Any:e,Enum:t,Nullable:s})=>({behavior:[a.TapBehavior,\"select\"],gesture:[t(\"tap\",\"doubletap\"),\"tap\"],callback:[s(e)]}))),this.register_alias(\"click\",(()=>new _({behavior:\"inspect\"}))),this.register_alias(\"tap\",(()=>new _)),this.register_alias(\"doubletap\",(()=>new _({gesture:\"doubletap\"})))}}s.TapTool=_,_.__name__=\"TapTool\",_.init_TapTool()},\n", + " function _(e,t,s,i,n){i();const o=e(237),a=e(20),l=e(242),_=e(384);class h extends o.GestureToolView{_scroll(e){let t=this.model.speed*e.delta;t>.9?t=.9:t<-.9&&(t=-.9),this._update_ranges(t)}_update_ranges(e){var t;const{frame:s}=this.plot_view,i=s.bbox.h_range,n=s.bbox.v_range,[o,a]=[i.start,i.end],[l,h]=[n.start,n.end];let r,d,c,p;switch(this.model.dimension){case\"height\":{const t=Math.abs(h-l);r=o,d=a,c=l-t*e,p=h-t*e;break}case\"width\":{const t=Math.abs(a-o);r=o-t*e,d=a-t*e,c=l,p=h;break}}const{x_scales:m,y_scales:u}=s,w={xrs:_.update_ranges(m,r,d),yrs:_.update_ranges(u,c,p),factor:e};this.plot_view.state.push(\"wheel_pan\",{range:w}),this.plot_view.update_range(w,{scrolling:!0}),null===(t=this.model.document)||void 0===t||t.interactive_start(this.plot_model)}}s.WheelPanToolView=h,h.__name__=\"WheelPanToolView\";class r extends o.GestureTool{constructor(e){super(e),this.tool_name=\"Wheel Pan\",this.icon=l.tool_icon_wheel_pan,this.event_type=\"scroll\",this.default_order=12}static init_WheelPanTool(){this.prototype.default_view=h,this.define((()=>({dimension:[a.Dimension,\"width\"]}))),this.internal((({Number:e})=>({speed:[e,.001]}))),this.register_alias(\"xwheel_pan\",(()=>new r({dimension:\"width\"}))),this.register_alias(\"ywheel_pan\",(()=>new r({dimension:\"height\"})))}get tooltip(){return this._get_dim_tooltip(this.dimension)}}s.WheelPanTool=r,r.__name__=\"WheelPanTool\",r.init_WheelPanTool()},\n", + " function _(e,o,t,s,i){s();const l=e(237),n=e(368),h=e(20),_=e(27),a=e(242);class m extends l.GestureToolView{_pinch(e){const{sx:o,sy:t,scale:s,ctrlKey:i,shiftKey:l}=e;let n;n=s>=1?20*(s-1):-20/s,this._scroll({type:\"wheel\",sx:o,sy:t,delta:n,ctrlKey:i,shiftKey:l})}_scroll(e){var o;const{frame:t}=this.plot_view,s=t.bbox.h_range,i=t.bbox.v_range,{sx:l,sy:h}=e,_=this.model.dimensions,a=(\"width\"==_||\"both\"==_)&&s.start({dimensions:[h.Dimensions,\"both\"],maintain_focus:[e,!0],zoom_on_axis:[e,!0],speed:[o,1/600]}))),this.register_alias(\"wheel_zoom\",(()=>new r({dimensions:\"both\"}))),this.register_alias(\"xwheel_zoom\",(()=>new r({dimensions:\"width\"}))),this.register_alias(\"ywheel_zoom\",(()=>new r({dimensions:\"height\"})))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}}t.WheelZoomTool=r,r.__name__=\"WheelZoomTool\",r.init_WheelZoomTool()},\n", + " function _(i,s,t,o,e){o();const n=i(247),l=i(233),h=i(20),a=i(13),r=i(242);class _ extends n.InspectToolView{_move(i){if(!this.model.active)return;const{sx:s,sy:t}=i;this.plot_view.frame.bbox.contains(s,t)?this._update_spans(s,t):this._update_spans(null,null)}_move_exit(i){this._update_spans(null,null)}_update_spans(i,s){const t=this.model.dimensions;\"width\"!=t&&\"both\"!=t||(this.model.spans.width.location=s),\"height\"!=t&&\"both\"!=t||(this.model.spans.height.location=i)}}t.CrosshairToolView=_,_.__name__=\"CrosshairToolView\";class c extends n.InspectTool{constructor(i){super(i),this.tool_name=\"Crosshair\",this.icon=r.tool_icon_crosshair}static init_CrosshairTool(){function i(i,s){return new l.Span({for_hover:!0,dimension:s,location_units:\"screen\",level:\"overlay\",line_color:i.line_color,line_width:i.line_width,line_alpha:i.line_alpha})}this.prototype.default_view=_,this.define((({Alpha:i,Number:s,Color:t})=>({dimensions:[h.Dimensions,\"both\"],line_color:[t,\"black\"],line_width:[s,1],line_alpha:[i,1]}))),this.internal((({Struct:s,Ref:t})=>({spans:[s({width:t(l.Span),height:t(l.Span)}),s=>({width:i(s,\"width\"),height:i(s,\"height\")})]}))),this.register_alias(\"crosshair\",(()=>new c))}get tooltip(){return this._get_dim_tooltip(this.dimensions)}get synthetic_renderers(){return a.values(this.spans)}}t.CrosshairTool=c,c.__name__=\"CrosshairTool\",c.init_CrosshairTool()},\n", + " function _(t,e,s,o,r){o();const n=t(53),i=t(13),a=t(34);class u extends n.Model{constructor(t){super(t)}static init_CustomJSHover(){this.define((({Unknown:t,String:e,Dict:s})=>({args:[s(t),{}],code:[e,\"\"]})))}get values(){return i.values(this.args)}_make_code(t,e,s,o){return new Function(...i.keys(this.args),t,e,s,a.use_strict(o))}format(t,e,s){return this._make_code(\"value\",\"format\",\"special_vars\",this.code)(...this.values,t,e,s)}}s.CustomJSHover=u,u.__name__=\"CustomJSHover\",u.init_CustomJSHover()},\n", + " function _(e,t,n,s,o){s();const i=e(1),r=e(247),l=e(390),a=e(254),c=e(61),_=e(123),d=e(62),p=e(63),h=e(127),u=i.__importStar(e(107)),m=e(182),y=e(43),f=e(22),x=e(13),v=e(245),w=e(8),g=e(122),b=e(20),k=e(242),C=e(15),S=e(161),T=i.__importStar(e(255));function $(e,t,n,s,o,i){const r={x:o[e],y:i[e]},l={x:o[e+1],y:i[e+1]};let a,c;if(\"span\"==t.type)\"h\"==t.direction?(a=Math.abs(r.x-n),c=Math.abs(l.x-n)):(a=Math.abs(r.y-s),c=Math.abs(l.y-s));else{const e={x:n,y:s};a=u.dist_2_pts(r,e),c=u.dist_2_pts(l,e)}return adelete this._template_el)),this.on_change([e,t,n],(async()=>await this._update_ttmodels()))}async _update_ttmodels(){const{_ttmodels:e,computed_renderers:t}=this;e.clear();const{tooltips:n}=this.model;if(null!=n)for(const t of this.computed_renderers){const s=new a.Tooltip({custom:w.isString(n)||w.isFunction(n),attachment:this.model.attachment,show_arrow:this.model.show_arrow});t instanceof c.GlyphRenderer?e.set(t,s):t instanceof _.GraphRenderer&&(e.set(t.node_renderer,s),e.set(t.edge_renderer,s))}const s=await g.build_views(this._ttviews,[...e.values()],{parent:this.plot_view});for(const e of s)e.render();const o=[...function*(){for(const e of t)e instanceof c.GlyphRenderer?yield e:e instanceof _.GraphRenderer&&(yield e.node_renderer,yield e.edge_renderer)}()],i=this._slots.get(this._update);if(null!=i){const e=new Set(o.map((e=>e.data_source)));C.Signal.disconnect_receiver(this,i,e)}for(const e of o)this.connect(e.data_source.inspect,this._update)}get computed_renderers(){const{renderers:e,names:t}=this.model,n=this.plot_model.data_renderers;return S.compute_renderers(e,n,t)}get ttmodels(){return this._ttmodels}_clear(){this._inspect(1/0,1/0);for(const[,e]of this.ttmodels)e.clear()}_move(e){if(!this.model.active)return;const{sx:t,sy:n}=e;this.plot_view.frame.bbox.contains(t,n)?this._inspect(t,n):this._clear()}_move_exit(){this._clear()}_inspect(e,t){let n;if(\"mouse\"==this.model.mode)n={type:\"point\",sx:e,sy:t};else{n={type:\"span\",direction:\"vline\"==this.model.mode?\"h\":\"v\",sx:e,sy:t}}for(const e of this.computed_renderers){const t=e.get_selection_manager(),s=this.plot_view.renderer_view(e);null!=s&&t.inspect(s,n)}this._emit_callback(n)}_update([e,{geometry:t}]){var n,s;if(!this.model.active)return;if(\"point\"!=t.type&&\"span\"!=t.type)return;if(!(e instanceof c.GlyphRenderer))return;if(\"ignore\"==this.model.muted_policy&&e.muted)return;const o=this.ttmodels.get(e);if(null==o)return;const i=e.get_selection_manager();let r=i.inspectors.get(e);if(r=e.view.convert_selection_to_subset(r),r.is_empty())return void o.clear();const l=i.source,a=this.plot_view.renderer_view(e);if(null==a)return;const{sx:_,sy:d}=t,u=a.coordinates.x_scale,m=a.coordinates.y_scale,f=u.invert(_),v=m.invert(d),{glyph:w}=a,g=[];if(w instanceof p.LineView)for(const n of r.line_indices){let s,o,i=w._x[n+1],a=w._y[n+1],c=n;switch(this.model.line_policy){case\"interp\":[i,a]=w.get_interpolation_hit(n,t),s=u.compute(i),o=m.compute(a);break;case\"prev\":[[s,o],c]=R(w.sx,w.sy,n);break;case\"next\":[[s,o],c]=R(w.sx,w.sy,n+1);break;case\"nearest\":[[s,o],c]=$(n,t,_,d,w.sx,w.sy),i=w._x[c],a=w._y[c];break;default:[s,o]=[_,d]}const p={index:c,x:f,y:v,sx:_,sy:d,data_x:i,data_y:a,rx:s,ry:o,indices:r.line_indices,name:e.name};g.push([s,o,this._render_tooltips(l,c,p)])}for(const t of r.image_indices){const n={index:t.index,x:f,y:v,sx:_,sy:d,name:e.name},s=this._render_tooltips(l,t,n);g.push([_,d,s])}for(const o of r.indices)if(w instanceof h.MultiLineView&&!x.isEmpty(r.multiline_indices))for(const n of r.multiline_indices[o.toString()]){let s,i,a,p=w._xs.get(o)[n],h=w._ys.get(o)[n],y=n;switch(this.model.line_policy){case\"interp\":[p,h]=w.get_interpolation_hit(o,n,t),s=u.compute(p),i=m.compute(h);break;case\"prev\":[[s,i],y]=R(w.sxs.get(o),w.sys.get(o),n);break;case\"next\":[[s,i],y]=R(w.sxs.get(o),w.sys.get(o),n+1);break;case\"nearest\":[[s,i],y]=$(n,t,_,d,w.sxs.get(o),w.sys.get(o)),p=w._xs.get(o)[y],h=w._ys.get(o)[y];break;default:throw new Error(\"shouldn't have happened\")}a=e instanceof c.GlyphRenderer?e.view.convert_indices_from_subset([o])[0]:o;const x={index:a,x:f,y:v,sx:_,sy:d,data_x:p,data_y:h,segment_index:y,indices:r.multiline_indices,name:e.name};g.push([s,i,this._render_tooltips(l,a,x)])}else{const t=null===(n=w._x)||void 0===n?void 0:n[o],i=null===(s=w._y)||void 0===s?void 0:s[o];let a,p,h;if(\"snap_to_data\"==this.model.point_policy){let e=w.get_anchor_point(this.model.anchor,o,[_,d]);if(null==e&&(e=w.get_anchor_point(\"center\",o,[_,d]),null==e))continue;a=e.x,p=e.y}else[a,p]=[_,d];h=e instanceof c.GlyphRenderer?e.view.convert_indices_from_subset([o])[0]:o;const u={index:h,x:f,y:v,sx:_,sy:d,data_x:t,data_y:i,indices:r.indices,name:e.name};g.push([a,p,this._render_tooltips(l,h,u)])}if(0==g.length)o.clear();else{const{content:e}=o;y.empty(o.content);for(const[,,t]of g)null!=t&&e.appendChild(t);const[t,n]=g[g.length-1];o.setv({position:[t,n]},{check_eq:!1})}}_emit_callback(e){const{callback:t}=this.model;if(null!=t)for(const n of this.computed_renderers){if(!(n instanceof c.GlyphRenderer))continue;const s=this.plot_view.renderer_view(n);if(null==s)continue;const{x_scale:o,y_scale:i}=s.coordinates,r=o.invert(e.sx),l=i.invert(e.sy),a=n.data_source.inspected;t.execute(this.model,{geometry:Object.assign({x:r,y:l},e),renderer:n,index:a})}}_create_template(e){const t=y.div({style:{display:\"table\",borderSpacing:\"2px\"}});for(const[n]of e){const e=y.div({style:{display:\"table-row\"}});t.appendChild(e);const s=y.div({style:{display:\"table-cell\"},class:T.tooltip_row_label},0!=n.length?`${n}: `:\"\");e.appendChild(s);const o=y.span();o.dataset.value=\"\";const i=y.span({class:T.tooltip_color_block},\" \");i.dataset.swatch=\"\",y.undisplay(i);const r=y.div({style:{display:\"table-cell\"},class:T.tooltip_row_value},o,i);e.appendChild(r)}return t}_render_template(e,t,n,s,o){const i=e.cloneNode(!0),r=i.querySelectorAll(\"[data-value]\"),l=i.querySelectorAll(\"[data-swatch]\"),a=/\\$color(\\[.*\\])?:(\\w*)/,c=/\\$swatch:(\\w*)/;for(const[[,e],i]of v.enumerate(t)){const t=e.match(c),_=e.match(a);if(null!=t||null!=_){if(null!=t){const[,e]=t,o=n.get_column(e);if(null==o)r[i].textContent=`${e} unknown`;else{const e=w.isNumber(s)?o[s]:null;null!=e&&(l[i].style.backgroundColor=f.color2css(e),y.display(l[i]))}}if(null!=_){const[,e=\"\",t]=_,o=n.get_column(t);if(null==o){r[i].textContent=`${t} unknown`;continue}const a=e.indexOf(\"hex\")>=0,c=e.indexOf(\"swatch\")>=0,d=w.isNumber(s)?o[s]:null;if(null==d){r[i].textContent=\"(null)\";continue}r[i].textContent=a?f.color2hex(d):f.color2css(d),c&&(l[i].style.backgroundColor=f.color2css(d),y.display(l[i]))}}else{const t=m.replace_placeholders(e.replace(\"$~\",\"$data_\"),n,s,this.model.formatters,o);if(w.isString(t))r[i].textContent=t;else for(const e of t)r[i].appendChild(e)}}return i}_render_tooltips(e,t,n){var s;const{tooltips:o}=this.model;if(w.isString(o)){const s=m.replace_placeholders({html:o},e,t,this.model.formatters,n);return y.div({},s)}if(w.isFunction(o))return o(e,n);if(null!=o){const i=null!==(s=this._template_el)&&void 0!==s?s:this._template_el=this._create_template(o);return this._render_template(i,o,e,t,n)}return null}}n.HoverToolView=H,H.__name__=\"HoverToolView\";class M extends r.InspectTool{constructor(e){super(e),this.tool_name=\"Hover\",this.icon=k.tool_icon_hover}static init_HoverTool(){this.prototype.default_view=H,this.define((({Any:e,Boolean:t,String:n,Array:s,Tuple:o,Dict:i,Or:r,Ref:a,Function:c,Auto:_,Nullable:p})=>({tooltips:[p(r(n,s(o(n,n)),c())),[[\"index\",\"$index\"],[\"data (x, y)\",\"($x, $y)\"],[\"screen (x, y)\",\"($sx, $sy)\"]]],formatters:[i(r(a(l.CustomJSHover),m.FormatterType)),{}],renderers:[r(s(a(d.DataRenderer)),_),\"auto\"],names:[s(n),[]],mode:[b.HoverMode,\"mouse\"],muted_policy:[b.MutedPolicy,\"show\"],point_policy:[b.PointPolicy,\"snap_to_data\"],line_policy:[b.LinePolicy,\"nearest\"],show_arrow:[t,!0],anchor:[b.Anchor,\"center\"],attachment:[b.TooltipAttachment,\"horizontal\"],callback:[p(e)]}))),this.register_alias(\"hover\",(()=>new M))}}n.HoverTool=M,M.__name__=\"HoverTool\",M.init_HoverTool()},\n", + " function _(t,o,e,n,i){n();const s=t(15),l=t(53),c=t(238),r=t(247),a=t(245);class u extends l.Model{constructor(t){super(t)}static init_ToolProxy(){this.define((({Boolean:t,Array:o,Ref:e})=>({tools:[o(e(c.ButtonTool)),[]],active:[t,!1],disabled:[t,!1]})))}get button_view(){return this.tools[0].button_view}get event_type(){return this.tools[0].event_type}get tooltip(){return this.tools[0].tooltip}get tool_name(){return this.tools[0].tool_name}get icon(){return this.tools[0].computed_icon}get computed_icon(){return this.icon}get toggleable(){const t=this.tools[0];return t instanceof r.InspectTool&&t.toggleable}initialize(){super.initialize(),this.do=new s.Signal0(this,\"do\")}connect_signals(){super.connect_signals(),this.connect(this.do,(()=>this.doit())),this.connect(this.properties.active.change,(()=>this.set_active()));for(const t of this.tools)this.connect(t.properties.active.change,(()=>{this.active=t.active}))}doit(){for(const t of this.tools)t.do.emit()}set_active(){for(const t of this.tools)t.active=this.active}get menu(){const{menu:t}=this.tools[0];if(null==t)return null;const o=[];for(const[e,n]of a.enumerate(t))if(null==e)o.push(null);else{const t=()=>{var t,o;for(const e of this.tools)null===(o=null===(t=e.menu)||void 0===t?void 0:t[n])||void 0===o||o.handler()};o.push(Object.assign(Object.assign({},e),{handler:t}))}return o}}e.ToolProxy=u,u.__name__=\"ToolProxy\",u.init_ToolProxy()},\n", + " function _(o,t,s,i,e){i();const n=o(20),r=o(9),l=o(13),c=o(248),h=o(235),a=o(392),_=o(319),p=o(221);class f extends c.ToolbarBase{constructor(o){super(o)}static init_ProxyToolbar(){this.define((({Array:o,Ref:t})=>({toolbars:[o(t(h.Toolbar)),[]]})))}initialize(){super.initialize(),this._merge_tools()}_merge_tools(){this._proxied_tools=[];const o={},t={},s={},i=[],e=[];for(const o of this.help)r.includes(e,o.redirect)||(i.push(o),e.push(o.redirect));this._proxied_tools.push(...i),this.help=i;for(const[o,t]of l.entries(this.gestures)){o in s||(s[o]={});for(const i of t.tools)i.type in s[o]||(s[o][i.type]=[]),s[o][i.type].push(i)}for(const t of this.inspectors)t.type in o||(o[t.type]=[]),o[t.type].push(t);for(const o of this.actions)o.type in t||(t[o.type]=[]),t[o.type].push(o);const n=(o,t=!1)=>{const s=new a.ToolProxy({tools:o,active:t});return this._proxied_tools.push(s),s};for(const o of l.keys(s)){const t=this.gestures[o];t.tools=[];for(const i of l.keys(s[o])){const e=s[o][i];if(e.length>0)if(\"multi\"==o)for(const o of e){const s=n([o]);t.tools.push(s),this.connect(s.properties.active.change,(()=>this._active_change(s)))}else{const o=n(e);t.tools.push(o),this.connect(o.properties.active.change,(()=>this._active_change(o)))}}}this.actions=[];for(const[o,s]of l.entries(t))if(\"CustomAction\"==o)for(const o of s)this.actions.push(n([o]));else s.length>0&&this.actions.push(n(s));this.inspectors=[];for(const t of l.values(o))t.length>0&&this.inspectors.push(n(t,!0));for(const[o,t]of l.entries(this.gestures))0!=t.tools.length&&(t.tools=r.sort_by(t.tools,(o=>o.default_order)),\"pinch\"!=o&&\"scroll\"!=o&&\"multi\"!=o&&(t.tools[0].active=!0))}}s.ProxyToolbar=f,f.__name__=\"ProxyToolbar\",f.init_ProxyToolbar();class u extends _.LayoutDOMView{initialize(){this.model.toolbar.toolbar_location=this.model.toolbar_location,super.initialize()}get child_models(){return[this.model.toolbar]}_update_layout(){this.layout=new p.ContentBox(this.child_views[0].el);const{toolbar:o}=this.model;o.horizontal?this.layout.set_sizing({width_policy:\"fit\",min_width:100,height_policy:\"fixed\"}):this.layout.set_sizing({width_policy:\"fixed\",height_policy:\"fit\",min_height:100})}}s.ToolbarBoxView=u,u.__name__=\"ToolbarBoxView\";class y extends _.LayoutDOM{constructor(o){super(o)}static init_ToolbarBox(){this.prototype.default_view=u,this.define((({Ref:o})=>({toolbar:[o(c.ToolbarBase)],toolbar_location:[n.Location,\"right\"]})))}}s.ToolbarBox=y,y.__name__=\"ToolbarBox\",y.init_ToolbarBox()},\n", + " function _(e,n,r,t,o){t();const s=e(1),u=e(53),c=s.__importStar(e(21)),a=e(8),l=e(13);r.resolve_defs=function(e,n){var r,t,o,s;function i(e){return null!=e.module?`${e.module}.${e.name}`:e.name}function f(e){if(a.isString(e))switch(e){case\"Any\":return c.Any;case\"Unknown\":return c.Unknown;case\"Boolean\":return c.Boolean;case\"Number\":return c.Number;case\"Int\":return c.Int;case\"String\":return c.String;case\"Null\":return c.Null}else switch(e[0]){case\"Nullable\":{const[,n]=e;return c.Nullable(f(n))}case\"Or\":{const[,...n]=e;return c.Or(...n.map(f))}case\"Tuple\":{const[,n,...r]=e;return c.Tuple(f(n),...r.map(f))}case\"Array\":{const[,n]=e;return c.Array(f(n))}case\"Struct\":{const[,...n]=e,r=n.map((([e,n])=>[e,f(n)]));return c.Struct(l.to_object(r))}case\"Dict\":{const[,n]=e;return c.Dict(f(n))}case\"Map\":{const[,n,r]=e;return c.Map(f(n),f(r))}case\"Enum\":{const[,...n]=e;return c.Enum(...n)}case\"Ref\":{const[,r]=e,t=n.get(i(r));if(null!=t)return c.Ref(t);throw new Error(`${i(r)} wasn't defined before referencing it`)}case\"AnyRef\":return c.AnyRef()}}for(const c of e){const e=(()=>{if(null==c.extends)return u.Model;{const e=n.get(i(c.extends));if(null!=e)return e;throw new Error(`base model ${i(c.extends)} of ${i(c)} is not defined`)}})(),a=((s=class extends e{}).__name__=c.name,s.__module__=c.module,s);for(const e of null!==(r=c.properties)&&void 0!==r?r:[]){const n=f(null!==(t=e.kind)&&void 0!==t?t:\"Unknown\");a.define({[e.name]:[n,e.default]})}for(const e of null!==(o=c.overrides)&&void 0!==o?o:[])a.override({[e.name]:e.default});n.register(a)}}},\n", + " function _(n,e,t,o,i){o();const d=n(5),c=n(240),s=n(122),a=n(43),l=n(396);t.index={},t.add_document_standalone=async function(n,e,o=[],i=!1){const u=new Map;async function f(i){let d;const f=n.roots().indexOf(i),r=o[f];null!=r?d=r:e.classList.contains(l.BOKEH_ROOT)?d=e:(d=a.div({class:l.BOKEH_ROOT}),e.appendChild(d));const w=await s.build_view(i,{parent:null});return w instanceof c.DOMView&&w.renderTo(d),u.set(i,w),t.index[i.id]=w,w}for(const e of n.roots())await f(e);return i&&(window.document.title=n.title()),n.on_change((n=>{n instanceof d.RootAddedEvent?f(n.model):n instanceof d.RootRemovedEvent?function(n){const e=u.get(n);null!=e&&(e.remove(),u.delete(n),delete t.index[n.id])}(n.model):i&&n instanceof d.TitleChangedEvent&&(window.document.title=n.title)})),[...u.values()]}},\n", + " function _(o,e,n,t,r){t();const l=o(43),d=o(44);function u(o){let e=document.getElementById(o);if(null==e)throw new Error(`Error rendering Bokeh model: could not find #${o} HTML tag`);if(!document.body.contains(e))throw new Error(`Error rendering Bokeh model: element #${o} must be under `);if(\"SCRIPT\"==e.tagName){const o=l.div({class:n.BOKEH_ROOT});l.replaceWith(e,o),e=o}return e}n.BOKEH_ROOT=d.root,n._resolve_element=function(o){const{elementid:e}=o;return null!=e?u(e):document.body},n._resolve_root_elements=function(o){const e=[];if(null!=o.root_ids&&null!=o.roots)for(const n of o.root_ids)e.push(u(o.roots[n]));return e}},\n", + " function _(n,o,t,s,e){s();const c=n(398),r=n(19),a=n(395);t._get_ws_url=function(n,o){let t,s=\"ws:\";return\"https:\"==window.location.protocol&&(s=\"wss:\"),null!=o?(t=document.createElement(\"a\"),t.href=o):t=window.location,null!=n?\"/\"==n&&(n=\"\"):n=t.pathname.replace(/\\/+$/,\"\"),s+\"//\"+t.host+n+\"/ws\"};const i={};t.add_document_from_session=async function(n,o,t,s=[],e=!1){const l=window.location.search.substr(1);let d;try{d=await function(n,o,t){const s=c.parse_token(o).session_id;n in i||(i[n]={});const e=i[n];return s in e||(e[s]=c.pull_session(n,o,t)),e[s]}(n,o,l)}catch(n){const t=c.parse_token(o).session_id;throw r.logger.error(`Failed to load Bokeh session ${t}: ${n}`),n}return a.add_document_standalone(d.document,t,s,e)}},\n", + " function _(e,s,n,t,o){t();const r=e(19),i=e(5),c=e(399),l=e(400),_=e(401);n.DEFAULT_SERVER_WEBSOCKET_URL=\"ws://localhost:5006/ws\",n.DEFAULT_TOKEN=\"eyJzZXNzaW9uX2lkIjogImRlZmF1bHQifQ\";let h=0;function a(e){let s=e.split(\".\")[0];const n=s.length%4;return 0!=n&&(s+=\"=\".repeat(4-n)),JSON.parse(atob(s.replace(/_/g,\"/\").replace(/-/g,\"+\")))}n.parse_token=a;class d{constructor(e=n.DEFAULT_SERVER_WEBSOCKET_URL,s=n.DEFAULT_TOKEN,t=null){this.url=e,this.token=s,this.args_string=t,this._number=h++,this.socket=null,this.session=null,this.closed_permanently=!1,this._current_handler=null,this._pending_replies=new Map,this._pending_messages=[],this._receiver=new l.Receiver,this.id=a(s).session_id.split(\".\")[0],r.logger.debug(`Creating websocket ${this._number} to '${this.url}' session '${this.id}'`)}async connect(){if(this.closed_permanently)throw new Error(\"Cannot connect() a closed ClientConnection\");if(null!=this.socket)throw new Error(\"Already connected\");this._current_handler=null,this._pending_replies.clear(),this._pending_messages=[];try{let e=`${this.url}`;return null!=this.args_string&&this.args_string.length>0&&(e+=`?${this.args_string}`),this.socket=new WebSocket(e,[\"bokeh\",this.token]),new Promise(((e,s)=>{this.socket.binaryType=\"arraybuffer\",this.socket.onopen=()=>this._on_open(e,s),this.socket.onmessage=e=>this._on_message(e),this.socket.onclose=e=>this._on_close(e,s),this.socket.onerror=()=>this._on_error(s)}))}catch(e){throw r.logger.error(`websocket creation failed to url: ${this.url}`),r.logger.error(` - ${e}`),e}}close(){this.closed_permanently||(r.logger.debug(`Permanently closing websocket connection ${this._number}`),this.closed_permanently=!0,null!=this.socket&&this.socket.close(1e3,`close method called on ClientConnection ${this._number}`),this.session._connection_closed())}_schedule_reconnect(e){setTimeout((()=>{this.closed_permanently||r.logger.info(`Websocket connection ${this._number} disconnected, will not attempt to reconnect`)}),e)}send(e){if(null==this.socket)throw new Error(`not connected so cannot send ${e}`);e.send(this.socket)}async send_with_reply(e){const s=await new Promise(((s,n)=>{this._pending_replies.set(e.msgid(),{resolve:s,reject:n}),this.send(e)}));if(\"ERROR\"===s.msgtype())throw new Error(`Error reply ${s.content.text}`);return s}async _pull_doc_json(){const e=c.Message.create(\"PULL-DOC-REQ\",{}),s=await this.send_with_reply(e);if(!(\"doc\"in s.content))throw new Error(\"No 'doc' field in PULL-DOC-REPLY\");return s.content.doc}async _repull_session_doc(e,s){var n;r.logger.debug(this.session?\"Repulling session\":\"Pulling session for first time\");try{const n=await this._pull_doc_json();if(null==this.session)if(this.closed_permanently)r.logger.debug(\"Got new document after connection was already closed\"),s(new Error(\"The connection has been closed\"));else{const s=i.Document.from_json(n),t=i.Document._compute_patch_since_json(n,s);if(t.events.length>0){r.logger.debug(`Sending ${t.events.length} changes from model construction back to server`);const e=c.Message.create(\"PATCH-DOC\",{},t);this.send(e)}this.session=new _.ClientSession(this,s,this.id);for(const e of this._pending_messages)this.session.handle(e);this._pending_messages=[],r.logger.debug(\"Created a new session from new pulled doc\"),e(this.session)}else this.session.document.replace_with_json(n),r.logger.debug(\"Updated existing session with new pulled doc\")}catch(e){null===(n=console.trace)||void 0===n||n.call(console,e),r.logger.error(`Failed to repull session ${e}`),s(e instanceof Error?e:`${e}`)}}_on_open(e,s){r.logger.info(`Websocket connection ${this._number} is now open`),this._current_handler=n=>{this._awaiting_ack_handler(n,e,s)}}_on_message(e){null==this._current_handler&&r.logger.error(\"Got a message with no current handler set\");try{this._receiver.consume(e.data)}catch(e){this._close_bad_protocol(`${e}`)}const s=this._receiver.message;if(null!=s){const e=s.problem();null!=e&&this._close_bad_protocol(e),this._current_handler(s)}}_on_close(e,s){r.logger.info(`Lost websocket ${this._number} connection, ${e.code} (${e.reason})`),this.socket=null,this._pending_replies.forEach((e=>e.reject(\"Disconnected\"))),this._pending_replies.clear(),this.closed_permanently||this._schedule_reconnect(2e3),s(new Error(`Lost websocket connection, ${e.code} (${e.reason})`))}_on_error(e){r.logger.debug(`Websocket error on socket ${this._number}`);const s=\"Could not open websocket\";r.logger.error(`Failed to connect to Bokeh server: ${s}`),e(new Error(s))}_close_bad_protocol(e){r.logger.error(`Closing connection: ${e}`),null!=this.socket&&this.socket.close(1002,e)}_awaiting_ack_handler(e,s,n){\"ACK\"===e.msgtype()?(this._current_handler=e=>this._steady_state_handler(e),this._repull_session_doc(s,n)):this._close_bad_protocol(\"First message was not an ACK\")}_steady_state_handler(e){const s=e.reqid(),n=this._pending_replies.get(s);n?(this._pending_replies.delete(s),n.resolve(e)):this.session?this.session.handle(e):\"PATCH-DOC\"!=e.msgtype()&&this._pending_messages.push(e)}}n.ClientConnection=d,d.__name__=\"ClientConnection\",n.pull_session=function(e,s,n){return new d(e,s,n).connect()}},\n", + " function _(e,s,t,r,n){r();const i=e(34);class a{constructor(e,s,t){this.header=e,this.metadata=s,this.content=t,this.buffers=new Map}static assemble(e,s,t){const r=JSON.parse(e),n=JSON.parse(s),i=JSON.parse(t);return new a(r,n,i)}assemble_buffer(e,s){const t=null!=this.header.num_buffers?this.header.num_buffers:0;if(t<=this.buffers.size)throw new Error(`too many buffers received, expecting ${t}`);const{id:r}=JSON.parse(e);this.buffers.set(r,s)}static create(e,s,t={}){const r=a.create_header(e);return new a(r,s,t)}static create_header(e){return{msgid:i.uniqueId(),msgtype:e}}complete(){return null!=this.header&&null!=this.metadata&&null!=this.content&&(null==this.header.num_buffers||this.buffers.size==this.header.num_buffers)}send(e){if((null!=this.header.num_buffers?this.header.num_buffers:0)>0)throw new Error(\"BokehJS only supports receiving buffers, not sending\");const s=JSON.stringify(this.header),t=JSON.stringify(this.metadata),r=JSON.stringify(this.content);e.send(s),e.send(t),e.send(r)}msgid(){return this.header.msgid}msgtype(){return this.header.msgtype}reqid(){return this.header.reqid}problem(){return\"msgid\"in this.header?\"msgtype\"in this.header?null:\"No msgtype in header\":\"No msgid in header\"}}t.Message=a,a.__name__=\"Message\"},\n", + " function _(e,t,s,_,r){_();const i=e(399),h=e(8);class a{constructor(){this.message=null,this._partial=null,this._fragments=[],this._buf_header=null,this._current_consumer=this._HEADER}consume(e){this._current_consumer(e)}_HEADER(e){this._assume_text(e),this.message=null,this._partial=null,this._fragments=[e],this._buf_header=null,this._current_consumer=this._METADATA}_METADATA(e){this._assume_text(e),this._fragments.push(e),this._current_consumer=this._CONTENT}_CONTENT(e){this._assume_text(e),this._fragments.push(e);const[t,s,_]=this._fragments.slice(0,3);this._partial=i.Message.assemble(t,s,_),this._check_complete()}_BUFFER_HEADER(e){this._assume_text(e),this._buf_header=e,this._current_consumer=this._BUFFER_PAYLOAD}_BUFFER_PAYLOAD(e){this._assume_binary(e),this._partial.assemble_buffer(this._buf_header,e),this._check_complete()}_assume_text(e){if(!h.isString(e))throw new Error(\"Expected text fragment but received binary fragment\")}_assume_binary(e){if(!(e instanceof ArrayBuffer))throw new Error(\"Expected binary fragment but received text fragment\")}_check_complete(){this._partial.complete()?(this.message=this._partial,this._current_consumer=this._HEADER):this._current_consumer=this._BUFFER_HEADER}}s.Receiver=a,a.__name__=\"Receiver\"},\n", + " function _(e,t,n,s,o){s();const c=e(5),i=e(399),_=e(19);class r{constructor(e,t,n){this._connection=e,this.document=t,this.id=n,this._document_listener=e=>{this._document_changed(e)},this.document.on_change(this._document_listener,!0)}handle(e){const t=e.msgtype();\"PATCH-DOC\"===t?this._handle_patch(e):\"OK\"===t?this._handle_ok(e):\"ERROR\"===t?this._handle_error(e):_.logger.debug(`Doing nothing with message ${e.msgtype()}`)}close(){this._connection.close()}_connection_closed(){this.document.remove_on_change(this._document_listener)}async request_server_info(){const e=i.Message.create(\"SERVER-INFO-REQ\",{});return(await this._connection.send_with_reply(e)).content}async force_roundtrip(){await this.request_server_info()}_document_changed(e){if(e.setter_id===this.id)return;const t=e instanceof c.DocumentEventBatch?e.events:[e],n=this.document.create_json_patch(t),s=i.Message.create(\"PATCH-DOC\",{},n);this._connection.send(s)}_handle_patch(e){this.document.apply_json_patch(e.content,e.buffers,this.id)}_handle_ok(e){_.logger.trace(`Unhandled OK reply to ${e.reqid()}`)}_handle_error(e){_.logger.error(`Unhandled ERROR reply to ${e.reqid()}: ${e.content.text}`)}}n.ClientSession=r,r.__name__=\"ClientSession\"},\n", + " function _(e,o,t,n,r){n();const s=e(1),l=e(5),i=e(400),a=e(19),c=e(43),g=e(13),f=e(395),u=e(396),m=s.__importDefault(e(44)),p=s.__importDefault(e(253)),d=s.__importDefault(e(403));function _(e,o){o.buffers.length>0?e.consume(o.buffers[0].buffer):e.consume(o.content.data);const t=e.message;null!=t&&this.apply_json_patch(t.content,t.buffers)}function b(e,o){if(\"undefined\"!=typeof Jupyter&&null!=Jupyter.notebook.kernel){a.logger.info(`Registering Jupyter comms for target ${e}`);const t=Jupyter.notebook.kernel.comm_manager;try{t.register_target(e,(t=>{a.logger.info(`Registering Jupyter comms for target ${e}`);const n=new i.Receiver;t.on_msg(_.bind(o,n))}))}catch(e){a.logger.warn(`Jupyter comms failed to register. push_notebook() will not function. (exception reported: ${e})`)}}else if(o.roots()[0].id in t.kernels){a.logger.info(`Registering JupyterLab comms for target ${e}`);const n=t.kernels[o.roots()[0].id];try{n.registerCommTarget(e,(t=>{a.logger.info(`Registering JupyterLab comms for target ${e}`);const n=new i.Receiver;t.onMsg=_.bind(o,n)}))}catch(e){a.logger.warn(`Jupyter comms failed to register. push_notebook() will not function. (exception reported: ${e})`)}}else if(\"undefined\"!=typeof google&&null!=google.colab.kernel){a.logger.info(`Registering Google Colab comms for target ${e}`);const t=google.colab.kernel.comms;try{t.registerTarget(e,(async t=>{var n,r,l;a.logger.info(`Registering Google Colab comms for target ${e}`);const c=new i.Receiver;try{for(var g,f=s.__asyncValues(t.messages);!(g=await f.next()).done;){const e=g.value,t={data:e.data},n=[];for(const o of null!==(l=e.buffers)&&void 0!==l?l:[])n.push(new DataView(o));const r={content:t,buffers:n};_.bind(o)(c,r)}}catch(e){n={error:e}}finally{try{g&&!g.done&&(r=f.return)&&await r.call(f)}finally{if(n)throw n.error}}}))}catch(e){a.logger.warn(`Google Colab comms failed to register. push_notebook() will not function. (exception reported: ${e})`)}}else console.warn(\"Jupyter notebooks comms not available. push_notebook() will not function. If running JupyterLab ensure the latest @bokeh/jupyter_bokeh extension is installed. In an exported notebook this warning is expected.\")}c.stylesheet.append(m.default),c.stylesheet.append(p.default),c.stylesheet.append(d.default),t.kernels={},t.embed_items_notebook=function(e,o){if(1!=g.size(e))throw new Error(\"embed_items_notebook expects exactly one document in docs_json\");const t=l.Document.from_json(g.values(e)[0]);for(const e of o){null!=e.notebook_comms_target&&b(e.notebook_comms_target,t);const o=u._resolve_element(e),n=u._resolve_root_elements(e);f.add_document_standalone(t,o,n)}}},\n", + " function _(t,o,r,e,d){e(),r.root=\"bk-root\",r.tooltip=\"bk-tooltip\",r.default=\".rendered_html .bk-root .bk-tooltip table,.rendered_html .bk-root .bk-tooltip tr,.rendered_html .bk-root .bk-tooltip th,.rendered_html .bk-root .bk-tooltip td{border:none;padding:1px;}\"},\n", + " function _(t,_,o,r,n){r();const a=t(1);a.__exportStar(t(399),o),a.__exportStar(t(400),o)},\n", + " function _(e,t,n,s,o){function l(){const e=document.getElementsByTagName(\"body\")[0],t=document.getElementsByClassName(\"bokeh-test-div\");1==t.length&&(e.removeChild(t[0]),delete t[0]);const n=document.createElement(\"div\");n.classList.add(\"bokeh-test-div\"),n.style.display=\"none\",e.insertBefore(n,e.firstChild)}s(),n.results={},n.init=function(){l()},n.record0=function(e,t){n.results[e]=t},n.record=function(e,t){n.results[e]=t,l()},n.count=function(e){null==n.results[e]&&(n.results[e]=0),n.results[e]+=1,l()}},\n", + " function _(e,t,o,n,l){n(),o.safely=function(e,t=!1){try{return e()}catch(e){if(function(e){const t=document.createElement(\"div\");t.style.backgroundColor=\"#f2dede\",t.style.border=\"1px solid #a94442\",t.style.borderRadius=\"4px\",t.style.display=\"inline-block\",t.style.fontFamily=\"sans-serif\",t.style.marginTop=\"5px\",t.style.minWidth=\"200px\",t.style.padding=\"5px 5px 5px 10px\",t.classList.add(\"bokeh-error-box-into-flames\");const o=document.createElement(\"span\");o.style.backgroundColor=\"#a94442\",o.style.borderRadius=\"0px 4px 0px 0px\",o.style.color=\"white\",o.style.cursor=\"pointer\",o.style.cssFloat=\"right\",o.style.fontSize=\"0.8em\",o.style.margin=\"-6px -6px 0px 0px\",o.style.padding=\"2px 5px 4px 5px\",o.title=\"close\",o.setAttribute(\"aria-label\",\"close\"),o.appendChild(document.createTextNode(\"x\")),o.addEventListener(\"click\",(()=>s.removeChild(t)));const n=document.createElement(\"h3\");n.style.color=\"#a94442\",n.style.margin=\"8px 0px 0px 0px\",n.style.padding=\"0px\",n.appendChild(document.createTextNode(\"Bokeh Error\"));const l=document.createElement(\"pre\");l.style.whiteSpace=\"unset\",l.style.overflowX=\"auto\",l.appendChild(document.createTextNode(e)),t.appendChild(o),t.appendChild(n),t.appendChild(l);const s=document.getElementsByTagName(\"body\")[0];s.insertBefore(t,s.firstChild)}(e instanceof Error&&e.stack?e.stack:`${e}`),t)return;throw e}}},\n", + " ], 0, {\"main\":0,\"tslib\":1,\"index\":2,\"version\":3,\"embed/index\":4,\"document/index\":5,\"document/document\":6,\"base\":7,\"core/util/types\":8,\"core/util/array\":9,\"core/util/math\":10,\"core/util/assert\":11,\"core/util/arrayable\":12,\"core/util/object\":13,\"core/has_props\":14,\"core/signaling\":15,\"core/util/defer\":16,\"core/util/refs\":17,\"core/properties\":18,\"core/logging\":19,\"core/enums\":20,\"core/kinds\":21,\"core/util/color\":22,\"core/util/svg_colors\":23,\"core/types\":24,\"core/util/bitset\":25,\"core/util/eq\":26,\"core/util/platform\":27,\"core/settings\":28,\"core/util/ndarray\":29,\"core/serializer\":30,\"core/util/serialization\":31,\"core/util/buffer\":32,\"core/uniforms\":33,\"core/util/string\":34,\"document/events\":35,\"core/util/pretty\":36,\"core/util/cloneable\":37,\"models/index\":38,\"models/annotations/index\":39,\"models/annotations/annotation\":40,\"models/renderers/renderer\":41,\"core/view\":42,\"core/dom\":43,\"styles/root.css\":44,\"core/visuals/index\":45,\"core/visuals/line\":46,\"core/visuals/visual\":47,\"core/property_mixins\":48,\"core/visuals/fill\":49,\"core/visuals/text\":50,\"core/visuals/hatch\":51,\"core/visuals/patterns\":52,\"model\":53,\"models/canvas/coordinates\":54,\"models/annotations/arrow\":55,\"models/annotations/data_annotation\":56,\"models/sources/columnar_data_source\":57,\"models/sources/data_source\":58,\"models/selections/selection\":59,\"core/selection_manager\":60,\"models/renderers/glyph_renderer\":61,\"models/renderers/data_renderer\":62,\"models/glyphs/line\":63,\"models/glyphs/xy_glyph\":64,\"core/util/projections\":65,\"models/glyphs/glyph\":98,\"core/util/bbox\":99,\"core/util/ragged_array\":100,\"core/util/spatial\":101,\"models/ranges/factor_range\":104,\"models/ranges/range\":105,\"models/glyphs/utils\":106,\"core/hittest\":107,\"models/glyphs/webgl/line\":108,\"models/glyphs/webgl/utils/index\":109,\"models/glyphs/webgl/utils/program\":110,\"models/glyphs/webgl/utils/buffer\":111,\"models/glyphs/webgl/utils/texture\":112,\"models/glyphs/webgl/base\":113,\"models/glyphs/webgl/line.vert\":114,\"models/glyphs/webgl/line.frag\":115,\"models/glyphs/patch\":116,\"models/glyphs/harea\":117,\"models/glyphs/area\":118,\"models/glyphs/varea\":119,\"models/sources/cds_view\":120,\"models/filters/filter\":121,\"core/build_views\":122,\"models/renderers/graph_renderer\":123,\"models/expressions/expression\":124,\"models/graphs/layout_provider\":125,\"models/graphs/graph_hit_test_policy\":126,\"models/glyphs/multi_line\":127,\"models/glyphs/patches\":128,\"models/selections/interaction_policy\":129,\"models/sources/column_data_source\":130,\"core/util/typed_array\":131,\"core/util/set\":132,\"models/annotations/arrow_head\":133,\"models/annotations/band\":134,\"models/annotations/upper_lower\":135,\"models/annotations/box_annotation\":136,\"models/annotations/color_bar\":137,\"models/annotations/title\":138,\"models/annotations/text_annotation\":139,\"core/layout/side_panel\":140,\"core/layout/types\":141,\"core/layout/layoutable\":142,\"core/util/text\":143,\"models/canvas/cartesian_frame\":144,\"models/scales/categorical_scale\":145,\"models/scales/scale\":146,\"models/transforms/index\":147,\"models/transforms/customjs_transform\":148,\"models/transforms/transform\":149,\"models/transforms/dodge\":150,\"models/transforms/range_transform\":151,\"models/transforms/interpolator\":152,\"models/transforms/jitter\":153,\"models/transforms/linear_interpolator\":154,\"models/transforms/step_interpolator\":155,\"models/ranges/range1d\":156,\"models/scales/log_scale\":157,\"models/scales/continuous_scale\":158,\"models/ranges/data_range1d\":159,\"models/ranges/data_range\":160,\"models/util\":161,\"models/axes/index\":162,\"models/axes/axis\":163,\"models/renderers/guide_renderer\":164,\"models/tickers/ticker\":165,\"models/formatters/tick_formatter\":166,\"core/graphics\":167,\"core/util/affine\":168,\"models/policies/labeling\":169,\"models/axes/categorical_axis\":170,\"models/tickers/categorical_ticker\":171,\"models/formatters/categorical_tick_formatter\":172,\"models/axes/continuous_axis\":173,\"models/axes/datetime_axis\":174,\"models/axes/linear_axis\":175,\"models/formatters/basic_tick_formatter\":176,\"models/tickers/basic_ticker\":177,\"models/tickers/adaptive_ticker\":178,\"models/tickers/continuous_ticker\":179,\"models/formatters/datetime_tick_formatter\":180,\"core/util/templating\":182,\"models/tickers/datetime_ticker\":185,\"models/tickers/composite_ticker\":186,\"models/tickers/days_ticker\":187,\"models/tickers/single_interval_ticker\":188,\"models/tickers/util\":189,\"models/tickers/months_ticker\":190,\"models/tickers/years_ticker\":191,\"models/axes/log_axis\":192,\"models/formatters/log_tick_formatter\":193,\"models/tickers/log_ticker\":194,\"models/axes/mercator_axis\":195,\"models/formatters/mercator_tick_formatter\":196,\"models/tickers/mercator_ticker\":197,\"models/tickers/index\":198,\"models/tickers/fixed_ticker\":199,\"models/tickers/binned_ticker\":200,\"models/mappers/scanning_color_mapper\":201,\"models/mappers/continuous_color_mapper\":202,\"models/mappers/color_mapper\":203,\"models/mappers/mapper\":204,\"models/formatters/index\":205,\"models/formatters/func_tick_formatter\":206,\"models/formatters/numeral_tick_formatter\":207,\"models/formatters/printf_tick_formatter\":208,\"models/mappers/index\":209,\"models/mappers/categorical_color_mapper\":210,\"models/mappers/categorical_mapper\":211,\"models/mappers/categorical_marker_mapper\":212,\"models/mappers/categorical_pattern_mapper\":213,\"models/mappers/linear_color_mapper\":214,\"models/mappers/log_color_mapper\":215,\"models/mappers/eqhist_color_mapper\":216,\"models/scales/index\":217,\"models/scales/linear_scale\":218,\"models/scales/linear_interpolation_scale\":219,\"models/ranges/index\":220,\"core/layout/index\":221,\"core/layout/alignments\":222,\"core/layout/grid\":223,\"core/layout/html\":224,\"core/layout/border\":225,\"models/annotations/label\":226,\"models/annotations/label_set\":227,\"models/annotations/legend\":228,\"models/annotations/legend_item\":229,\"core/vectorization\":230,\"models/annotations/poly_annotation\":231,\"models/annotations/slope\":232,\"models/annotations/span\":233,\"models/annotations/toolbar_panel\":234,\"models/tools/toolbar\":235,\"models/tools/tool\":236,\"models/tools/gestures/gesture_tool\":237,\"models/tools/button_tool\":238,\"core/dom_view\":240,\"styles/toolbar.css\":241,\"styles/icons.css\":242,\"styles/menus.css\":243,\"core/util/menus\":244,\"core/util/iterator\":245,\"models/tools/on_off_button\":246,\"models/tools/inspectors/inspect_tool\":247,\"models/tools/toolbar_base\":248,\"core/util/canvas\":249,\"core/util/svg\":250,\"models/tools/actions/action_tool\":251,\"models/tools/actions/help_tool\":252,\"styles/logo.css\":253,\"models/annotations/tooltip\":254,\"styles/tooltips.css\":255,\"models/annotations/whisker\":256,\"models/callbacks/index\":257,\"models/callbacks/customjs\":258,\"models/callbacks/callback\":259,\"models/callbacks/open_url\":260,\"models/canvas/index\":261,\"models/canvas/canvas\":262,\"core/ui_events\":263,\"core/bokeh_events\":264,\"core/util/wheel\":265,\"models/expressions/index\":266,\"models/expressions/customjs_expr\":267,\"models/expressions/stack\":268,\"models/expressions/cumsum\":269,\"models/expressions/minimum\":270,\"models/expressions/maximum\":271,\"models/filters/index\":272,\"models/filters/boolean_filter\":273,\"models/filters/customjs_filter\":274,\"models/filters/group_filter\":275,\"models/filters/index_filter\":276,\"models/glyphs/index\":277,\"models/glyphs/annular_wedge\":278,\"models/glyphs/annulus\":279,\"models/glyphs/arc\":280,\"models/glyphs/bezier\":281,\"models/glyphs/circle\":282,\"models/glyphs/webgl/markers\":283,\"models/glyphs/webgl/markers.vert\":284,\"models/glyphs/webgl/markers.frag\":285,\"models/glyphs/ellipse\":286,\"models/glyphs/ellipse_oval\":287,\"models/glyphs/center_rotatable\":288,\"models/glyphs/hbar\":289,\"models/glyphs/box\":290,\"models/glyphs/hex_tile\":291,\"models/glyphs/image\":292,\"models/glyphs/image_base\":293,\"models/glyphs/image_rgba\":294,\"models/glyphs/image_url\":295,\"core/util/image\":296,\"models/glyphs/multi_polygons\":297,\"models/glyphs/oval\":298,\"models/glyphs/quad\":299,\"models/glyphs/quadratic\":300,\"models/glyphs/ray\":301,\"models/glyphs/rect\":302,\"models/glyphs/scatter\":303,\"models/glyphs/marker\":304,\"models/glyphs/defs\":305,\"models/glyphs/segment\":306,\"models/glyphs/spline\":307,\"core/util/interpolation\":308,\"models/glyphs/step\":309,\"models/glyphs/text\":310,\"models/glyphs/vbar\":311,\"models/glyphs/wedge\":312,\"models/graphs/index\":313,\"models/graphs/static_layout_provider\":314,\"models/grids/index\":315,\"models/grids/grid\":316,\"models/layouts/index\":317,\"models/layouts/box\":318,\"models/layouts/layout_dom\":319,\"models/layouts/column\":320,\"models/layouts/grid_box\":321,\"models/layouts/html_box\":322,\"models/layouts/panel\":323,\"models/layouts/row\":324,\"models/layouts/spacer\":325,\"models/layouts/tabs\":326,\"styles/tabs.css\":327,\"styles/buttons.css\":328,\"models/layouts/widget_box\":329,\"models/plots/index\":330,\"models/plots/gmap_plot\":331,\"models/plots/plot\":332,\"models/plots/plot_canvas\":333,\"core/util/throttle\":334,\"models/plots/range_manager\":335,\"models/plots/state_manager\":336,\"models/plots/gmap_plot_canvas\":337,\"models/policies/index\":338,\"models/renderers/index\":339,\"models/selections/index\":340,\"models/sources/index\":341,\"models/sources/server_sent_data_source\":342,\"models/sources/web_data_source\":343,\"models/sources/ajax_data_source\":344,\"models/sources/geojson_data_source\":345,\"models/tiles/index\":346,\"models/tiles/bbox_tile_source\":347,\"models/tiles/mercator_tile_source\":348,\"models/tiles/tile_source\":349,\"models/tiles/tile_utils\":350,\"models/tiles/quadkey_tile_source\":351,\"models/tiles/tile_renderer\":352,\"models/tiles/wmts_tile_source\":353,\"styles/tiles.css\":354,\"models/tiles/tms_tile_source\":355,\"models/textures/index\":356,\"models/textures/canvas_texture\":357,\"models/textures/texture\":358,\"models/textures/image_url_texture\":359,\"models/tools/index\":360,\"models/tools/actions/custom_action\":361,\"models/tools/actions/redo_tool\":362,\"models/tools/actions/reset_tool\":363,\"models/tools/actions/save_tool\":364,\"models/tools/actions/undo_tool\":365,\"models/tools/actions/zoom_in_tool\":366,\"models/tools/actions/zoom_base_tool\":367,\"core/util/zoom\":368,\"models/tools/actions/zoom_out_tool\":369,\"models/tools/edit/edit_tool\":370,\"models/tools/edit/box_edit_tool\":371,\"models/tools/edit/freehand_draw_tool\":372,\"models/tools/edit/point_draw_tool\":373,\"models/tools/edit/poly_draw_tool\":374,\"models/tools/edit/poly_tool\":375,\"models/tools/edit/poly_edit_tool\":376,\"models/tools/gestures/box_select_tool\":377,\"models/tools/gestures/select_tool\":378,\"models/tools/gestures/box_zoom_tool\":379,\"models/tools/gestures/lasso_select_tool\":380,\"models/tools/gestures/poly_select_tool\":381,\"models/tools/edit/line_edit_tool\":382,\"models/tools/edit/line_tool\":383,\"models/tools/gestures/pan_tool\":384,\"models/tools/gestures/range_tool\":385,\"models/tools/gestures/tap_tool\":386,\"models/tools/gestures/wheel_pan_tool\":387,\"models/tools/gestures/wheel_zoom_tool\":388,\"models/tools/inspectors/crosshair_tool\":389,\"models/tools/inspectors/customjs_hover\":390,\"models/tools/inspectors/hover_tool\":391,\"models/tools/tool_proxy\":392,\"models/tools/toolbar_box\":393,\"document/defs\":394,\"embed/standalone\":395,\"embed/dom\":396,\"embed/server\":397,\"client/connection\":398,\"protocol/message\":399,\"protocol/receiver\":400,\"client/session\":401,\"embed/notebook\":402,\"styles/notebook.css\":403,\"protocol/index\":404,\"testing\":405,\"safely\":406}, {});});\n", + "\n", + " /* END bokeh.min.js */\n", + " },\n", + " \n", + " function(Bokeh) {\n", + " /* BEGIN bokeh-widgets.min.js */\n", + " /*!\n", + " * Copyright (c) 2012 - 2021, Anaconda, Inc., and Bokeh Contributors\n", + " * All rights reserved.\n", + " * \n", + " * Redistribution and use in source and binary forms, with or without modification,\n", + " * are permitted provided that the following conditions are met:\n", + " * \n", + " * Redistributions of source code must retain the above copyright notice,\n", + " * this list of conditions and the following disclaimer.\n", + " * \n", + " * Redistributions in binary form must reproduce the above copyright notice,\n", + " * this list of conditions and the following disclaimer in the documentation\n", + " * and/or other materials provided with the distribution.\n", + " * \n", + " * Neither the name of Anaconda nor the names of any contributors\n", + " * may be used to endorse or promote products derived from this software\n", + " * without specific prior written permission.\n", + " * \n", + " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n", + " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n", + " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n", + " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n", + " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n", + " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n", + " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n", + " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n", + " * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n", + " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n", + " * THE POSSIBILITY OF SUCH DAMAGE.\n", + " */\n", + " (function(root, factory) {\n", + " factory(root[\"Bokeh\"], \"2.3.3\");\n", + " })(this, function(Bokeh, version) {\n", + " var define;\n", + " return (function(modules, entry, aliases, externals) {\n", + " const bokeh = typeof Bokeh !== \"undefined\" && (version != null ? Bokeh[version] : Bokeh);\n", + " if (bokeh != null) {\n", + " return bokeh.register_plugin(modules, entry, aliases);\n", + " } else {\n", + " throw new Error(\"Cannot find Bokeh \" + version + \". You have to load it prior to loading plugins.\");\n", + " }\n", + " })\n", + " ({\n", + " 417: function _(t,e,i,o,r){o();const s=t(1).__importStar(t(418));i.Widgets=s;t(7).register_models(s)},\n", + " 418: function _(t,e,o,r,u){r(),u(\"AbstractButton\",t(419).AbstractButton),u(\"AbstractIcon\",t(422).AbstractIcon),u(\"AutocompleteInput\",t(423).AutocompleteInput),u(\"Button\",t(428).Button),u(\"CheckboxButtonGroup\",t(429).CheckboxButtonGroup),u(\"CheckboxGroup\",t(431).CheckboxGroup),u(\"ColorPicker\",t(433).ColorPicker),u(\"DatePicker\",t(434).DatePicker),u(\"DateRangeSlider\",t(437).DateRangeSlider),u(\"DateSlider\",t(442).DateSlider),u(\"Div\",t(443).Div),u(\"Dropdown\",t(446).Dropdown),u(\"FileInput\",t(447).FileInput),u(\"InputWidget\",t(426).InputWidget),u(\"Markup\",t(444).Markup),u(\"MultiSelect\",t(448).MultiSelect),u(\"Paragraph\",t(449).Paragraph),u(\"PasswordInput\",t(450).PasswordInput),u(\"MultiChoice\",t(451).MultiChoice),u(\"NumericInput\",t(454).NumericInput),u(\"PreText\",t(455).PreText),u(\"RadioButtonGroup\",t(456).RadioButtonGroup),u(\"RadioGroup\",t(457).RadioGroup),u(\"RangeSlider\",t(458).RangeSlider),u(\"Select\",t(459).Select),u(\"Slider\",t(460).Slider),u(\"Spinner\",t(461).Spinner),u(\"TextInput\",t(424).TextInput),u(\"TextAreaInput\",t(462).TextAreaInput),u(\"Toggle\",t(463).Toggle),u(\"Widget\",t(488).Widget)},\n", + " 419: function _(t,e,n,i,s){i();const l=t(1),o=t(20),r=t(43),c=t(122),u=t(420),_=t(422),a=l.__importStar(t(328)),b=a;class d extends u.ControlView{*controls(){yield this.button_el}async lazy_initialize(){await super.lazy_initialize();const{icon:t}=this.model;null!=t&&(this.icon_view=await c.build_view(t,{parent:this}))}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.render()))}remove(){null!=this.icon_view&&this.icon_view.remove(),super.remove()}styles(){return[...super.styles(),a.default]}_render_button(...t){return r.button({type:\"button\",disabled:this.model.disabled,class:[b.btn,b[`btn_${this.model.button_type}`]]},...t)}render(){super.render(),this.button_el=this._render_button(this.model.label),this.button_el.addEventListener(\"click\",(()=>this.click())),null!=this.icon_view&&(\"\"!=this.model.label?r.prepend(this.button_el,this.icon_view.el,r.nbsp()):r.prepend(this.button_el,this.icon_view.el),this.icon_view.render()),this.group_el=r.div({class:b.btn_group},this.button_el),this.el.appendChild(this.group_el)}click(){}}n.AbstractButtonView=d,d.__name__=\"AbstractButtonView\";class h extends u.Control{constructor(t){super(t)}static init_AbstractButton(){this.define((({String:t,Ref:e,Nullable:n})=>({label:[t,\"Button\"],icon:[n(e(_.AbstractIcon)),null],button_type:[o.ButtonType,\"default\"]})))}}n.AbstractButton=h,h.__name__=\"AbstractButton\",h.init_AbstractButton()},\n", + " 420: function _(t,e,o,s,n){s();const i=t(488),l=t(43);class c extends i.WidgetView{connect_signals(){super.connect_signals();const t=this.model.properties;this.on_change(t.disabled,(()=>{for(const t of this.controls())l.toggle_attribute(t,\"disabled\",this.model.disabled)}))}}o.ControlView=c,c.__name__=\"ControlView\";class r extends i.Widget{constructor(t){super(t)}}o.Control=r,r.__name__=\"Control\"},\n", + " 488: function _(i,t,e,o,n){o();const s=i(322),r=i(20);class d extends s.HTMLBoxView{_width_policy(){return\"horizontal\"==this.model.orientation?super._width_policy():\"fixed\"}_height_policy(){return\"horizontal\"==this.model.orientation?\"fixed\":super._height_policy()}box_sizing(){const i=super.box_sizing();return\"horizontal\"==this.model.orientation?null==i.width&&(i.width=this.model.default_size):null==i.height&&(i.height=this.model.default_size),i}}e.WidgetView=d,d.__name__=\"WidgetView\";class _ extends s.HTMLBox{constructor(i){super(i)}static init_Widget(){this.define((({Number:i})=>({orientation:[r.Orientation,\"horizontal\"],default_size:[i,300]}))),this.override({margin:[5,5,5,5]})}}e.Widget=_,_.__name__=\"Widget\",_.init_Widget()},\n", + " 422: function _(c,t,s,n,e){n();const o=c(53),_=c(240);class a extends _.DOMView{}s.AbstractIconView=a,a.__name__=\"AbstractIconView\";class r extends o.Model{constructor(c){super(c)}}s.AbstractIcon=r,r.__name__=\"AbstractIcon\"},\n", + " 423: function _(e,t,n,i,s){i();const h=e(1),o=e(424),_=e(43),u=e(10),r=h.__importStar(e(243)),c=r;class l extends o.TextInputView{constructor(){super(...arguments),this._open=!1,this._last_value=\"\",this._hover_index=0}styles(){return[...super.styles(),r.default]}render(){super.render(),this.input_el.addEventListener(\"keydown\",(e=>this._keydown(e))),this.input_el.addEventListener(\"keyup\",(e=>this._keyup(e))),this.menu=_.div({class:[c.menu,c.below]}),this.menu.addEventListener(\"click\",(e=>this._menu_click(e))),this.menu.addEventListener(\"mouseover\",(e=>this._menu_hover(e))),this.el.appendChild(this.menu),_.undisplay(this.menu)}change_input(){this._open&&this.menu.children.length>0&&(this.model.value=this.menu.children[this._hover_index].textContent,this.input_el.focus(),this._hide_menu()),this.model.restrict||super.change_input()}_update_completions(e){_.empty(this.menu);for(const t of e){const e=_.div({},t);this.menu.appendChild(e)}e.length>0&&this.menu.children[0].classList.add(c.active)}_show_menu(){if(!this._open){this._open=!0,this._hover_index=0,this._last_value=this.model.value,_.display(this.menu);const e=t=>{const{target:n}=t;n instanceof HTMLElement&&!this.el.contains(n)&&(document.removeEventListener(\"click\",e),this._hide_menu())};document.addEventListener(\"click\",e)}}_hide_menu(){this._open&&(this._open=!1,_.undisplay(this.menu))}_menu_click(e){e.target!=e.currentTarget&&e.target instanceof Element&&(this.model.value=e.target.textContent,this.input_el.focus(),this._hide_menu())}_menu_hover(e){if(e.target!=e.currentTarget&&e.target instanceof Element){let t=0;for(t=0;t0&&(this.menu.children[this._hover_index].classList.remove(c.active),this._hover_index=u.clamp(e,0,t-1),this.menu.children[this._hover_index].classList.add(c.active))}_keydown(e){}_keyup(e){switch(e.keyCode){case _.Keys.Enter:this.change_input();break;case _.Keys.Esc:this._hide_menu();break;case _.Keys.Up:this._bump_hover(this._hover_index-1);break;case _.Keys.Down:this._bump_hover(this._hover_index+1);break;default:{const e=this.input_el.value;if(e.lengthe:e=>e.toLowerCase();for(const n of this.model.completions)i(n).startsWith(i(e))&&t.push(n);this._update_completions(t),0==t.length?this._hide_menu():this._show_menu()}}}}n.AutocompleteInputView=l,l.__name__=\"AutocompleteInputView\";class a extends o.TextInput{constructor(e){super(e)}static init_AutocompleteInput(){this.prototype.default_view=l,this.define((({Boolean:e,Int:t,String:n,Array:i})=>({completions:[i(n),[]],min_characters:[t,2],case_sensitive:[e,!0],restrict:[e,!0]})))}}n.AutocompleteInput=a,a.__name__=\"AutocompleteInput\",a.init_AutocompleteInput()},\n", + " 424: function _(t,e,n,i,p){i();const _=t(1),u=t(425),s=t(43),x=_.__importStar(t(427));class a extends u.TextLikeInputView{_render_input(){this.input_el=s.input({type:\"text\",class:x.input})}}n.TextInputView=a,a.__name__=\"TextInputView\";class c extends u.TextLikeInput{constructor(t){super(t)}static init_TextInput(){this.prototype.default_view=a}}n.TextInput=c,c.__name__=\"TextInput\",c.init_TextInput()},\n", + " 425: function _(e,t,n,i,l){i();const s=e(426);class h extends s.InputWidgetView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.name.change,(()=>{var e;return this.input_el.name=null!==(e=this.model.name)&&void 0!==e?e:\"\"})),this.connect(this.model.properties.value.change,(()=>this.input_el.value=this.model.value)),this.connect(this.model.properties.value_input.change,(()=>this.input_el.value=this.model.value_input)),this.connect(this.model.properties.disabled.change,(()=>this.input_el.disabled=this.model.disabled)),this.connect(this.model.properties.placeholder.change,(()=>this.input_el.placeholder=this.model.placeholder)),this.connect(this.model.properties.max_length.change,(()=>{const{max_length:e}=this.model;null!=e?this.input_el.maxLength=e:this.input_el.removeAttribute(\"maxLength\")}))}render(){var e;super.render(),this._render_input();const{input_el:t}=this;t.name=null!==(e=this.model.name)&&void 0!==e?e:\"\",t.value=this.model.value,t.disabled=this.model.disabled,t.placeholder=this.model.placeholder,null!=this.model.max_length&&(t.maxLength=this.model.max_length),t.addEventListener(\"change\",(()=>this.change_input())),t.addEventListener(\"input\",(()=>this.change_input_value())),this.group_el.appendChild(t)}change_input(){this.model.value=this.input_el.value,super.change_input()}change_input_value(){this.model.value_input=this.input_el.value,super.change_input()}}n.TextLikeInputView=h,h.__name__=\"TextLikeInputView\";class a extends s.InputWidget{constructor(e){super(e)}static init_TextLikeInput(){this.define((({Int:e,String:t,Nullable:n})=>({value:[t,\"\"],value_input:[t,\"\"],placeholder:[t,\"\"],max_length:[n(e),null]})))}}n.TextLikeInput=a,a.__name__=\"TextLikeInput\",a.init_TextLikeInput()},\n", + " 426: function _(t,e,i,n,s){n();const l=t(1),o=t(420),r=t(43),_=l.__importStar(t(427)),p=_;class d extends o.ControlView{*controls(){yield this.input_el}connect_signals(){super.connect_signals(),this.connect(this.model.properties.title.change,(()=>{this.label_el.textContent=this.model.title}))}styles(){return[...super.styles(),_.default]}render(){super.render();const{title:t}=this.model;this.label_el=r.label({style:{display:0==t.length?\"none\":\"\"}},t),this.group_el=r.div({class:p.input_group},this.label_el),this.el.appendChild(this.group_el)}change_input(){}}i.InputWidgetView=d,d.__name__=\"InputWidgetView\";class u extends o.Control{constructor(t){super(t)}static init_InputWidget(){this.define((({String:t})=>({title:[t,\"\"]})))}}i.InputWidget=u,u.__name__=\"InputWidget\",u.init_InputWidget()},\n", + " 427: function _(o,i,t,n,p){n(),t.root=\"bk-root\",t.input=\"bk-input\",t.input_group=\"bk-input-group\",t.inline=\"bk-inline\",t.spin_wrapper=\"bk-spin-wrapper\",t.spin_btn=\"bk-spin-btn\",t.spin_btn_up=\"bk-spin-btn-up\",t.spin_btn_down=\"bk-spin-btn-down\",t.default='.bk-root .bk-input{display:inline-block;width:100%;flex-grow:1;-webkit-flex-grow:1;min-height:31px;padding:0 12px;background-color:#fff;border:1px solid #ccc;border-radius:4px;}.bk-root .bk-input:focus{border-color:#66afe9;outline:0;box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(102, 175, 233, 0.6);}.bk-root .bk-input::placeholder,.bk-root .bk-input:-ms-input-placeholder,.bk-root .bk-input::-moz-placeholder,.bk-root .bk-input::-webkit-input-placeholder{color:#999;opacity:1;}.bk-root .bk-input[disabled]{cursor:not-allowed;background-color:#eee;opacity:1;}.bk-root select:not([multiple]).bk-input,.bk-root select:not([size]).bk-input{height:auto;appearance:none;-webkit-appearance:none;background-image:url(\\'data:image/svg+xml;utf8,\\');background-position:right 0.5em center;background-size:8px 6px;background-repeat:no-repeat;}.bk-root select[multiple].bk-input,.bk-root select[size].bk-input,.bk-root textarea.bk-input{height:auto;}.bk-root .bk-input-group{width:100%;height:100%;display:inline-flex;display:-webkit-inline-flex;flex-wrap:nowrap;-webkit-flex-wrap:nowrap;align-items:start;-webkit-align-items:start;flex-direction:column;-webkit-flex-direction:column;white-space:nowrap;}.bk-root .bk-input-group.bk-inline{flex-direction:row;-webkit-flex-direction:row;}.bk-root .bk-input-group.bk-inline > *:not(:first-child){margin-left:5px;}.bk-root .bk-input-group input[type=\"checkbox\"] + span,.bk-root .bk-input-group input[type=\"radio\"] + span{position:relative;top:-2px;margin-left:3px;}.bk-root .bk-input-group > .bk-spin-wrapper{display:inherit;width:inherit;height:inherit;position:relative;overflow:hidden;padding:0;vertical-align:middle;}.bk-root .bk-input-group > .bk-spin-wrapper input{padding-right:20px;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn{position:absolute;display:block;height:50%;min-height:0;min-width:0;width:30px;padding:0;margin:0;right:0;border:none;background:none;cursor:pointer;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn:before{content:\"\";display:inline-block;transform:translateY(-50%);border-left:5px solid transparent;border-right:5px solid transparent;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-up{top:0;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-up:before{border-bottom:5px solid black;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-up:disabled:before{border-bottom-color:grey;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-down{bottom:0;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-down:before{border-top:5px solid black;}.bk-root .bk-input-group > .bk-spin-wrapper > .bk-spin-btn.bk-spin-btn-down:disabled:before{border-top-color:grey;}'},\n", + " 428: function _(t,e,n,i,o){i();const s=t(419),u=t(264);class c extends s.AbstractButtonView{click(){this.model.trigger_event(new u.ButtonClick),super.click()}}n.ButtonView=c,c.__name__=\"ButtonView\";class _ extends s.AbstractButton{constructor(t){super(t)}static init_Button(){this.prototype.default_view=c,this.override({label:\"Button\"})}}n.Button=_,_.__name__=\"Button\",_.init_Button()},\n", + " 429: function _(t,e,o,i,c){i();const n=t(1),s=t(430),a=t(43),u=n.__importStar(t(328));class r extends s.ButtonGroupView{get active(){return new Set(this.model.active)}change_active(t){const{active:e}=this;e.has(t)?e.delete(t):e.add(t),this.model.active=[...e].sort()}_update_active(){const{active:t}=this;this._buttons.forEach(((e,o)=>{a.classes(e).toggle(u.active,t.has(o))}))}}o.CheckboxButtonGroupView=r,r.__name__=\"CheckboxButtonGroupView\";class _ extends s.ButtonGroup{constructor(t){super(t)}static init_CheckboxButtonGroup(){this.prototype.default_view=r,this.define((({Int:t,Array:e})=>({active:[e(t),[]]})))}}o.CheckboxButtonGroup=_,_.__name__=\"CheckboxButtonGroup\",_.init_CheckboxButtonGroup()},\n", + " 430: function _(t,e,n,s,i){s();const o=t(1),r=t(420),u=t(20),a=t(43),_=o.__importStar(t(328)),l=_;class c extends r.ControlView{*controls(){yield*this._buttons}connect_signals(){super.connect_signals();const t=this.model.properties;this.on_change(t.button_type,(()=>this.render())),this.on_change(t.labels,(()=>this.render())),this.on_change(t.active,(()=>this._update_active()))}styles(){return[...super.styles(),_.default]}render(){super.render(),this._buttons=this.model.labels.map(((t,e)=>{const n=a.div({class:[l.btn,l[`btn_${this.model.button_type}`]],disabled:this.model.disabled},t);return n.addEventListener(\"click\",(()=>this.change_active(e))),n})),this._update_active();const t=a.div({class:l.btn_group},this._buttons);this.el.appendChild(t)}}n.ButtonGroupView=c,c.__name__=\"ButtonGroupView\";class d extends r.Control{constructor(t){super(t)}static init_ButtonGroup(){this.define((({String:t,Array:e})=>({labels:[e(t),[]],button_type:[u.ButtonType,\"default\"]})))}}n.ButtonGroup=d,d.__name__=\"ButtonGroup\",d.init_ButtonGroup()},\n", + " 431: function _(e,t,i,n,s){n();const o=e(1),c=e(432),a=e(43),l=e(9),d=o.__importStar(e(427));class h extends c.InputGroupView{render(){super.render();const e=a.div({class:[d.input_group,this.model.inline?d.inline:null]});this.el.appendChild(e);const{active:t,labels:i}=this.model;this._inputs=[];for(let n=0;nthis.change_active(n))),this._inputs.push(s),this.model.disabled&&(s.disabled=!0),l.includes(t,n)&&(s.checked=!0);const o=a.label({},s,a.span({},i[n]));e.appendChild(o)}}change_active(e){const t=new Set(this.model.active);t.has(e)?t.delete(e):t.add(e),this.model.active=[...t].sort()}}i.CheckboxGroupView=h,h.__name__=\"CheckboxGroupView\";class p extends c.InputGroup{constructor(e){super(e)}static init_CheckboxGroup(){this.prototype.default_view=h,this.define((({Boolean:e,Int:t,String:i,Array:n})=>({active:[n(t),[]],labels:[n(i),[]],inline:[e,!1]})))}}i.CheckboxGroup=p,p.__name__=\"CheckboxGroup\",p.init_CheckboxGroup()},\n", + " 432: function _(n,t,e,s,o){s();const r=n(1),u=n(420),c=r.__importDefault(n(427));class _ extends u.ControlView{*controls(){yield*this._inputs}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.render()))}styles(){return[...super.styles(),c.default]}}e.InputGroupView=_,_.__name__=\"InputGroupView\";class i extends u.Control{constructor(n){super(n)}}e.InputGroup=i,i.__name__=\"InputGroup\"},\n", + " 433: function _(e,i,t,n,o){n();const s=e(1),l=e(426),r=e(43),c=e(22),a=s.__importStar(e(427));class d extends l.InputWidgetView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.name.change,(()=>{var e;return this.input_el.name=null!==(e=this.model.name)&&void 0!==e?e:\"\"})),this.connect(this.model.properties.color.change,(()=>this.input_el.value=c.color2hexrgb(this.model.color))),this.connect(this.model.properties.disabled.change,(()=>this.input_el.disabled=this.model.disabled))}render(){super.render(),this.input_el=r.input({type:\"color\",class:a.input,name:this.model.name,value:this.model.color,disabled:this.model.disabled}),this.input_el.addEventListener(\"change\",(()=>this.change_input())),this.group_el.appendChild(this.input_el)}change_input(){this.model.color=this.input_el.value,super.change_input()}}t.ColorPickerView=d,d.__name__=\"ColorPickerView\";class h extends l.InputWidget{constructor(e){super(e)}static init_ColorPicker(){this.prototype.default_view=d,this.define((({Color:e})=>({color:[e,\"#000000\"]})))}}t.ColorPicker=h,h.__name__=\"ColorPicker\",h.init_ColorPicker()},\n", + " 434: function _(e,t,i,n,s){n();const a=e(1),l=a.__importDefault(e(435)),o=e(426),d=e(43),r=e(20),c=e(8),h=a.__importStar(e(427)),u=a.__importDefault(e(436));function _(e){const t=[];for(const i of e)if(c.isString(i))t.push(i);else{const[e,n]=i;t.push({from:e,to:n})}return t}class p extends o.InputWidgetView{connect_signals(){super.connect_signals();const{value:e,min_date:t,max_date:i,disabled_dates:n,enabled_dates:s,position:a,inline:l}=this.model.properties;this.connect(e.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.setDate(this.model.value)})),this.connect(t.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"minDate\",this.model.min_date)})),this.connect(i.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"maxDate\",this.model.max_date)})),this.connect(n.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"disable\",this.model.disabled_dates)})),this.connect(s.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"enable\",this.model.enabled_dates)})),this.connect(a.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"position\",this.model.position)})),this.connect(l.change,(()=>{var e;return null===(e=this._picker)||void 0===e?void 0:e.set(\"inline\",this.model.inline)}))}remove(){var e;null===(e=this._picker)||void 0===e||e.destroy(),super.remove()}styles(){return[...super.styles(),u.default]}render(){var e,t;null==this._picker&&(super.render(),this.input_el=d.input({type:\"text\",class:h.input,disabled:this.model.disabled}),this.group_el.appendChild(this.input_el),this._picker=l.default(this.input_el,{defaultDate:this.model.value,minDate:null!==(e=this.model.min_date)&&void 0!==e?e:void 0,maxDate:null!==(t=this.model.max_date)&&void 0!==t?t:void 0,inline:this.model.inline,position:this.model.position,disable:_(this.model.disabled_dates),enable:_(this.model.enabled_dates),onChange:(e,t,i)=>this._on_change(e,t,i)}))}_on_change(e,t,i){this.model.value=t,this.change_input()}}i.DatePickerView=p,p.__name__=\"DatePickerView\";class m extends o.InputWidget{constructor(e){super(e)}static init_DatePicker(){this.prototype.default_view=p,this.define((({Boolean:e,String:t,Array:i,Tuple:n,Or:s,Nullable:a})=>{const l=i(s(t,n(t,t)));return{value:[t],min_date:[a(t),null],max_date:[a(t),null],disabled_dates:[l,[]],enabled_dates:[l,[]],position:[r.CalendarPosition,\"auto\"],inline:[e,!1]}}))}}i.DatePicker=m,m.__name__=\"DatePicker\",m.init_DatePicker()},\n", + " 435: function _(e,n,t,a,i){\n", + " /* flatpickr v4.6.6, @license MIT */var o,r;o=this,r=function(){\"use strict\";\n", + " /*! *****************************************************************************\n", + " Copyright (c) Microsoft Corporation.\n", + " \n", + " Permission to use, copy, modify, and/or distribute this software for any\n", + " purpose with or without fee is hereby granted.\n", + " \n", + " THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n", + " REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n", + " AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n", + " INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n", + " LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n", + " OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n", + " PERFORMANCE OF THIS SOFTWARE.\n", + " ***************************************************************************** */var e=function(){return(e=Object.assign||function(e){for(var n,t=1,a=arguments.length;t\",noCalendar:!1,now:new Date,onChange:[],onClose:[],onDayCreate:[],onDestroy:[],onKeyDown:[],onMonthChange:[],onOpen:[],onParseConfig:[],onReady:[],onValueUpdate:[],onYearChange:[],onPreCalendarPosition:[],plugins:[],position:\"auto\",positionElement:void 0,prevArrow:\"\",shorthandCurrentMonth:!1,showMonths:1,static:!1,time_24hr:!1,weekNumbers:!1,wrap:!1},i={weekdays:{shorthand:[\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"],longhand:[\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]},months:{shorthand:[\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\"],longhand:[\"January\",\"February\",\"March\",\"April\",\"May\",\"June\",\"July\",\"August\",\"September\",\"October\",\"November\",\"December\"]},daysInMonth:[31,28,31,30,31,30,31,31,30,31,30,31],firstDayOfWeek:0,ordinal:function(e){var n=e%100;if(n>3&&n<21)return\"th\";switch(n%10){case 1:return\"st\";case 2:return\"nd\";case 3:return\"rd\";default:return\"th\"}},rangeSeparator:\" to \",weekAbbreviation:\"Wk\",scrollTitle:\"Scroll to increment\",toggleTitle:\"Click to toggle\",amPM:[\"AM\",\"PM\"],yearAriaLabel:\"Year\",monthAriaLabel:\"Month\",hourAriaLabel:\"Hour\",minuteAriaLabel:\"Minute\",time_24hr:!1},o=function(e,n){return void 0===n&&(n=2),(\"000\"+e).slice(-1*n)},r=function(e){return!0===e?1:0};function l(e,n,t){var a;return void 0===t&&(t=!1),function(){var i=this,o=arguments;null!==a&&clearTimeout(a),a=window.setTimeout((function(){a=null,t||e.apply(i,o)}),n),t&&!a&&e.apply(i,o)}}var c=function(e){return e instanceof Array?e:[e]};function d(e,n,t){if(!0===t)return e.classList.add(n);e.classList.remove(n)}function s(e,n,t){var a=window.document.createElement(e);return n=n||\"\",t=t||\"\",a.className=n,void 0!==t&&(a.textContent=t),a}function u(e){for(;e.firstChild;)e.removeChild(e.firstChild)}function f(e,n){return n(e)?e:e.parentNode?f(e.parentNode,n):void 0}function m(e,n){var t=s(\"div\",\"numInputWrapper\"),a=s(\"input\",\"numInput \"+e),i=s(\"span\",\"arrowUp\"),o=s(\"span\",\"arrowDown\");if(-1===navigator.userAgent.indexOf(\"MSIE 9.0\")?a.type=\"number\":(a.type=\"text\",a.pattern=\"\\\\d*\"),void 0!==n)for(var r in n)a.setAttribute(r,n[r]);return t.appendChild(a),t.appendChild(i),t.appendChild(o),t}function g(e){try{return\"function\"==typeof e.composedPath?e.composedPath()[0]:e.target}catch(n){return e.target}}var p=function(){},h=function(e,n,t){return t.months[n?\"shorthand\":\"longhand\"][e]},v={D:p,F:function(e,n,t){e.setMonth(t.months.longhand.indexOf(n))},G:function(e,n){e.setHours(parseFloat(n))},H:function(e,n){e.setHours(parseFloat(n))},J:function(e,n){e.setDate(parseFloat(n))},K:function(e,n,t){e.setHours(e.getHours()%12+12*r(new RegExp(t.amPM[1],\"i\").test(n)))},M:function(e,n,t){e.setMonth(t.months.shorthand.indexOf(n))},S:function(e,n){e.setSeconds(parseFloat(n))},U:function(e,n){return new Date(1e3*parseFloat(n))},W:function(e,n,t){var a=parseInt(n),i=new Date(e.getFullYear(),0,2+7*(a-1),0,0,0,0);return i.setDate(i.getDate()-i.getDay()+t.firstDayOfWeek),i},Y:function(e,n){e.setFullYear(parseFloat(n))},Z:function(e,n){return new Date(n)},d:function(e,n){e.setDate(parseFloat(n))},h:function(e,n){e.setHours(parseFloat(n))},i:function(e,n){e.setMinutes(parseFloat(n))},j:function(e,n){e.setDate(parseFloat(n))},l:p,m:function(e,n){e.setMonth(parseFloat(n)-1)},n:function(e,n){e.setMonth(parseFloat(n)-1)},s:function(e,n){e.setSeconds(parseFloat(n))},u:function(e,n){return new Date(parseFloat(n))},w:p,y:function(e,n){e.setFullYear(2e3+parseFloat(n))}},D={D:\"(\\\\w+)\",F:\"(\\\\w+)\",G:\"(\\\\d\\\\d|\\\\d)\",H:\"(\\\\d\\\\d|\\\\d)\",J:\"(\\\\d\\\\d|\\\\d)\\\\w+\",K:\"\",M:\"(\\\\w+)\",S:\"(\\\\d\\\\d|\\\\d)\",U:\"(.+)\",W:\"(\\\\d\\\\d|\\\\d)\",Y:\"(\\\\d{4})\",Z:\"(.+)\",d:\"(\\\\d\\\\d|\\\\d)\",h:\"(\\\\d\\\\d|\\\\d)\",i:\"(\\\\d\\\\d|\\\\d)\",j:\"(\\\\d\\\\d|\\\\d)\",l:\"(\\\\w+)\",m:\"(\\\\d\\\\d|\\\\d)\",n:\"(\\\\d\\\\d|\\\\d)\",s:\"(\\\\d\\\\d|\\\\d)\",u:\"(.+)\",w:\"(\\\\d\\\\d|\\\\d)\",y:\"(\\\\d{2})\"},w={Z:function(e){return e.toISOString()},D:function(e,n,t){return n.weekdays.shorthand[w.w(e,n,t)]},F:function(e,n,t){return h(w.n(e,n,t)-1,!1,n)},G:function(e,n,t){return o(w.h(e,n,t))},H:function(e){return o(e.getHours())},J:function(e,n){return void 0!==n.ordinal?e.getDate()+n.ordinal(e.getDate()):e.getDate()},K:function(e,n){return n.amPM[r(e.getHours()>11)]},M:function(e,n){return h(e.getMonth(),!0,n)},S:function(e){return o(e.getSeconds())},U:function(e){return e.getTime()/1e3},W:function(e,n,t){return t.getWeek(e)},Y:function(e){return o(e.getFullYear(),4)},d:function(e){return o(e.getDate())},h:function(e){return e.getHours()%12?e.getHours()%12:12},i:function(e){return o(e.getMinutes())},j:function(e){return e.getDate()},l:function(e,n){return n.weekdays.longhand[e.getDay()]},m:function(e){return o(e.getMonth()+1)},n:function(e){return e.getMonth()+1},s:function(e){return e.getSeconds()},u:function(e){return e.getTime()},w:function(e){return e.getDay()},y:function(e){return String(e.getFullYear()).substring(2)}},b=function(e){var n=e.config,t=void 0===n?a:n,o=e.l10n,r=void 0===o?i:o,l=e.isMobile,c=void 0!==l&&l;return function(e,n,a){var i=a||r;return void 0===t.formatDate||c?n.split(\"\").map((function(n,a,o){return w[n]&&\"\\\\\"!==o[a-1]?w[n](e,i,t):\"\\\\\"!==n?n:\"\"})).join(\"\"):t.formatDate(e,n,i)}},C=function(e){var n=e.config,t=void 0===n?a:n,o=e.l10n,r=void 0===o?i:o;return function(e,n,i,o){if(0===e||e){var l,c=o||r,d=e;if(e instanceof Date)l=new Date(e.getTime());else if(\"string\"!=typeof e&&void 0!==e.toFixed)l=new Date(e);else if(\"string\"==typeof e){var s=n||(t||a).dateFormat,u=String(e).trim();if(\"today\"===u)l=new Date,i=!0;else if(/Z$/.test(u)||/GMT$/.test(u))l=new Date(e);else if(t&&t.parseDate)l=t.parseDate(e,s);else{l=t&&t.noCalendar?new Date((new Date).setHours(0,0,0,0)):new Date((new Date).getFullYear(),0,1,0,0,0,0);for(var f=void 0,m=[],g=0,p=0,h=\"\";gl&&(u=a===w.hourElement?u-l-r(!w.amPM):i,m&&H(void 0,1,w.hourElement)),w.amPM&&f&&(1===c?u+d===23:Math.abs(u-d)>c)&&(w.amPM.textContent=w.l10n.amPM[r(w.amPM.textContent===w.l10n.amPM[0])]),a.value=o(u)}}(e);var c=w._input.value;I(),be(),w._input.value!==c&&w._debouncedChange()}function I(){if(void 0!==w.hourElement&&void 0!==w.minuteElement){var e,n,t=(parseInt(w.hourElement.value.slice(-2),10)||0)%24,a=(parseInt(w.minuteElement.value,10)||0)%60,i=void 0!==w.secondElement?(parseInt(w.secondElement.value,10)||0)%60:0;void 0!==w.amPM&&(e=t,n=w.amPM.textContent,t=e%12+12*r(n===w.l10n.amPM[1]));var o=void 0!==w.config.minTime||w.config.minDate&&w.minDateHasTime&&w.latestSelectedDateObj&&0===M(w.latestSelectedDateObj,w.config.minDate,!0);if(void 0!==w.config.maxTime||w.config.maxDate&&w.maxDateHasTime&&w.latestSelectedDateObj&&0===M(w.latestSelectedDateObj,w.config.maxDate,!0)){var l=void 0!==w.config.maxTime?w.config.maxTime:w.config.maxDate;(t=Math.min(t,l.getHours()))===l.getHours()&&(a=Math.min(a,l.getMinutes())),a===l.getMinutes()&&(i=Math.min(i,l.getSeconds()))}if(o){var c=void 0!==w.config.minTime?w.config.minTime:w.config.minDate;(t=Math.max(t,c.getHours()))===c.getHours()&&(a=Math.max(a,c.getMinutes())),a===c.getMinutes()&&(i=Math.max(i,c.getSeconds()))}O(t,a,i)}}function S(e){var n=e||w.latestSelectedDateObj;n&&O(n.getHours(),n.getMinutes(),n.getSeconds())}function _(){var e=w.config.defaultHour,n=w.config.defaultMinute,t=w.config.defaultSeconds;if(void 0!==w.config.minDate){var a=w.config.minDate.getHours(),i=w.config.minDate.getMinutes();(e=Math.max(e,a))===a&&(n=Math.max(i,n)),e===a&&n===i&&(t=w.config.minDate.getSeconds())}if(void 0!==w.config.maxDate){var o=w.config.maxDate.getHours(),r=w.config.maxDate.getMinutes();(e=Math.min(e,o))===o&&(n=Math.min(r,n)),e===o&&n===r&&(t=w.config.maxDate.getSeconds())}return{hours:e,minutes:n,seconds:t}}function O(e,n,t){void 0!==w.latestSelectedDateObj&&w.latestSelectedDateObj.setHours(e%24,n,t||0,0),w.hourElement&&w.minuteElement&&!w.isMobile&&(w.hourElement.value=o(w.config.time_24hr?e:(12+e)%12+12*r(e%12==0)),w.minuteElement.value=o(n),void 0!==w.amPM&&(w.amPM.textContent=w.l10n.amPM[r(e>=12)]),void 0!==w.secondElement&&(w.secondElement.value=o(t)))}function F(e){var n=g(e),t=parseInt(n.value)+(e.delta||0);(t/1e3>1||\"Enter\"===e.key&&!/[^\\d]/.test(t.toString()))&&Q(t)}function N(e,n,t,a){return n instanceof Array?n.forEach((function(n){return N(e,n,t,a)})):e instanceof Array?e.forEach((function(e){return N(e,n,t,a)})):(e.addEventListener(n,t,a),void w._handlers.push({element:e,event:n,handler:t,options:a}))}function A(){pe(\"onChange\")}function P(e,n){var t=void 0!==e?w.parseDate(e):w.latestSelectedDateObj||(w.config.minDate&&w.config.minDate>w.now?w.config.minDate:w.config.maxDate&&w.config.maxDate=0&&M(e,w.selectedDates[1])<=0}(n)&&!ve(n)&&o.classList.add(\"inRange\"),w.weekNumbers&&1===w.config.showMonths&&\"prevMonthDay\"!==e&&t%7==1&&w.weekNumbers.insertAdjacentHTML(\"beforeend\",\"\"+w.config.getWeek(n)+\"\"),pe(\"onDayCreate\",o),o}function L(e){e.focus(),\"range\"===w.config.mode&&ae(e)}function W(e){for(var n=e>0?0:w.config.showMonths-1,t=e>0?w.config.showMonths:-1,a=n;a!=t;a+=e)for(var i=w.daysContainer.children[a],o=e>0?0:i.children.length-1,r=e>0?i.children.length:-1,l=o;l!=r;l+=e){var c=i.children[l];if(-1===c.className.indexOf(\"hidden\")&&X(c.dateObj))return c}}function R(e,n){var t=ee(document.activeElement||document.body),a=void 0!==e?e:t?document.activeElement:void 0!==w.selectedDateElem&&ee(w.selectedDateElem)?w.selectedDateElem:void 0!==w.todayDateElem&&ee(w.todayDateElem)?w.todayDateElem:W(n>0?1:-1);void 0===a?w._input.focus():t?function(e,n){for(var t=-1===e.className.indexOf(\"Month\")?e.dateObj.getMonth():w.currentMonth,a=n>0?w.config.showMonths:-1,i=n>0?1:-1,o=t-w.currentMonth;o!=a;o+=i)for(var r=w.daysContainer.children[o],l=t-w.currentMonth===o?e.$i+n:n<0?r.children.length-1:0,c=r.children.length,d=l;d>=0&&d0?c:-1);d+=i){var s=r.children[d];if(-1===s.className.indexOf(\"hidden\")&&X(s.dateObj)&&Math.abs(e.$i-d)>=Math.abs(n))return L(s)}w.changeMonth(i),R(W(i),0)}(a,n):L(a)}function B(e,n){for(var t=(new Date(e,n,1).getDay()-w.l10n.firstDayOfWeek+7)%7,a=w.utils.getDaysInMonth((n-1+12)%12,e),i=w.utils.getDaysInMonth(n,e),o=window.document.createDocumentFragment(),r=w.config.showMonths>1,l=r?\"prevMonthDay hidden\":\"prevMonthDay\",c=r?\"nextMonthDay hidden\":\"nextMonthDay\",d=a+1-t,u=0;d<=a;d++,u++)o.appendChild(j(l,new Date(e,n-1,d),d,u));for(d=1;d<=i;d++,u++)o.appendChild(j(\"\",new Date(e,n,d),d,u));for(var f=i+1;f<=42-t&&(1===w.config.showMonths||u%7!=0);f++,u++)o.appendChild(j(c,new Date(e,n+1,f%i),f,u));var m=s(\"div\",\"dayContainer\");return m.appendChild(o),m}function J(){if(void 0!==w.daysContainer){u(w.daysContainer),w.weekNumbers&&u(w.weekNumbers);for(var e=document.createDocumentFragment(),n=0;n1||\"dropdown\"!==w.config.monthSelectorType)){var e=function(e){return!(void 0!==w.config.minDate&&w.currentYear===w.config.minDate.getFullYear()&&ew.config.maxDate.getMonth())};w.monthsDropdownContainer.tabIndex=-1,w.monthsDropdownContainer.innerHTML=\"\";for(var n=0;n<12;n++)if(e(n)){var t=s(\"option\",\"flatpickr-monthDropdown-month\");t.value=new Date(w.currentYear,n).getMonth().toString(),t.textContent=h(n,w.config.shorthandCurrentMonth,w.l10n),t.tabIndex=-1,w.currentMonth===n&&(t.selected=!0),w.monthsDropdownContainer.appendChild(t)}}}function U(){var e,n=s(\"div\",\"flatpickr-month\"),t=window.document.createDocumentFragment();w.config.showMonths>1||\"static\"===w.config.monthSelectorType?e=s(\"span\",\"cur-month\"):(w.monthsDropdownContainer=s(\"select\",\"flatpickr-monthDropdown-months\"),w.monthsDropdownContainer.setAttribute(\"aria-label\",w.l10n.monthAriaLabel),N(w.monthsDropdownContainer,\"change\",(function(e){var n=g(e),t=parseInt(n.value,10);w.changeMonth(t-w.currentMonth),pe(\"onMonthChange\")})),K(),e=w.monthsDropdownContainer);var a=m(\"cur-year\",{tabindex:\"-1\"}),i=a.getElementsByTagName(\"input\")[0];i.setAttribute(\"aria-label\",w.l10n.yearAriaLabel),w.config.minDate&&i.setAttribute(\"min\",w.config.minDate.getFullYear().toString()),w.config.maxDate&&(i.setAttribute(\"max\",w.config.maxDate.getFullYear().toString()),i.disabled=!!w.config.minDate&&w.config.minDate.getFullYear()===w.config.maxDate.getFullYear());var o=s(\"div\",\"flatpickr-current-month\");return o.appendChild(e),o.appendChild(a),t.appendChild(o),n.appendChild(t),{container:n,yearElement:i,monthElement:e}}function q(){u(w.monthNav),w.monthNav.appendChild(w.prevMonthNav),w.config.showMonths&&(w.yearElements=[],w.monthElements=[]);for(var e=w.config.showMonths;e--;){var n=U();w.yearElements.push(n.yearElement),w.monthElements.push(n.monthElement),w.monthNav.appendChild(n.container)}w.monthNav.appendChild(w.nextMonthNav)}function $(){w.weekdayContainer?u(w.weekdayContainer):w.weekdayContainer=s(\"div\",\"flatpickr-weekdays\");for(var e=w.config.showMonths;e--;){var n=s(\"div\",\"flatpickr-weekdaycontainer\");w.weekdayContainer.appendChild(n)}return z(),w.weekdayContainer}function z(){if(w.weekdayContainer){var e=w.l10n.firstDayOfWeek,t=n(w.l10n.weekdays.shorthand);e>0&&e\\n \"+t.join(\"\")+\"\\n \\n \"}}function G(e,n){void 0===n&&(n=!0);var t=n?e:e-w.currentMonth;t<0&&!0===w._hidePrevMonthArrow||t>0&&!0===w._hideNextMonthArrow||(w.currentMonth+=t,(w.currentMonth<0||w.currentMonth>11)&&(w.currentYear+=w.currentMonth>11?1:-1,w.currentMonth=(w.currentMonth+12)%12,pe(\"onYearChange\"),K()),J(),pe(\"onMonthChange\"),De())}function V(e){return!(!w.config.appendTo||!w.config.appendTo.contains(e))||w.calendarContainer.contains(e)}function Z(e){if(w.isOpen&&!w.config.inline){var n=g(e),t=V(n),a=n===w.input||n===w.altInput||w.element.contains(n)||e.path&&e.path.indexOf&&(~e.path.indexOf(w.input)||~e.path.indexOf(w.altInput)),i=\"blur\"===e.type?a&&e.relatedTarget&&!V(e.relatedTarget):!a&&!t&&!V(e.relatedTarget),o=!w.config.ignoredFocusElements.some((function(e){return e.contains(n)}));i&&o&&(void 0!==w.timeContainer&&void 0!==w.minuteElement&&void 0!==w.hourElement&&\"\"!==w.input.value&&void 0!==w.input.value&&T(),w.close(),w.config&&\"range\"===w.config.mode&&1===w.selectedDates.length&&(w.clear(!1),w.redraw()))}}function Q(e){if(!(!e||w.config.minDate&&ew.config.maxDate.getFullYear())){var n=e,t=w.currentYear!==n;w.currentYear=n||w.currentYear,w.config.maxDate&&w.currentYear===w.config.maxDate.getFullYear()?w.currentMonth=Math.min(w.config.maxDate.getMonth(),w.currentMonth):w.config.minDate&&w.currentYear===w.config.minDate.getFullYear()&&(w.currentMonth=Math.max(w.config.minDate.getMonth(),w.currentMonth)),t&&(w.redraw(),pe(\"onYearChange\"),K())}}function X(e,n){void 0===n&&(n=!0);var t=w.parseDate(e,void 0,n);if(w.config.minDate&&t&&M(t,w.config.minDate,void 0!==n?n:!w.minDateHasTime)<0||w.config.maxDate&&t&&M(t,w.config.maxDate,void 0!==n?n:!w.maxDateHasTime)>0)return!1;if(0===w.config.enable.length&&0===w.config.disable.length)return!0;if(void 0===t)return!1;for(var a=w.config.enable.length>0,i=a?w.config.enable:w.config.disable,o=0,r=void 0;o=r.from.getTime()&&t.getTime()<=r.to.getTime())return a}return!a}function ee(e){return void 0!==w.daysContainer&&-1===e.className.indexOf(\"hidden\")&&-1===e.className.indexOf(\"flatpickr-disabled\")&&w.daysContainer.contains(e)}function ne(e){e.target!==w._input||e.relatedTarget&&V(e.relatedTarget)||w.setDate(w._input.value,!0,e.target===w.altInput?w.config.altFormat:w.config.dateFormat)}function te(e){var n=g(e),t=w.config.wrap?p.contains(n):n===w._input,a=w.config.allowInput,i=w.isOpen&&(!a||!t),o=w.config.inline&&t&&!a;if(13===e.keyCode&&t){if(a)return w.setDate(w._input.value,!0,n===w.altInput?w.config.altFormat:w.config.dateFormat),n.blur();w.open()}else if(V(n)||i||o){var r=!!w.timeContainer&&w.timeContainer.contains(n);switch(e.keyCode){case 13:r?(e.preventDefault(),T(),se()):ue(e);break;case 27:e.preventDefault(),se();break;case 8:case 46:t&&!w.config.allowInput&&(e.preventDefault(),w.clear());break;case 37:case 39:if(r||t)w.hourElement&&w.hourElement.focus();else if(e.preventDefault(),void 0!==w.daysContainer&&(!1===a||document.activeElement&&ee(document.activeElement))){var l=39===e.keyCode?1:-1;e.ctrlKey?(e.stopPropagation(),G(l),R(W(1),0)):R(void 0,l)}break;case 38:case 40:e.preventDefault();var c=40===e.keyCode?1:-1;w.daysContainer&&void 0!==n.$i||n===w.input||n===w.altInput?e.ctrlKey?(e.stopPropagation(),Q(w.currentYear-c),R(W(1),0)):r||R(void 0,7*c):n===w.currentYearElement?Q(w.currentYear-c):w.config.enableTime&&(!r&&w.hourElement&&w.hourElement.focus(),T(e),w._debouncedChange());break;case 9:if(r){var d=[w.hourElement,w.minuteElement,w.secondElement,w.amPM].concat(w.pluginElements).filter((function(e){return e})),s=d.indexOf(n);if(-1!==s){var u=d[s+(e.shiftKey?-1:1)];e.preventDefault(),(u||w._input).focus()}}else!w.config.noCalendar&&w.daysContainer&&w.daysContainer.contains(n)&&e.shiftKey&&(e.preventDefault(),w._input.focus())}}if(void 0!==w.amPM&&n===w.amPM)switch(e.key){case w.l10n.amPM[0].charAt(0):case w.l10n.amPM[0].charAt(0).toLowerCase():w.amPM.textContent=w.l10n.amPM[0],I(),be();break;case w.l10n.amPM[1].charAt(0):case w.l10n.amPM[1].charAt(0).toLowerCase():w.amPM.textContent=w.l10n.amPM[1],I(),be()}(t||V(n))&&pe(\"onKeyDown\",e)}function ae(e){if(1===w.selectedDates.length&&(!e||e.classList.contains(\"flatpickr-day\")&&!e.classList.contains(\"flatpickr-disabled\"))){for(var n=e?e.dateObj.getTime():w.days.firstElementChild.dateObj.getTime(),t=w.parseDate(w.selectedDates[0],void 0,!0).getTime(),a=Math.min(n,w.selectedDates[0].getTime()),i=Math.max(n,w.selectedDates[0].getTime()),o=!1,r=0,l=0,c=a;ca&&cr)?r=c:c>t&&(!l||c0&&m0&&m>l;return g?(f.classList.add(\"notAllowed\"),[\"inRange\",\"startRange\",\"endRange\"].forEach((function(e){f.classList.remove(e)})),\"continue\"):o&&!g?\"continue\":([\"startRange\",\"inRange\",\"endRange\",\"notAllowed\"].forEach((function(e){f.classList.remove(e)})),void(void 0!==e&&(e.classList.add(n<=w.selectedDates[0].getTime()?\"startRange\":\"endRange\"),tn&&m===t&&f.classList.add(\"endRange\"),m>=r&&(0===l||m<=l)&&(d=t,u=n,(c=m)>Math.min(d,u)&&c0||t.getMinutes()>0||t.getSeconds()>0),w.selectedDates&&(w.selectedDates=w.selectedDates.filter((function(e){return X(e)})),w.selectedDates.length||\"min\"!==e||S(t),be()),w.daysContainer&&(de(),void 0!==t?w.currentYearElement[e]=t.getFullYear().toString():w.currentYearElement.removeAttribute(e),w.currentYearElement.disabled=!!a&&void 0!==t&&a.getFullYear()===t.getFullYear())}}function re(){return w.config.wrap?p.querySelector(\"[data-input]\"):p}function le(){\"object\"!=typeof w.config.locale&&void 0===k.l10ns[w.config.locale]&&w.config.errorHandler(new Error(\"flatpickr: invalid locale \"+w.config.locale)),w.l10n=e(e({},k.l10ns.default),\"object\"==typeof w.config.locale?w.config.locale:\"default\"!==w.config.locale?k.l10ns[w.config.locale]:void 0),D.K=\"(\"+w.l10n.amPM[0]+\"|\"+w.l10n.amPM[1]+\"|\"+w.l10n.amPM[0].toLowerCase()+\"|\"+w.l10n.amPM[1].toLowerCase()+\")\",void 0===e(e({},v),JSON.parse(JSON.stringify(p.dataset||{}))).time_24hr&&void 0===k.defaultConfig.time_24hr&&(w.config.time_24hr=w.l10n.time_24hr),w.formatDate=b(w),w.parseDate=C({config:w.config,l10n:w.l10n})}function ce(e){if(void 0!==w.calendarContainer){pe(\"onPreCalendarPosition\");var n=e||w._positionElement,t=Array.prototype.reduce.call(w.calendarContainer.children,(function(e,n){return e+n.offsetHeight}),0),a=w.calendarContainer.offsetWidth,i=w.config.position.split(\" \"),o=i[0],r=i.length>1?i[1]:null,l=n.getBoundingClientRect(),c=window.innerHeight-l.bottom,s=\"above\"===o||\"below\"!==o&&ct,u=window.pageYOffset+l.top+(s?-t-2:n.offsetHeight+2);if(d(w.calendarContainer,\"arrowTop\",!s),d(w.calendarContainer,\"arrowBottom\",s),!w.config.inline){var f=window.pageXOffset+l.left,m=!1,g=!1;\"center\"===r?(f-=(a-l.width)/2,m=!0):\"right\"===r&&(f-=a-l.width,g=!0),d(w.calendarContainer,\"arrowLeft\",!m&&!g),d(w.calendarContainer,\"arrowCenter\",m),d(w.calendarContainer,\"arrowRight\",g);var p=window.document.body.offsetWidth-(window.pageXOffset+l.right),h=f+a>window.document.body.offsetWidth,v=p+a>window.document.body.offsetWidth;if(d(w.calendarContainer,\"rightMost\",h),!w.config.static)if(w.calendarContainer.style.top=u+\"px\",h)if(v){var D=function(){for(var e=null,n=0;nw.currentMonth+w.config.showMonths-1)&&\"range\"!==w.config.mode;if(w.selectedDateElem=t,\"single\"===w.config.mode)w.selectedDates=[a];else if(\"multiple\"===w.config.mode){var o=ve(a);o?w.selectedDates.splice(parseInt(o),1):w.selectedDates.push(a)}else\"range\"===w.config.mode&&(2===w.selectedDates.length&&w.clear(!1,!1),w.latestSelectedDateObj=a,w.selectedDates.push(a),0!==M(a,w.selectedDates[0],!0)&&w.selectedDates.sort((function(e,n){return e.getTime()-n.getTime()})));if(I(),i){var r=w.currentYear!==a.getFullYear();w.currentYear=a.getFullYear(),w.currentMonth=a.getMonth(),r&&(pe(\"onYearChange\"),K()),pe(\"onMonthChange\")}if(De(),J(),be(),i||\"range\"===w.config.mode||1!==w.config.showMonths?void 0!==w.selectedDateElem&&void 0===w.hourElement&&w.selectedDateElem&&w.selectedDateElem.focus():L(t),void 0!==w.hourElement&&void 0!==w.hourElement&&w.hourElement.focus(),w.config.closeOnSelect){var l=\"single\"===w.config.mode&&!w.config.enableTime,c=\"range\"===w.config.mode&&2===w.selectedDates.length&&!w.config.enableTime;(l||c)&&se()}A()}}w.parseDate=C({config:w.config,l10n:w.l10n}),w._handlers=[],w.pluginElements=[],w.loadedPlugins=[],w._bind=N,w._setHoursFromDate=S,w._positionCalendar=ce,w.changeMonth=G,w.changeYear=Q,w.clear=function(e,n){if(void 0===e&&(e=!0),void 0===n&&(n=!0),w.input.value=\"\",void 0!==w.altInput&&(w.altInput.value=\"\"),void 0!==w.mobileInput&&(w.mobileInput.value=\"\"),w.selectedDates=[],w.latestSelectedDateObj=void 0,!0===n&&(w.currentYear=w._initialDate.getFullYear(),w.currentMonth=w._initialDate.getMonth()),!0===w.config.enableTime){var t=_(),a=t.hours,i=t.minutes,o=t.seconds;O(a,i,o)}w.redraw(),e&&pe(\"onChange\")},w.close=function(){w.isOpen=!1,w.isMobile||(void 0!==w.calendarContainer&&w.calendarContainer.classList.remove(\"open\"),void 0!==w._input&&w._input.classList.remove(\"active\")),pe(\"onClose\")},w._createElement=s,w.destroy=function(){void 0!==w.config&&pe(\"onDestroy\");for(var e=w._handlers.length;e--;){var n=w._handlers[e];n.element.removeEventListener(n.event,n.handler,n.options)}if(w._handlers=[],w.mobileInput)w.mobileInput.parentNode&&w.mobileInput.parentNode.removeChild(w.mobileInput),w.mobileInput=void 0;else if(w.calendarContainer&&w.calendarContainer.parentNode)if(w.config.static&&w.calendarContainer.parentNode){var t=w.calendarContainer.parentNode;if(t.lastChild&&t.removeChild(t.lastChild),t.parentNode){for(;t.firstChild;)t.parentNode.insertBefore(t.firstChild,t);t.parentNode.removeChild(t)}}else w.calendarContainer.parentNode.removeChild(w.calendarContainer);w.altInput&&(w.input.type=\"text\",w.altInput.parentNode&&w.altInput.parentNode.removeChild(w.altInput),delete w.altInput),w.input&&(w.input.type=w.input._type,w.input.classList.remove(\"flatpickr-input\"),w.input.removeAttribute(\"readonly\")),[\"_showTimeInput\",\"latestSelectedDateObj\",\"_hideNextMonthArrow\",\"_hidePrevMonthArrow\",\"__hideNextMonthArrow\",\"__hidePrevMonthArrow\",\"isMobile\",\"isOpen\",\"selectedDateElem\",\"minDateHasTime\",\"maxDateHasTime\",\"days\",\"daysContainer\",\"_input\",\"_positionElement\",\"innerContainer\",\"rContainer\",\"monthNav\",\"todayDateElem\",\"calendarContainer\",\"weekdayContainer\",\"prevMonthNav\",\"nextMonthNav\",\"monthsDropdownContainer\",\"currentMonthElement\",\"currentYearElement\",\"navigationCurrentMonth\",\"selectedDateElem\",\"config\"].forEach((function(e){try{delete w[e]}catch(e){}}))},w.isEnabled=X,w.jumpToDate=P,w.open=function(e,n){if(void 0===n&&(n=w._positionElement),!0===w.isMobile){if(e){e.preventDefault();var t=g(e);t&&t.blur()}return void 0!==w.mobileInput&&(w.mobileInput.focus(),w.mobileInput.click()),void pe(\"onOpen\")}if(!w._input.disabled&&!w.config.inline){var a=w.isOpen;w.isOpen=!0,a||(w.calendarContainer.classList.add(\"open\"),w._input.classList.add(\"active\"),pe(\"onOpen\"),ce(n)),!0===w.config.enableTime&&!0===w.config.noCalendar&&(!1!==w.config.allowInput||void 0!==e&&w.timeContainer.contains(e.relatedTarget)||setTimeout((function(){return w.hourElement.select()}),50))}},w.redraw=de,w.set=function(e,n){if(null!==e&&\"object\"==typeof e)for(var a in Object.assign(w.config,e),e)void 0!==fe[a]&&fe[a].forEach((function(e){return e()}));else w.config[e]=n,void 0!==fe[e]?fe[e].forEach((function(e){return e()})):t.indexOf(e)>-1&&(w.config[e]=c(n));w.redraw(),be(!0)},w.setDate=function(e,n,t){if(void 0===n&&(n=!1),void 0===t&&(t=w.config.dateFormat),0!==e&&!e||e instanceof Array&&0===e.length)return w.clear(n);me(e,t),w.latestSelectedDateObj=w.selectedDates[w.selectedDates.length-1],w.redraw(),P(void 0,n),S(),0===w.selectedDates.length&&w.clear(!1),be(n),n&&pe(\"onChange\")},w.toggle=function(e){if(!0===w.isOpen)return w.close();w.open(e)};var fe={locale:[le,z],showMonths:[q,E,$],minDate:[P],maxDate:[P]};function me(e,n){var t=[];if(e instanceof Array)t=e.map((function(e){return w.parseDate(e,n)}));else if(e instanceof Date||\"number\"==typeof e)t=[w.parseDate(e,n)];else if(\"string\"==typeof e)switch(w.config.mode){case\"single\":case\"time\":t=[w.parseDate(e,n)];break;case\"multiple\":t=e.split(w.config.conjunction).map((function(e){return w.parseDate(e,n)}));break;case\"range\":t=e.split(w.l10n.rangeSeparator).map((function(e){return w.parseDate(e,n)}))}else w.config.errorHandler(new Error(\"Invalid date supplied: \"+JSON.stringify(e)));w.selectedDates=w.config.allowInvalidPreload?t:t.filter((function(e){return e instanceof Date&&X(e,!1)})),\"range\"===w.config.mode&&w.selectedDates.sort((function(e,n){return e.getTime()-n.getTime()}))}function ge(e){return e.slice().map((function(e){return\"string\"==typeof e||\"number\"==typeof e||e instanceof Date?w.parseDate(e,void 0,!0):e&&\"object\"==typeof e&&e.from&&e.to?{from:w.parseDate(e.from,void 0),to:w.parseDate(e.to,void 0)}:e})).filter((function(e){return e}))}function pe(e,n){if(void 0!==w.config){var t=w.config[e];if(void 0!==t&&t.length>0)for(var a=0;t[a]&&a1||\"static\"===w.config.monthSelectorType?w.monthElements[n].textContent=h(t.getMonth(),w.config.shorthandCurrentMonth,w.l10n)+\" \":w.monthsDropdownContainer.value=t.getMonth().toString(),e.value=t.getFullYear().toString()})),w._hidePrevMonthArrow=void 0!==w.config.minDate&&(w.currentYear===w.config.minDate.getFullYear()?w.currentMonth<=w.config.minDate.getMonth():w.currentYearw.config.maxDate.getMonth():w.currentYear>w.config.maxDate.getFullYear()))}function we(e){return w.selectedDates.map((function(n){return w.formatDate(n,e)})).filter((function(e,n,t){return\"range\"!==w.config.mode||w.config.enableTime||t.indexOf(e)===n})).join(\"range\"!==w.config.mode?w.config.conjunction:w.l10n.rangeSeparator)}function be(e){void 0===e&&(e=!0),void 0!==w.mobileInput&&w.mobileFormatStr&&(w.mobileInput.value=void 0!==w.latestSelectedDateObj?w.formatDate(w.latestSelectedDateObj,w.mobileFormatStr):\"\"),w.input.value=we(w.config.dateFormat),void 0!==w.altInput&&(w.altInput.value=we(w.config.altFormat)),!1!==e&&pe(\"onValueUpdate\")}function Ce(e){var n=g(e),t=w.prevMonthNav.contains(n),a=w.nextMonthNav.contains(n);t||a?G(t?-1:1):w.yearElements.indexOf(n)>=0?n.select():n.classList.contains(\"arrowUp\")?w.changeYear(w.currentYear+1):n.classList.contains(\"arrowDown\")&&w.changeYear(w.currentYear-1)}return function(){w.element=w.input=p,w.isOpen=!1,function(){var n=[\"wrap\",\"weekNumbers\",\"allowInput\",\"allowInvalidPreload\",\"clickOpens\",\"time_24hr\",\"enableTime\",\"noCalendar\",\"altInput\",\"shorthandCurrentMonth\",\"inline\",\"static\",\"enableSeconds\",\"disableMobile\"],i=e(e({},JSON.parse(JSON.stringify(p.dataset||{}))),v),o={};w.config.parseDate=i.parseDate,w.config.formatDate=i.formatDate,Object.defineProperty(w.config,\"enable\",{get:function(){return w.config._enable},set:function(e){w.config._enable=ge(e)}}),Object.defineProperty(w.config,\"disable\",{get:function(){return w.config._disable},set:function(e){w.config._disable=ge(e)}});var r=\"time\"===i.mode;if(!i.dateFormat&&(i.enableTime||r)){var l=k.defaultConfig.dateFormat||a.dateFormat;o.dateFormat=i.noCalendar||r?\"H:i\"+(i.enableSeconds?\":S\":\"\"):l+\" H:i\"+(i.enableSeconds?\":S\":\"\")}if(i.altInput&&(i.enableTime||r)&&!i.altFormat){var d=k.defaultConfig.altFormat||a.altFormat;o.altFormat=i.noCalendar||r?\"h:i\"+(i.enableSeconds?\":S K\":\" K\"):d+\" h:i\"+(i.enableSeconds?\":S\":\"\")+\" K\"}Object.defineProperty(w.config,\"minDate\",{get:function(){return w.config._minDate},set:oe(\"min\")}),Object.defineProperty(w.config,\"maxDate\",{get:function(){return w.config._maxDate},set:oe(\"max\")});var s=function(e){return function(n){w.config[\"min\"===e?\"_minTime\":\"_maxTime\"]=w.parseDate(n,\"H:i:S\")}};Object.defineProperty(w.config,\"minTime\",{get:function(){return w.config._minTime},set:s(\"min\")}),Object.defineProperty(w.config,\"maxTime\",{get:function(){return w.config._maxTime},set:s(\"max\")}),\"time\"===i.mode&&(w.config.noCalendar=!0,w.config.enableTime=!0),Object.assign(w.config,o,i);for(var u=0;u-1?w.config[m]=c(f[m]).map(x).concat(w.config[m]):void 0===i[m]&&(w.config[m]=f[m])}i.altInputClass||(w.config.altInputClass=re().className+\" \"+w.config.altInputClass),pe(\"onParseConfig\")}(),le(),w.input=re(),w.input?(w.input._type=w.input.type,w.input.type=\"text\",w.input.classList.add(\"flatpickr-input\"),w._input=w.input,w.config.altInput&&(w.altInput=s(w.input.nodeName,w.config.altInputClass),w._input=w.altInput,w.altInput.placeholder=w.input.placeholder,w.altInput.disabled=w.input.disabled,w.altInput.required=w.input.required,w.altInput.tabIndex=w.input.tabIndex,w.altInput.type=\"text\",w.input.setAttribute(\"type\",\"hidden\"),!w.config.static&&w.input.parentNode&&w.input.parentNode.insertBefore(w.altInput,w.input.nextSibling)),w.config.allowInput||w._input.setAttribute(\"readonly\",\"readonly\"),w._positionElement=w.config.positionElement||w._input):w.config.errorHandler(new Error(\"Invalid input element specified\")),function(){w.selectedDates=[],w.now=w.parseDate(w.config.now)||new Date;var e=w.config.defaultDate||(\"INPUT\"!==w.input.nodeName&&\"TEXTAREA\"!==w.input.nodeName||!w.input.placeholder||w.input.value!==w.input.placeholder?w.input.value:null);e&&me(e,w.config.dateFormat),w._initialDate=w.selectedDates.length>0?w.selectedDates[0]:w.config.minDate&&w.config.minDate.getTime()>w.now.getTime()?w.config.minDate:w.config.maxDate&&w.config.maxDate.getTime()0&&(w.latestSelectedDateObj=w.selectedDates[0]),void 0!==w.config.minTime&&(w.config.minTime=w.parseDate(w.config.minTime,\"H:i\")),void 0!==w.config.maxTime&&(w.config.maxTime=w.parseDate(w.config.maxTime,\"H:i\")),w.minDateHasTime=!!w.config.minDate&&(w.config.minDate.getHours()>0||w.config.minDate.getMinutes()>0||w.config.minDate.getSeconds()>0),w.maxDateHasTime=!!w.config.maxDate&&(w.config.maxDate.getHours()>0||w.config.maxDate.getMinutes()>0||w.config.maxDate.getSeconds()>0)}(),w.utils={getDaysInMonth:function(e,n){return void 0===e&&(e=w.currentMonth),void 0===n&&(n=w.currentYear),1===e&&(n%4==0&&n%100!=0||n%400==0)?29:w.l10n.daysInMonth[e]}},w.isMobile||function(){var e=window.document.createDocumentFragment();if(w.calendarContainer=s(\"div\",\"flatpickr-calendar\"),w.calendarContainer.tabIndex=-1,!w.config.noCalendar){if(e.appendChild((w.monthNav=s(\"div\",\"flatpickr-months\"),w.yearElements=[],w.monthElements=[],w.prevMonthNav=s(\"span\",\"flatpickr-prev-month\"),w.prevMonthNav.innerHTML=w.config.prevArrow,w.nextMonthNav=s(\"span\",\"flatpickr-next-month\"),w.nextMonthNav.innerHTML=w.config.nextArrow,q(),Object.defineProperty(w,\"_hidePrevMonthArrow\",{get:function(){return w.__hidePrevMonthArrow},set:function(e){w.__hidePrevMonthArrow!==e&&(d(w.prevMonthNav,\"flatpickr-disabled\",e),w.__hidePrevMonthArrow=e)}}),Object.defineProperty(w,\"_hideNextMonthArrow\",{get:function(){return w.__hideNextMonthArrow},set:function(e){w.__hideNextMonthArrow!==e&&(d(w.nextMonthNav,\"flatpickr-disabled\",e),w.__hideNextMonthArrow=e)}}),w.currentYearElement=w.yearElements[0],De(),w.monthNav)),w.innerContainer=s(\"div\",\"flatpickr-innerContainer\"),w.config.weekNumbers){var n=function(){w.calendarContainer.classList.add(\"hasWeeks\");var e=s(\"div\",\"flatpickr-weekwrapper\");e.appendChild(s(\"span\",\"flatpickr-weekday\",w.l10n.weekAbbreviation));var n=s(\"div\",\"flatpickr-weeks\");return e.appendChild(n),{weekWrapper:e,weekNumbers:n}}(),t=n.weekWrapper,a=n.weekNumbers;w.innerContainer.appendChild(t),w.weekNumbers=a,w.weekWrapper=t}w.rContainer=s(\"div\",\"flatpickr-rContainer\"),w.rContainer.appendChild($()),w.daysContainer||(w.daysContainer=s(\"div\",\"flatpickr-days\"),w.daysContainer.tabIndex=-1),J(),w.rContainer.appendChild(w.daysContainer),w.innerContainer.appendChild(w.rContainer),e.appendChild(w.innerContainer)}w.config.enableTime&&e.appendChild(function(){w.calendarContainer.classList.add(\"hasTime\"),w.config.noCalendar&&w.calendarContainer.classList.add(\"noCalendar\"),w.timeContainer=s(\"div\",\"flatpickr-time\"),w.timeContainer.tabIndex=-1;var e=s(\"span\",\"flatpickr-time-separator\",\":\"),n=m(\"flatpickr-hour\",{\"aria-label\":w.l10n.hourAriaLabel});w.hourElement=n.getElementsByTagName(\"input\")[0];var t=m(\"flatpickr-minute\",{\"aria-label\":w.l10n.minuteAriaLabel});if(w.minuteElement=t.getElementsByTagName(\"input\")[0],w.hourElement.tabIndex=w.minuteElement.tabIndex=-1,w.hourElement.value=o(w.latestSelectedDateObj?w.latestSelectedDateObj.getHours():w.config.time_24hr?w.config.defaultHour:function(e){switch(e%24){case 0:case 12:return 12;default:return e%12}}(w.config.defaultHour)),w.minuteElement.value=o(w.latestSelectedDateObj?w.latestSelectedDateObj.getMinutes():w.config.defaultMinute),w.hourElement.setAttribute(\"step\",w.config.hourIncrement.toString()),w.minuteElement.setAttribute(\"step\",w.config.minuteIncrement.toString()),w.hourElement.setAttribute(\"min\",w.config.time_24hr?\"0\":\"1\"),w.hourElement.setAttribute(\"max\",w.config.time_24hr?\"23\":\"12\"),w.minuteElement.setAttribute(\"min\",\"0\"),w.minuteElement.setAttribute(\"max\",\"59\"),w.timeContainer.appendChild(n),w.timeContainer.appendChild(e),w.timeContainer.appendChild(t),w.config.time_24hr&&w.timeContainer.classList.add(\"time24hr\"),w.config.enableSeconds){w.timeContainer.classList.add(\"hasSeconds\");var a=m(\"flatpickr-second\");w.secondElement=a.getElementsByTagName(\"input\")[0],w.secondElement.value=o(w.latestSelectedDateObj?w.latestSelectedDateObj.getSeconds():w.config.defaultSeconds),w.secondElement.setAttribute(\"step\",w.minuteElement.getAttribute(\"step\")),w.secondElement.setAttribute(\"min\",\"0\"),w.secondElement.setAttribute(\"max\",\"59\"),w.timeContainer.appendChild(s(\"span\",\"flatpickr-time-separator\",\":\")),w.timeContainer.appendChild(a)}return w.config.time_24hr||(w.amPM=s(\"span\",\"flatpickr-am-pm\",w.l10n.amPM[r((w.latestSelectedDateObj?w.hourElement.value:w.config.defaultHour)>11)]),w.amPM.title=w.l10n.toggleTitle,w.amPM.tabIndex=-1,w.timeContainer.appendChild(w.amPM)),w.timeContainer}()),d(w.calendarContainer,\"rangeMode\",\"range\"===w.config.mode),d(w.calendarContainer,\"animate\",!0===w.config.animate),d(w.calendarContainer,\"multiMonth\",w.config.showMonths>1),w.calendarContainer.appendChild(e);var i=void 0!==w.config.appendTo&&void 0!==w.config.appendTo.nodeType;if((w.config.inline||w.config.static)&&(w.calendarContainer.classList.add(w.config.inline?\"inline\":\"static\"),w.config.inline&&(!i&&w.element.parentNode?w.element.parentNode.insertBefore(w.calendarContainer,w._input.nextSibling):void 0!==w.config.appendTo&&w.config.appendTo.appendChild(w.calendarContainer)),w.config.static)){var l=s(\"div\",\"flatpickr-wrapper\");w.element.parentNode&&w.element.parentNode.insertBefore(l,w.element),l.appendChild(w.element),w.altInput&&l.appendChild(w.altInput),l.appendChild(w.calendarContainer)}w.config.static||w.config.inline||(void 0!==w.config.appendTo?w.config.appendTo:window.document.body).appendChild(w.calendarContainer)}(),function(){if(w.config.wrap&&[\"open\",\"close\",\"toggle\",\"clear\"].forEach((function(e){Array.prototype.forEach.call(w.element.querySelectorAll(\"[data-\"+e+\"]\"),(function(n){return N(n,\"click\",w[e])}))})),w.isMobile)!function(){var e=w.config.enableTime?w.config.noCalendar?\"time\":\"datetime-local\":\"date\";w.mobileInput=s(\"input\",w.input.className+\" flatpickr-mobile\"),w.mobileInput.tabIndex=1,w.mobileInput.type=e,w.mobileInput.disabled=w.input.disabled,w.mobileInput.required=w.input.required,w.mobileInput.placeholder=w.input.placeholder,w.mobileFormatStr=\"datetime-local\"===e?\"Y-m-d\\\\TH:i:S\":\"date\"===e?\"Y-m-d\":\"H:i:S\",w.selectedDates.length>0&&(w.mobileInput.defaultValue=w.mobileInput.value=w.formatDate(w.selectedDates[0],w.mobileFormatStr)),w.config.minDate&&(w.mobileInput.min=w.formatDate(w.config.minDate,\"Y-m-d\")),w.config.maxDate&&(w.mobileInput.max=w.formatDate(w.config.maxDate,\"Y-m-d\")),w.input.getAttribute(\"step\")&&(w.mobileInput.step=String(w.input.getAttribute(\"step\"))),w.input.type=\"hidden\",void 0!==w.altInput&&(w.altInput.type=\"hidden\");try{w.input.parentNode&&w.input.parentNode.insertBefore(w.mobileInput,w.input.nextSibling)}catch(e){}N(w.mobileInput,\"change\",(function(e){w.setDate(g(e).value,!1,w.mobileFormatStr),pe(\"onChange\"),pe(\"onClose\")}))}();else{var e=l(ie,50);if(w._debouncedChange=l(A,300),w.daysContainer&&!/iPhone|iPad|iPod/i.test(navigator.userAgent)&&N(w.daysContainer,\"mouseover\",(function(e){\"range\"===w.config.mode&&ae(g(e))})),N(window.document.body,\"keydown\",te),w.config.inline||w.config.static||N(window,\"resize\",e),void 0!==window.ontouchstart?N(window.document,\"touchstart\",Z):N(window.document,\"click\",Z),N(window.document,\"focus\",Z,{capture:!0}),!0===w.config.clickOpens&&(N(w._input,\"focus\",w.open),N(w._input,\"click\",w.open)),void 0!==w.daysContainer&&(N(w.monthNav,\"click\",Ce),N(w.monthNav,[\"keyup\",\"increment\"],F),N(w.daysContainer,\"click\",ue)),void 0!==w.timeContainer&&void 0!==w.minuteElement&&void 0!==w.hourElement){var n=function(e){return g(e).select()};N(w.timeContainer,[\"increment\"],T),N(w.timeContainer,\"blur\",T,{capture:!0}),N(w.timeContainer,\"click\",Y),N([w.hourElement,w.minuteElement],[\"focus\",\"click\"],n),void 0!==w.secondElement&&N(w.secondElement,\"focus\",(function(){return w.secondElement&&w.secondElement.select()})),void 0!==w.amPM&&N(w.amPM,\"click\",(function(e){T(e),A()}))}w.config.allowInput&&N(w._input,\"blur\",ne)}}(),(w.selectedDates.length||w.config.noCalendar)&&(w.config.enableTime&&S(w.config.noCalendar?w.latestSelectedDateObj||w.config.minDate:void 0),be(!1)),E();var n=/^((?!chrome|android).)*safari/i.test(navigator.userAgent);!w.isMobile&&n&&ce(),pe(\"onReady\")}(),w}function E(e,n){for(var t=Array.prototype.slice.call(e).filter((function(e){return e instanceof HTMLElement})),a=[],i=0;ithis.render()));const{start:s,end:l,value:r,step:o,title:n}=this.model.properties;this.on_change([s,l,r,o],(()=>{const{start:t,end:e,value:i,step:s}=this._calc_to();this.noUiSlider.updateOptions({range:{min:t,max:e},start:i,step:s})}));const{bar_color:a}=this.model.properties;this.on_change(a,(()=>{this._set_bar_color()}));const{show_value:d}=this.model.properties;this.on_change([r,n,d],(()=>this._update_title()))}styles(){return[...super.styles(),u.default,c.default]}_update_title(){var t;n.empty(this.title_el);const e=null==this.model.title||0==this.model.title.length&&!this.model.show_value;if(this.title_el.style.display=e?\"none\":\"\",!e&&(0!=(null===(t=this.model.title)||void 0===t?void 0:t.length)&&(this.title_el.textContent=`${this.model.title}: `),this.model.show_value)){const{value:t}=this._calc_to(),e=t.map((t=>this.model.pretty(t))).join(\" .. \");this.title_el.appendChild(n.span({class:m.slider_value},e))}}_set_bar_color(){if(!this.model.disabled){this.slider_el.querySelector(\".noUi-connect\").style.backgroundColor=d.color2css(this.model.bar_color)}}render(){super.render();const{start:t,end:e,value:i,step:s}=this._calc_to();let l;if(this.model.tooltips){const t={to:t=>this.model.pretty(t)};l=a.repeat(t,i.length)}else l=!1;if(null==this.slider_el){this.slider_el=n.div(),o.create(this.slider_el,{range:{min:t,max:e},start:i,step:s,behaviour:this.model.behaviour,connect:this.model.connected,tooltips:l,orientation:this.model.orientation,direction:this.model.direction}),this.noUiSlider.on(\"slide\",((t,e,i)=>this._slide(i))),this.noUiSlider.on(\"change\",((t,e,i)=>this._change(i)));const r=(t,e)=>{if(!l)return;this.slider_el.querySelectorAll(\".noUi-handle\")[t].querySelector(\".noUi-tooltip\").style.display=e?\"block\":\"\"};this.noUiSlider.on(\"start\",((t,e)=>r(e,!0))),this.noUiSlider.on(\"end\",((t,e)=>r(e,!1)))}else this.noUiSlider.updateOptions({range:{min:t,max:e},start:i,step:s});this._set_bar_color(),this.model.disabled?this.slider_el.setAttribute(\"disabled\",\"true\"):this.slider_el.removeAttribute(\"disabled\"),this.title_el=n.div({class:m.slider_title}),this._update_title(),this.group_el=n.div({class:p.input_group},this.title_el,this.slider_el),this.el.appendChild(this.group_el)}_slide(t){this.model.value=this._calc_from(t)}_change(t){const e=this._calc_from(t);this.model.setv({value:e,value_throttled:e})}}b.__name__=\"AbstractBaseSliderView\";class v extends b{_calc_to(){return{start:this.model.start,end:this.model.end,value:[this.model.value],step:this.model.step}}_calc_from([t]){return Number.isInteger(this.model.start)&&Number.isInteger(this.model.end)&&Number.isInteger(this.model.step)?Math.round(t):t}}i.AbstractSliderView=v,v.__name__=\"AbstractSliderView\";class g extends b{_calc_to(){return{start:this.model.start,end:this.model.end,value:this.model.value,step:this.model.step}}_calc_from(t){return t}}i.AbstractRangeSliderView=g,g.__name__=\"AbstractRangeSliderView\";class S extends _.Control{constructor(t){super(t),this.connected=!1}static init_AbstractSlider(){this.define((({Any:t,Boolean:e,Number:i,String:s,Color:l,Or:r,Enum:o,Ref:n,Nullable:a})=>({title:[a(s),\"\"],show_value:[e,!0],start:[t],end:[t],value:[t],value_throttled:[t],step:[i,1],format:[r(s,n(h.TickFormatter))],direction:[o(\"ltr\",\"rtl\"),\"ltr\"],tooltips:[e,!0],bar_color:[l,\"#e6e6e6\"]})))}pretty(t){return this._formatter(t,this.format)}}i.AbstractSlider=S,S.__name__=\"AbstractSlider\",S.init_AbstractSlider()},\n", + " 439: function _(t,e,r,n,i){\n", + " /*! nouislider - 14.6.3 - 11/19/2020 */\n", + " var o;o=function(){\"use strict\";var t=\"14.6.3\";function e(t){t.parentElement.removeChild(t)}function r(t){return null!=t}function n(t){t.preventDefault()}function i(t){return\"number\"==typeof t&&!isNaN(t)&&isFinite(t)}function o(t,e,r){r>0&&(u(t,e),setTimeout((function(){c(t,e)}),r))}function s(t){return Math.max(Math.min(t,100),0)}function a(t){return Array.isArray(t)?t:[t]}function l(t){var e=(t=String(t)).split(\".\");return e.length>1?e[1].length:0}function u(t,e){t.classList&&!/\\s/.test(e)?t.classList.add(e):t.className+=\" \"+e}function c(t,e){t.classList&&!/\\s/.test(e)?t.classList.remove(e):t.className=t.className.replace(new RegExp(\"(^|\\\\b)\"+e.split(\" \").join(\"|\")+\"(\\\\b|$)\",\"gi\"),\" \")}function p(t){var e=void 0!==window.pageXOffset,r=\"CSS1Compat\"===(t.compatMode||\"\");return{x:e?window.pageXOffset:r?t.documentElement.scrollLeft:t.body.scrollLeft,y:e?window.pageYOffset:r?t.documentElement.scrollTop:t.body.scrollTop}}function f(t,e){return 100/(e-t)}function d(t,e,r){return 100*e/(t[r+1]-t[r])}function h(t,e){for(var r=1;t>=e[r];)r+=1;return r}function m(t,e,r){if(r>=t.slice(-1)[0])return 100;var n=h(r,t),i=t[n-1],o=t[n],s=e[n-1],a=e[n];return s+function(t,e){return d(t,t[0]<0?e+Math.abs(t[0]):e-t[0],0)}([i,o],r)/f(s,a)}function g(t,e,r,n){if(100===n)return n;var i=h(n,t),o=t[i-1],s=t[i];return r?n-o>(s-o)/2?s:o:e[i-1]?t[i-1]+function(t,e){return Math.round(t/e)*e}(n-t[i-1],e[i-1]):n}function v(t,e,r){var n;if(\"number\"==typeof e&&(e=[e]),!Array.isArray(e))throw new Error(\"noUiSlider (14.6.3): 'range' contains invalid value.\");if(!i(n=\"min\"===t?0:\"max\"===t?100:parseFloat(t))||!i(e[0]))throw new Error(\"noUiSlider (14.6.3): 'range' value isn't numeric.\");r.xPct.push(n),r.xVal.push(e[0]),n?r.xSteps.push(!isNaN(e[1])&&e[1]):isNaN(e[1])||(r.xSteps[0]=e[1]),r.xHighestCompleteStep.push(0)}function b(t,e,r){if(e)if(r.xVal[t]!==r.xVal[t+1]){r.xSteps[t]=d([r.xVal[t],r.xVal[t+1]],e,0)/f(r.xPct[t],r.xPct[t+1]);var n=(r.xVal[t+1]-r.xVal[t])/r.xNumSteps[t],i=Math.ceil(Number(n.toFixed(3))-1),o=r.xVal[t]+r.xNumSteps[t]*i;r.xHighestCompleteStep[t]=o}else r.xSteps[t]=r.xHighestCompleteStep[t]=r.xVal[t]}function x(t,e,r){var n;this.xPct=[],this.xVal=[],this.xSteps=[r||!1],this.xNumSteps=[!1],this.xHighestCompleteStep=[],this.snap=e;var i=[];for(n in t)t.hasOwnProperty(n)&&i.push([t[n],n]);for(i.length&&\"object\"==typeof i[0][0]?i.sort((function(t,e){return t[0][0]-e[0][0]})):i.sort((function(t,e){return t[0]-e[0]})),n=0;nthis.xPct[i+1];)i++;else t===this.xPct[this.xPct.length-1]&&(i=this.xPct.length-2);r||t!==this.xPct[i+1]||i++;var o=1,s=e[i],a=0,l=0,u=0,c=0;for(n=r?(t-this.xPct[i])/(this.xPct[i+1]-this.xPct[i]):(this.xPct[i+1]-t)/(this.xPct[i+1]-this.xPct[i]);s>0;)a=this.xPct[i+1+c]-this.xPct[i+c],e[i+c]*o+100-100*n>100?(l=a*n,o=(s-100*n)/e[i+c],n=1):(l=e[i+c]*a/100*o,o=0),r?(u-=l,this.xPct.length+c>=1&&c--):(u+=l,this.xPct.length-c>=1&&c++),s=e[i+c]*o;return t+u},x.prototype.toStepping=function(t){return t=m(this.xVal,this.xPct,t)},x.prototype.fromStepping=function(t){return function(t,e,r){if(r>=100)return t.slice(-1)[0];var n=h(r,e),i=t[n-1],o=t[n],s=e[n-1];return function(t,e){return e*(t[1]-t[0])/100+t[0]}([i,o],(r-s)*f(s,e[n]))}(this.xVal,this.xPct,t)},x.prototype.getStep=function(t){return t=g(this.xPct,this.xSteps,this.snap,t)},x.prototype.getDefaultStep=function(t,e,r){var n=h(t,this.xPct);return(100===t||e&&t===this.xPct[n-1])&&(n=Math.max(n-1,1)),(this.xVal[n]-this.xVal[n-1])/r},x.prototype.getNearbySteps=function(t){var e=h(t,this.xPct);return{stepBefore:{startValue:this.xVal[e-2],step:this.xNumSteps[e-2],highestStep:this.xHighestCompleteStep[e-2]},thisStep:{startValue:this.xVal[e-1],step:this.xNumSteps[e-1],highestStep:this.xHighestCompleteStep[e-1]},stepAfter:{startValue:this.xVal[e],step:this.xNumSteps[e],highestStep:this.xHighestCompleteStep[e]}}},x.prototype.countStepDecimals=function(){var t=this.xNumSteps.map(l);return Math.max.apply(null,t)},x.prototype.convert=function(t){return this.getStep(this.toStepping(t))};var S={to:function(t){return void 0!==t&&t.toFixed(2)},from:Number},w={target:\"target\",base:\"base\",origin:\"origin\",handle:\"handle\",handleLower:\"handle-lower\",handleUpper:\"handle-upper\",touchArea:\"touch-area\",horizontal:\"horizontal\",vertical:\"vertical\",background:\"background\",connect:\"connect\",connects:\"connects\",ltr:\"ltr\",rtl:\"rtl\",textDirectionLtr:\"txt-dir-ltr\",textDirectionRtl:\"txt-dir-rtl\",draggable:\"draggable\",drag:\"state-drag\",tap:\"state-tap\",active:\"active\",tooltip:\"tooltip\",pips:\"pips\",pipsHorizontal:\"pips-horizontal\",pipsVertical:\"pips-vertical\",marker:\"marker\",markerHorizontal:\"marker-horizontal\",markerVertical:\"marker-vertical\",markerNormal:\"marker-normal\",markerLarge:\"marker-large\",markerSub:\"marker-sub\",value:\"value\",valueHorizontal:\"value-horizontal\",valueVertical:\"value-vertical\",valueNormal:\"value-normal\",valueLarge:\"value-large\",valueSub:\"value-sub\"},y=\".__tooltips\",E=\".__aria\";function C(t){if(function(t){return\"object\"==typeof t&&\"function\"==typeof t.to&&\"function\"==typeof t.from}(t))return!0;throw new Error(\"noUiSlider (14.6.3): 'format' requires 'to' and 'from' methods.\")}function P(t,e){if(!i(e))throw new Error(\"noUiSlider (14.6.3): 'step' is not numeric.\");t.singleStep=e}function N(t,e){if(!i(e))throw new Error(\"noUiSlider (14.6.3): 'keyboardPageMultiplier' is not numeric.\");t.keyboardPageMultiplier=e}function k(t,e){if(!i(e))throw new Error(\"noUiSlider (14.6.3): 'keyboardDefaultStep' is not numeric.\");t.keyboardDefaultStep=e}function U(t,e){if(\"object\"!=typeof e||Array.isArray(e))throw new Error(\"noUiSlider (14.6.3): 'range' is not an object.\");if(void 0===e.min||void 0===e.max)throw new Error(\"noUiSlider (14.6.3): Missing 'min' or 'max' in 'range'.\");if(e.min===e.max)throw new Error(\"noUiSlider (14.6.3): 'range' 'min' and 'max' cannot be equal.\");t.spectrum=new x(e,t.snap,t.singleStep)}function A(t,e){if(e=a(e),!Array.isArray(e)||!e.length)throw new Error(\"noUiSlider (14.6.3): 'start' option is incorrect.\");t.handles=e.length,t.start=e}function V(t,e){if(t.snap=e,\"boolean\"!=typeof e)throw new Error(\"noUiSlider (14.6.3): 'snap' option must be a boolean.\")}function D(t,e){if(t.animate=e,\"boolean\"!=typeof e)throw new Error(\"noUiSlider (14.6.3): 'animate' option must be a boolean.\")}function M(t,e){if(t.animationDuration=e,\"number\"!=typeof e)throw new Error(\"noUiSlider (14.6.3): 'animationDuration' option must be a number.\")}function O(t,e){var r,n=[!1];if(\"lower\"===e?e=[!0,!1]:\"upper\"===e&&(e=[!1,!0]),!0===e||!1===e){for(r=1;r1)throw new Error(\"noUiSlider (14.6.3): 'padding' option must not exceed 100% of the range.\")}}function F(t,e){switch(e){case\"ltr\":t.dir=0;break;case\"rtl\":t.dir=1;break;default:throw new Error(\"noUiSlider (14.6.3): 'direction' option was not recognized.\")}}function R(t,e){if(\"string\"!=typeof e)throw new Error(\"noUiSlider (14.6.3): 'behaviour' must be a string containing options.\");var r=e.indexOf(\"tap\")>=0,n=e.indexOf(\"drag\")>=0,i=e.indexOf(\"fixed\")>=0,o=e.indexOf(\"snap\")>=0,s=e.indexOf(\"hover\")>=0,a=e.indexOf(\"unconstrained\")>=0;if(i){if(2!==t.handles)throw new Error(\"noUiSlider (14.6.3): 'fixed' behaviour must be used with 2 handles\");z(t,t.start[1]-t.start[0])}if(a&&(t.margin||t.limit))throw new Error(\"noUiSlider (14.6.3): 'unconstrained' behaviour cannot be used with margin or limit\");t.events={tap:r||o,drag:n,fixed:i,snap:o,hover:s,unconstrained:a}}function T(t,e){if(!1!==e)if(!0===e){t.tooltips=[];for(var r=0;r0&&((a=L(i,!1)).className=c(s,r.cssClasses.value),a.setAttribute(\"data-value\",o),a.style[r.style]=t+\"%\",a.innerHTML=n.to(o))}}(o,t[o][0],t[o][1])})),i}function q(){h&&(e(h),h=null)}function X(t){q();var e=t.mode,r=t.density||1,n=t.filter||!1,i=function(t,e,r){if(\"range\"===t||\"steps\"===t)return C.xVal;if(\"count\"===t){if(e<2)throw new Error(\"noUiSlider (14.6.3): 'values' (>= 2) required for mode 'count'.\");var n=e-1,i=100/n;for(e=[];n--;)e[n]=n*i;e.push(100),t=\"positions\"}return\"positions\"===t?e.map((function(t){return C.fromStepping(r?C.getStep(t):t)})):\"values\"===t?r?e.map((function(t){return C.fromStepping(C.getStep(C.toStepping(t)))})):e:void 0}(e,t.values||!1,t.stepped||!1),o=function(t,e,r){var n,i={},o=C.xVal[0],s=C.xVal[C.xVal.length-1],a=!1,l=!1,u=0;return n=r.slice().sort((function(t,e){return t-e})),(r=n.filter((function(t){return!this[t]&&(this[t]=!0)}),{}))[0]!==o&&(r.unshift(o),a=!0),r[r.length-1]!==s&&(r.push(s),l=!0),r.forEach((function(n,o){var s,c,p,f,d,h,m,g,v,b,x=n,S=r[o+1],w=\"steps\"===e;if(w&&(s=C.xNumSteps[o]),s||(s=S-x),!1!==x)for(void 0===S&&(S=x),s=Math.max(s,1e-7),c=x;c<=S;c=(c+s).toFixed(7)/1){for(g=(d=(f=C.toStepping(c))-u)/t,b=d/(v=Math.round(g)),p=1;p<=v;p+=1)i[(h=u+p*b).toFixed(5)]=[C.fromStepping(h),0];m=r.indexOf(c)>-1?1:w?2:0,!o&&a&&c!==S&&(m=0),c===S&&l||(i[f.toFixed(5)]=[c,m]),u=f}})),i}(r,e,i),s=t.format||{to:Math.round};return h=w.appendChild(B(o,n,s))}function Y(){var t=l.getBoundingClientRect(),e=\"offset\"+[\"Width\",\"Height\"][r.ort];return 0===r.ort?t.width||l[e]:t.height||l[e]}function I(t,e,n,i){var o=function(o){return!!(o=function(t,e,r){var n,i,o=0===t.type.indexOf(\"touch\"),s=0===t.type.indexOf(\"mouse\"),a=0===t.type.indexOf(\"pointer\");if(0===t.type.indexOf(\"MSPointer\")&&(a=!0),\"mousedown\"===t.type&&!t.buttons&&!t.touches)return!1;if(o){var l=function(t){return t.target===r||r.contains(t.target)||t.target.shadowRoot&&t.target.shadowRoot.contains(r)};if(\"touchstart\"===t.type){var u=Array.prototype.filter.call(t.touches,l);if(u.length>1)return!1;n=u[0].pageX,i=u[0].pageY}else{var c=Array.prototype.find.call(t.changedTouches,l);if(!c)return!1;n=c.pageX,i=c.pageY}}return e=e||p(V),(s||a)&&(n=t.clientX+e.x,i=t.clientY+e.y),t.pageOffset=e,t.points=[n,i],t.cursor=s||a,t}(o,i.pageOffset,i.target||e))&&!(F()&&!i.doNotReject)&&(s=w,a=r.cssClasses.tap,!((s.classList?s.classList.contains(a):new RegExp(\"\\\\b\"+a+\"\\\\b\").test(s.className))&&!i.doNotReject)&&!(t===x.start&&void 0!==o.buttons&&o.buttons>1)&&(!i.hover||!o.buttons)&&(S||o.preventDefault(),o.calcPoint=o.points[r.ort],void n(o,i)));var s,a},s=[];return t.split(\" \").forEach((function(t){e.addEventListener(t,o,!!S&&{passive:!0}),s.push([t,o])})),s}function $(t){var e,n,i,o,a,u,c=100*(t-(e=l,n=r.ort,i=e.getBoundingClientRect(),o=e.ownerDocument,a=o.documentElement,u=p(o),/webkit.*Chrome.*Mobile/i.test(navigator.userAgent)&&(u.x=0),n?i.top+u.y-a.clientTop:i.left+u.x-a.clientLeft))/Y();return c=s(c),r.dir?100-c:c}function G(t,e){\"mouseout\"===t.type&&\"HTML\"===t.target.nodeName&&null===t.relatedTarget&&K(t,e)}function J(t,e){if(-1===navigator.appVersion.indexOf(\"MSIE 9\")&&0===t.buttons&&0!==e.buttonsProperty)return K(t,e);var n=(r.dir?-1:1)*(t.calcPoint-e.startCalcPoint);st(n>0,100*n/e.baseSize,e.locations,e.handleNumbers)}function K(t,e){e.handle&&(c(e.handle,r.cssClasses.active),U-=1),e.listeners.forEach((function(t){D.removeEventListener(t[0],t[1])})),0===U&&(c(w,r.cssClasses.drag),lt(),t.cursor&&(M.style.cursor=\"\",M.removeEventListener(\"selectstart\",n))),e.handleNumbers.forEach((function(t){nt(\"change\",t),nt(\"set\",t),nt(\"end\",t)}))}function Q(t,e){if(e.handleNumbers.some(R))return!1;var i;1===e.handleNumbers.length&&(i=f[e.handleNumbers[0]].children[0],U+=1,u(i,r.cssClasses.active)),t.stopPropagation();var o=[],s=I(x.move,D,J,{target:t.target,handle:i,listeners:o,startCalcPoint:t.calcPoint,baseSize:Y(),pageOffset:t.pageOffset,handleNumbers:e.handleNumbers,buttonsProperty:t.buttons,locations:N.slice()}),a=I(x.end,D,K,{target:t.target,handle:i,listeners:o,doNotReject:!0,handleNumbers:e.handleNumbers}),l=I(\"mouseout\",D,G,{target:t.target,handle:i,listeners:o,doNotReject:!0,handleNumbers:e.handleNumbers});o.push.apply(o,s.concat(a,l)),t.cursor&&(M.style.cursor=getComputedStyle(t.target).cursor,f.length>1&&u(w,r.cssClasses.drag),M.addEventListener(\"selectstart\",n,!1)),e.handleNumbers.forEach((function(t){nt(\"start\",t)}))}function Z(t){t.stopPropagation();var e=$(t.calcPoint),n=function(t){var e=100,r=!1;return f.forEach((function(n,i){if(!R(i)){var o=N[i],s=Math.abs(o-t);(so||100===s&&100===e)&&(r=i,e=s)}})),r}(e);if(!1===n)return!1;r.events.snap||o(w,r.cssClasses.tap,r.animationDuration),ut(n,e,!0,!0),lt(),nt(\"slide\",n,!0),nt(\"update\",n,!0),nt(\"change\",n,!0),nt(\"set\",n,!0),r.events.snap&&Q(t,{handleNumbers:[n]})}function tt(t){var e=$(t.calcPoint),r=C.getStep(e),n=C.fromStepping(r);Object.keys(A).forEach((function(t){\"hover\"===t.split(\".\")[0]&&A[t].forEach((function(t){t.call(g,n)}))}))}function et(t,e){A[t]=A[t]||[],A[t].push(e),\"update\"===t.split(\".\")[0]&&f.forEach((function(t,e){nt(\"update\",e)}))}function rt(t){var e=t&&t.split(\".\")[0],r=e?t.substring(e.length):t;Object.keys(A).forEach((function(t){var n=t.split(\".\")[0],i=t.substring(n.length);e&&e!==n||r&&r!==i||function(t){return t===E||t===y}(i)&&r!==i||delete A[t]}))}function nt(t,e,n){Object.keys(A).forEach((function(i){var o=i.split(\".\")[0];t===o&&A[i].forEach((function(t){t.call(g,P.map(r.format.to),e,P.slice(),n||!1,N.slice(),g)}))}))}function it(t,e,n,i,o,a){var l;return f.length>1&&!r.events.unconstrained&&(i&&e>0&&(l=C.getAbsoluteDistance(t[e-1],r.margin,0),n=Math.max(n,l)),o&&e1&&r.limit&&(i&&e>0&&(l=C.getAbsoluteDistance(t[e-1],r.limit,0),n=Math.min(n,l)),o&&e1?n.forEach((function(t,r){var n=it(i,t,i[t]+e,o[r],s[r],!1);!1===n?e=0:(e=n-i[t],i[t]=n)})):o=s=[!0];var a=!1;n.forEach((function(t,n){a=ut(t,r[t]+e,o[n],s[n])||a})),a&&n.forEach((function(t){nt(\"update\",t),nt(\"slide\",t)}))}function at(t,e){return r.dir?100-t-e:t}function lt(){k.forEach((function(t){var e=N[t]>50?-1:1,r=3+(f.length+e*t);f[t].style.zIndex=r}))}function ut(t,e,n,i,o){return o||(e=it(N,t,e,n,i,!1)),!1!==e&&(function(t,e){N[t]=e,P[t]=C.fromStepping(e);var n=\"translate(\"+ot(10*(at(e,0)-O)+\"%\",\"0\")+\")\";f[t].style[r.transformRule]=n,ct(t),ct(t+1)}(t,e),!0)}function ct(t){if(d[t]){var e=0,n=100;0!==t&&(e=N[t-1]),t!==d.length-1&&(n=N[t]);var i=n-e,o=\"translate(\"+ot(at(e,i)+\"%\",\"0\")+\")\",s=\"scale(\"+ot(i/100,\"1\")+\")\";d[t].style[r.transformRule]=o+\" \"+s}}function pt(t,e){return null===t||!1===t||void 0===t?N[e]:(\"number\"==typeof t&&(t=String(t)),t=r.format.from(t),!1===(t=C.toStepping(t))||isNaN(t)?N[e]:t)}function ft(t,e,n){var i=a(t),s=void 0===N[0];e=void 0===e||!!e,r.animate&&!s&&o(w,r.cssClasses.tap,r.animationDuration),k.forEach((function(t){ut(t,pt(i[t],t),!0,!1,n)}));for(var l=1===k.length?0:1;ln.stepAfter.startValue&&(o=n.stepAfter.startValue-i),s=i>n.thisStep.startValue?n.thisStep.step:!1!==n.stepBefore.step&&i-n.stepBefore.highestStep,100===e?o=null:0===e&&(s=null);var a=C.countStepDecimals();return null!==o&&!1!==o&&(o=Number(o.toFixed(a))),null!==s&&!1!==s&&(s=Number(s.toFixed(a))),[s,o]}return u(v=w,r.cssClasses.target),0===r.dir?u(v,r.cssClasses.ltr):u(v,r.cssClasses.rtl),0===r.ort?u(v,r.cssClasses.horizontal):u(v,r.cssClasses.vertical),u(v,\"rtl\"===getComputedStyle(v).direction?r.cssClasses.textDirectionRtl:r.cssClasses.textDirectionLtr),l=L(v,r.cssClasses.base),function(t,e){var n=L(e,r.cssClasses.connects);f=[],(d=[]).push(H(n,t[0]));for(var i=0;i=0&&t .noUi-tooltip{-webkit-transform:translate(50%, 0);transform:translate(50%, 0);left:auto;bottom:10px;}.bk-root .noUi-vertical .noUi-origin > .noUi-tooltip{-webkit-transform:translate(0, -18px);transform:translate(0, -18px);top:auto;right:28px;}.bk-root .noUi-handle{cursor:grab;cursor:-webkit-grab;}.bk-root .noUi-handle.noUi-active{cursor:grabbing;cursor:-webkit-grabbing;}.bk-root .noUi-handle:after,.bk-root .noUi-handle:before{display:none;}.bk-root .noUi-tooltip{display:none;white-space:nowrap;}.bk-root .noUi-handle:hover .noUi-tooltip{display:block;}.bk-root .noUi-horizontal{width:100%;height:10px;}.bk-root .noUi-vertical{width:10px;height:100%;}.bk-root .noUi-horizontal .noUi-handle{width:14px;height:18px;right:-7px;top:-5px;}.bk-root .noUi-vertical .noUi-handle{width:18px;height:14px;right:-5px;top:-7px;}.bk-root .noUi-target.noUi-horizontal{margin:5px 0px;}.bk-root .noUi-target.noUi-vertical{margin:0px 5px;}'},\n", + " 442: function _(t,e,i,r,a){r();const s=t(1).__importDefault(t(181)),d=t(438),_=t(8);class n extends d.AbstractSliderView{}i.DateSliderView=n,n.__name__=\"DateSliderView\";class l extends d.AbstractSlider{constructor(t){super(t),this.behaviour=\"tap\",this.connected=[!0,!1]}static init_DateSlider(){this.prototype.default_view=n,this.override({format:\"%d %b %Y\"})}_formatter(t,e){return _.isString(e)?s.default(t,e):e.compute(t)}}i.DateSlider=l,l.__name__=\"DateSlider\",l.init_DateSlider()},\n", + " 443: function _(e,t,i,n,s){n();const r=e(444);class _ extends r.MarkupView{render(){super.render(),this.model.render_as_text?this.markup_el.textContent=this.model.text:this.markup_el.innerHTML=this.model.text}}i.DivView=_,_.__name__=\"DivView\";class a extends r.Markup{constructor(e){super(e)}static init_Div(){this.prototype.default_view=_,this.define((({Boolean:e})=>({render_as_text:[e,!1]})))}}i.Div=a,a.__name__=\"Div\",a.init_Div()},\n", + " 444: function _(t,e,s,i,a){i();const n=t(1),l=t(224),r=t(43),c=t(488),u=n.__importStar(t(445));class _ extends c.WidgetView{connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>{this.layout.invalidate_cache(),this.render(),this.root.compute_layout()}))}styles(){return[...super.styles(),u.default]}_update_layout(){this.layout=new l.CachedVariadicBox(this.el),this.layout.set_sizing(this.box_sizing())}render(){super.render();const t=Object.assign(Object.assign({},this.model.style),{display:\"inline-block\"});this.markup_el=r.div({class:u.clearfix,style:t}),this.el.appendChild(this.markup_el)}}s.MarkupView=_,_.__name__=\"MarkupView\";class o extends c.Widget{constructor(t){super(t)}static init_Markup(){this.define((({String:t,Dict:e})=>({text:[t,\"\"],style:[e(t),{}]})))}}s.Markup=o,o.__name__=\"Markup\",o.init_Markup()},\n", + " 445: function _(o,r,e,t,a){t(),e.root=\"bk-root\",e.clearfix=\"bk-clearfix\",e.default='.bk-root .bk-clearfix:before,.bk-root .bk-clearfix:after{content:\"\";display:table;}.bk-root .bk-clearfix:after{clear:both;}'},\n", + " 446: function _(e,t,i,n,s){n();const o=e(1),r=e(419),l=e(264),d=e(43),_=e(8),u=o.__importStar(e(328)),c=o.__importStar(e(243)),h=c;class p extends r.AbstractButtonView{constructor(){super(...arguments),this._open=!1}styles(){return[...super.styles(),c.default]}render(){super.render();const e=d.div({class:[h.caret,h.down]});if(this.model.is_split){const t=this._render_button(e);t.classList.add(u.dropdown_toggle),t.addEventListener(\"click\",(()=>this._toggle_menu())),this.group_el.appendChild(t)}else this.button_el.appendChild(e);const t=this.model.menu.map(((e,t)=>{if(null==e)return d.div({class:h.divider});{const i=_.isString(e)?e:e[0],n=d.div({},i);return n.addEventListener(\"click\",(()=>this._item_click(t))),n}}));this.menu=d.div({class:[h.menu,h.below]},t),this.el.appendChild(this.menu),d.undisplay(this.menu)}_show_menu(){if(!this._open){this._open=!0,d.display(this.menu);const e=t=>{const{target:i}=t;i instanceof HTMLElement&&!this.el.contains(i)&&(document.removeEventListener(\"click\",e),this._hide_menu())};document.addEventListener(\"click\",e)}}_hide_menu(){this._open&&(this._open=!1,d.undisplay(this.menu))}_toggle_menu(){this._open?this._hide_menu():this._show_menu()}click(){this.model.is_split?(this._hide_menu(),this.model.trigger_event(new l.ButtonClick),super.click()):this._toggle_menu()}_item_click(e){this._hide_menu();const t=this.model.menu[e];if(null!=t){const i=_.isString(t)?t:t[1];_.isString(i)?this.model.trigger_event(new l.MenuItemClick(i)):i.execute(this.model,{index:e})}}}i.DropdownView=p,p.__name__=\"DropdownView\";class m extends r.AbstractButton{constructor(e){super(e)}static init_Dropdown(){this.prototype.default_view=p,this.define((({Null:e,Boolean:t,String:i,Array:n,Tuple:s,Or:o})=>({split:[t,!1],menu:[n(o(i,s(i,o(i)),e)),[]]}))),this.override({label:\"Dropdown\"})}get is_split(){return this.split}}i.Dropdown=m,m.__name__=\"Dropdown\",m.init_Dropdown()},\n", + " 447: function _(e,i,l,t,s){t();const n=e(43),a=e(488);class o extends a.WidgetView{connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.render()))}render(){const{multiple:e,accept:i,disabled:l,width:t}=this.model;null==this.dialog_el&&(this.dialog_el=n.input({type:\"file\",multiple:e}),this.dialog_el.onchange=()=>{const{files:e}=this.dialog_el;null!=e&&this.load_files(e)},this.el.appendChild(this.dialog_el)),null!=i&&\"\"!=i&&(this.dialog_el.accept=i),this.dialog_el.style.width=`${t}px`,this.dialog_el.disabled=l}async load_files(e){const i=[],l=[],t=[];for(const s of e){const e=await this._read_file(s),[,n=\"\",,a=\"\"]=e.split(/[:;,]/,4);i.push(a),l.push(s.name),t.push(n)}this.model.multiple?(this.model.value=i,this.model.filename=l,this.model.mime_type=t):(this.model.value=i[0],this.model.filename=l[0],this.model.mime_type=t[0])}_read_file(e){return new Promise(((i,l)=>{const t=new FileReader;t.onload=()=>{var s;const{result:n}=t;null!=n?i(n):l(null!==(s=t.error)&&void 0!==s?s:new Error(`unable to read '${e.name}'`))},t.readAsDataURL(e)}))}}l.FileInputView=o,o.__name__=\"FileInputView\";class d extends a.Widget{constructor(e){super(e)}static init_FileInput(){this.prototype.default_view=o,this.define((({Boolean:e,String:i,Array:l,Or:t})=>({value:[t(i,l(i)),\"\"],mime_type:[t(i,l(i)),\"\"],filename:[t(i,l(i)),\"\"],accept:[i,\"\"],multiple:[e,!1]})))}}l.FileInput=d,d.__name__=\"FileInput\",d.init_FileInput()},\n", + " 448: function _(e,t,i,s,n){s();const l=e(1),o=e(43),r=e(8),c=e(426),h=l.__importStar(e(427));class p extends c.InputWidgetView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.value.change,(()=>this.render_selection())),this.connect(this.model.properties.options.change,(()=>this.render())),this.connect(this.model.properties.name.change,(()=>this.render())),this.connect(this.model.properties.title.change,(()=>this.render())),this.connect(this.model.properties.size.change,(()=>this.render())),this.connect(this.model.properties.disabled.change,(()=>this.render()))}render(){super.render();const e=this.model.options.map((e=>{let t,i;return r.isString(e)?t=i=e:[t,i]=e,o.option({value:t},i)}));this.input_el=o.select({multiple:!0,class:h.input,name:this.model.name,disabled:this.model.disabled},e),this.input_el.addEventListener(\"change\",(()=>this.change_input())),this.group_el.appendChild(this.input_el),this.render_selection()}render_selection(){const e=new Set(this.model.value);for(const t of this.el.querySelectorAll(\"option\"))t.selected=e.has(t.value);this.input_el.size=this.model.size}change_input(){const e=null!=this.el.querySelector(\"select:focus\"),t=[];for(const e of this.el.querySelectorAll(\"option\"))e.selected&&t.push(e.value);this.model.value=t,super.change_input(),e&&this.input_el.focus()}}i.MultiSelectView=p,p.__name__=\"MultiSelectView\";class u extends c.InputWidget{constructor(e){super(e)}static init_MultiSelect(){this.prototype.default_view=p,this.define((({Int:e,String:t,Array:i,Tuple:s,Or:n})=>({value:[i(t),[]],options:[i(n(t,s(t,t))),[]],size:[e,4]})))}}i.MultiSelect=u,u.__name__=\"MultiSelect\",u.init_MultiSelect()},\n", + " 449: function _(a,r,e,t,p){t();const s=a(444),i=a(43);class n extends s.MarkupView{render(){super.render();const a=i.p({style:{margin:0}},this.model.text);this.markup_el.appendChild(a)}}e.ParagraphView=n,n.__name__=\"ParagraphView\";class _ extends s.Markup{constructor(a){super(a)}static init_Paragraph(){this.prototype.default_view=n}}e.Paragraph=_,_.__name__=\"Paragraph\",_.init_Paragraph()},\n", + " 450: function _(s,t,e,n,r){n();const p=s(424);class u extends p.TextInputView{render(){super.render(),this.input_el.type=\"password\"}}e.PasswordInputView=u,u.__name__=\"PasswordInputView\";class a extends p.TextInput{constructor(s){super(s)}static init_PasswordInput(){this.prototype.default_view=u}}e.PasswordInput=a,a.__name__=\"PasswordInput\",a.init_PasswordInput()},\n", + " 451: function _(e,t,i,l,s){l();const o=e(1),n=o.__importDefault(e(452)),h=e(43),a=e(8),u=e(224),c=o.__importStar(e(427)),d=o.__importDefault(e(453)),_=e(426);class r extends _.InputWidgetView{constructor(){super(...arguments),this._last_height=null}connect_signals(){super.connect_signals(),this.connect(this.model.properties.disabled.change,(()=>this.set_disabled()));const{value:e,max_items:t,option_limit:i,delete_button:l,placeholder:s,options:o,name:n,title:h}=this.model.properties;this.on_change([e,t,i,l,s,o,n,h],(()=>this.render()))}styles(){return[...super.styles(),d.default]}_update_layout(){this.layout=new u.CachedVariadicBox(this.el),this.layout.set_sizing(this.box_sizing())}render(){super.render(),this.input_el=h.select({multiple:!0,class:c.input,name:this.model.name,disabled:this.model.disabled}),this.group_el.appendChild(this.input_el);const e=new Set(this.model.value),t=this.model.options.map((t=>{let i,l;return a.isString(t)?i=l=t:[i,l]=t,{value:i,label:l,selected:e.has(i)}})),i=this.model.solid?\"solid\":\"light\",l=`choices__item ${i}`,s=`choices__button ${i}`,o={choices:t,duplicateItemsAllowed:!1,removeItemButton:this.model.delete_button,classNames:{item:l,button:s}};null!=this.model.placeholder&&(o.placeholderValue=this.model.placeholder),null!=this.model.max_items&&(o.maxItemCount=this.model.max_items),null!=this.model.option_limit&&(o.renderChoiceLimit=this.model.option_limit),this.choice_el=new n.default(this.input_el,o);const u=()=>this.choice_el.containerOuter.element.getBoundingClientRect().height;null!=this._last_height&&this._last_height!=u()&&this.root.invalidate_layout(),this._last_height=u(),this.input_el.addEventListener(\"change\",(()=>this.change_input()))}set_disabled(){this.model.disabled?this.choice_el.disable():this.choice_el.enable()}change_input(){const e=null!=this.el.querySelector(\"select:focus\"),t=[];for(const e of this.el.querySelectorAll(\"option\"))e.selected&&t.push(e.value);this.model.value=t,super.change_input(),e&&this.input_el.focus()}}i.MultiChoiceView=r,r.__name__=\"MultiChoiceView\";class m extends _.InputWidget{constructor(e){super(e)}static init_MultiChoice(){this.prototype.default_view=r,this.define((({Boolean:e,Int:t,String:i,Array:l,Tuple:s,Or:o,Nullable:n})=>({value:[l(i),[]],options:[l(o(i,s(i,i))),[]],max_items:[n(t),null],delete_button:[e,!0],placeholder:[n(i),null],option_limit:[n(t),null],solid:[e,!0]})))}}i.MultiChoice=m,m.__name__=\"MultiChoice\",m.init_MultiChoice()},\n", + " 452: function _(e,t,i,n,s){\n", + " /*! choices.js v9.0.1 | © 2019 Josh Johnson | https://github.com/jshjohnson/Choices#readme */\n", + " var r,o;r=window,o=function(){return function(e){var t={};function i(n){if(t[n])return t[n].exports;var s=t[n]={i:n,l:!1,exports:{}};return e[n].call(s.exports,s,s.exports,i),s.l=!0,s.exports}return i.m=e,i.c=t,i.d=function(e,t,n){i.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},i.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},i.t=function(e,t){if(1&t&&(e=i(e)),8&t)return e;if(4&t&&\"object\"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(i.r(n),Object.defineProperty(n,\"default\",{enumerable:!0,value:e}),2&t&&\"string\"!=typeof e)for(var s in e)i.d(n,s,function(t){return e[t]}.bind(null,s));return n},i.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return i.d(t,\"a\",t),t},i.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},i.p=\"/public/assets/scripts/\",i(i.s=4)}([function(e,t,i){\"use strict\";var n=function(e){return function(e){return!!e&&\"object\"==typeof e}(e)&&!function(e){var t=Object.prototype.toString.call(e);return\"[object RegExp]\"===t||\"[object Date]\"===t||function(e){return e.$$typeof===s}(e)}(e)},s=\"function\"==typeof Symbol&&Symbol.for?Symbol.for(\"react.element\"):60103;function r(e,t){return!1!==t.clone&&t.isMergeableObject(e)?l((i=e,Array.isArray(i)?[]:{}),e,t):e;var i}function o(e,t,i){return e.concat(t).map((function(e){return r(e,i)}))}function a(e){return Object.keys(e).concat(function(e){return Object.getOwnPropertySymbols?Object.getOwnPropertySymbols(e).filter((function(t){return e.propertyIsEnumerable(t)})):[]}(e))}function c(e,t,i){var n={};return i.isMergeableObject(e)&&a(e).forEach((function(t){n[t]=r(e[t],i)})),a(t).forEach((function(s){(function(e,t){try{return t in e&&!(Object.hasOwnProperty.call(e,t)&&Object.propertyIsEnumerable.call(e,t))}catch(e){return!1}})(e,s)||(i.isMergeableObject(t[s])&&e[s]?n[s]=function(e,t){if(!t.customMerge)return l;var i=t.customMerge(e);return\"function\"==typeof i?i:l}(s,i)(e[s],t[s],i):n[s]=r(t[s],i))})),n}function l(e,t,i){(i=i||{}).arrayMerge=i.arrayMerge||o,i.isMergeableObject=i.isMergeableObject||n,i.cloneUnlessOtherwiseSpecified=r;var s=Array.isArray(t);return s===Array.isArray(e)?s?i.arrayMerge(e,t,i):c(e,t,i):r(t,i)}l.all=function(e,t){if(!Array.isArray(e))throw new Error(\"first argument should be an array\");return e.reduce((function(e,i){return l(e,i,t)}),{})};var h=l;e.exports=h},function(e,t,i){\"use strict\";(function(e,n){var s,r=i(3);s=\"undefined\"!=typeof self?self:\"undefined\"!=typeof window?window:void 0!==e?e:n;var o=Object(r.a)(s);t.a=o}).call(this,i(5),i(6)(e))},function(e,t,i){\n", + " /*!\n", + " * Fuse.js v3.4.5 - Lightweight fuzzy-search (http://fusejs.io)\n", + " *\n", + " * Copyright (c) 2012-2017 Kirollos Risk (http://kiro.me)\n", + " * All Rights Reserved. Apache Software License 2.0\n", + " *\n", + " * http://www.apache.org/licenses/LICENSE-2.0\n", + " */\n", + " e.exports=function(e){var t={};function i(n){if(t[n])return t[n].exports;var s=t[n]={i:n,l:!1,exports:{}};return e[n].call(s.exports,s,s.exports,i),s.l=!0,s.exports}return i.m=e,i.c=t,i.d=function(e,t,n){i.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},i.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},i.t=function(e,t){if(1&t&&(e=i(e)),8&t)return e;if(4&t&&\"object\"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(i.r(n),Object.defineProperty(n,\"default\",{enumerable:!0,value:e}),2&t&&\"string\"!=typeof e)for(var s in e)i.d(n,s,function(t){return e[t]}.bind(null,s));return n},i.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return i.d(t,\"a\",t),t},i.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},i.p=\"\",i(i.s=1)}([function(e,t){e.exports=function(e){return Array.isArray?Array.isArray(e):\"[object Array]\"===Object.prototype.toString.call(e)}},function(e,t,i){function n(e){return(n=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&\"function\"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?\"symbol\":typeof e})(e)}function s(e,t){for(var i=0;i1&&void 0!==arguments[1]?arguments[1]:{limit:!1};this._log('---------\\nSearch pattern: \"'.concat(e,'\"'));var i=this._prepareSearchers(e),n=i.tokenSearchers,s=i.fullSearcher,r=this._search(n,s),o=r.weights,a=r.results;return this._computeScore(o,a),this.options.shouldSort&&this._sort(a),t.limit&&\"number\"==typeof t.limit&&(a=a.slice(0,t.limit)),this._format(a)}},{key:\"_prepareSearchers\",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:\"\",t=[];if(this.options.tokenize)for(var i=e.split(this.options.tokenSeparator),n=0,s=i.length;n0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1?arguments[1]:void 0,i=this.list,n={},s=[];if(\"string\"==typeof i[0]){for(var r=0,o=i.length;r1)throw new Error(\"Key weight has to be > 0 and <= 1\");p=p.name}else a[p]={weight:1};this._analyze({key:p,value:this.options.getFn(h,p),record:h,index:c},{resultMap:n,results:s,tokenSearchers:e,fullSearcher:t})}return{weights:a,results:s}}},{key:\"_analyze\",value:function(e,t){var i=e.key,n=e.arrayIndex,s=void 0===n?-1:n,r=e.value,o=e.record,c=e.index,l=t.tokenSearchers,h=void 0===l?[]:l,u=t.fullSearcher,d=void 0===u?[]:u,p=t.resultMap,m=void 0===p?{}:p,f=t.results,v=void 0===f?[]:f;if(null!=r){var g=!1,_=-1,b=0;if(\"string\"==typeof r){this._log(\"\\nKey: \".concat(\"\"===i?\"-\":i));var y=d.search(r);if(this._log('Full text: \"'.concat(r,'\", score: ').concat(y.score)),this.options.tokenize){for(var E=r.split(this.options.tokenSeparator),I=[],S=0;S-1&&(P=(P+_)/2),this._log(\"Score average:\",P);var D=!this.options.tokenize||!this.options.matchAllTokens||b>=h.length;if(this._log(\"\\nCheck Matches: \".concat(D)),(g||y.isMatch)&&D){var M=m[c];M?M.output.push({key:i,arrayIndex:s,value:r,score:P,matchedIndices:y.matchedIndices}):(m[c]={item:o,output:[{key:i,arrayIndex:s,value:r,score:P,matchedIndices:y.matchedIndices}]},v.push(m[c]))}}else if(a(r))for(var N=0,F=r.length;N-1&&(o.arrayIndex=r.arrayIndex),t.matches.push(o)}}})),this.options.includeScore&&s.push((function(e,t){t.score=e.score}));for(var r=0,o=e.length;ri)return s(e,this.pattern,n);var o=this.options,a=o.location,c=o.distance,l=o.threshold,h=o.findAllMatches,u=o.minMatchCharLength;return r(e,this.pattern,this.patternAlphabet,{location:a,distance:c,threshold:l,findAllMatches:h,minMatchCharLength:u})}}])&&n(t.prototype,i),a&&n(t,a),e}();e.exports=a},function(e,t){var i=/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g;e.exports=function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:/ +/g,s=new RegExp(t.replace(i,\"\\\\$&\").replace(n,\"|\")),r=e.match(s),o=!!r,a=[];if(o)for(var c=0,l=r.length;c=P;N-=1){var F=N-1,j=i[e.charAt(F)];if(j&&(E[F]=1),M[N]=(M[N+1]<<1|1)&j,0!==T&&(M[N]|=(O[N+1]|O[N])<<1|1|O[N+1]),M[N]&L&&(C=n(t,{errors:T,currentLocation:F,expectedLocation:v,distance:l}))<=_){if(_=C,(b=F)<=v)break;P=Math.max(1,2*v-b)}}if(n(t,{errors:T+1,currentLocation:v,expectedLocation:v,distance:l})>_)break;O=M}return{isMatch:b>=0,score:0===C?.001:C,matchedIndices:s(E,f)}}},function(e,t){e.exports=function(e,t){var i=t.errors,n=void 0===i?0:i,s=t.currentLocation,r=void 0===s?0:s,o=t.expectedLocation,a=void 0===o?0:o,c=t.distance,l=void 0===c?100:c,h=n/e.length,u=Math.abs(a-r);return l?h+u/l:u?1:h}},function(e,t){e.exports=function(){for(var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1,i=[],n=-1,s=-1,r=0,o=e.length;r=t&&i.push([n,s]),n=-1)}return e[r-1]&&r-n>=t&&i.push([n,r-1]),i}},function(e,t){e.exports=function(e){for(var t={},i=e.length,n=0;n/g,\"&rt;\").replace(/-1?e.map((function(e){var i=e;return i.id===parseInt(t.choiceId,10)&&(i.selected=!0),i})):e;case\"REMOVE_ITEM\":return t.choiceId>-1?e.map((function(e){var i=e;return i.id===parseInt(t.choiceId,10)&&(i.selected=!1),i})):e;case\"FILTER_CHOICES\":return e.map((function(e){var i=e;return i.active=t.results.some((function(e){var t=e.item,n=e.score;return t.id===i.id&&(i.score=n,!0)})),i}));case\"ACTIVATE_CHOICES\":return e.map((function(e){var i=e;return i.active=t.active,i}));case\"CLEAR_CHOICES\":return v;default:return e}},general:_}),A=function(e,t){var i=e;if(\"CLEAR_ALL\"===t.type)i=void 0;else if(\"RESET_TO\"===t.type)return O(t.state);return C(i,t)};function L(e,t){for(var i=0;i\"'+I(e)+'\"'},maxItemText:function(e){return\"Only \"+e+\" values can be added\"},valueComparer:function(e,t){return e===t},fuseOptions:{includeScore:!0},callbackOnInit:null,callbackOnCreateTemplates:null,classNames:{containerOuter:\"choices\",containerInner:\"choices__inner\",input:\"choices__input\",inputCloned:\"choices__input--cloned\",list:\"choices__list\",listItems:\"choices__list--multiple\",listSingle:\"choices__list--single\",listDropdown:\"choices__list--dropdown\",item:\"choices__item\",itemSelectable:\"choices__item--selectable\",itemDisabled:\"choices__item--disabled\",itemChoice:\"choices__item--choice\",placeholder:\"choices__placeholder\",group:\"choices__group\",groupHeading:\"choices__heading\",button:\"choices__button\",activeState:\"is-active\",focusState:\"is-focused\",openState:\"is-open\",disabledState:\"is-disabled\",highlightedState:\"is-highlighted\",selectedState:\"is-selected\",flippedState:\"is-flipped\",loadingState:\"is-loading\",noResults:\"has-no-results\",noChoices:\"has-no-choices\"}},D=\"showDropdown\",M=\"hideDropdown\",N=\"change\",F=\"choice\",j=\"search\",K=\"addItem\",R=\"removeItem\",H=\"highlightItem\",B=\"highlightChoice\",V=\"ADD_CHOICE\",G=\"FILTER_CHOICES\",q=\"ACTIVATE_CHOICES\",U=\"CLEAR_CHOICES\",z=\"ADD_GROUP\",W=\"ADD_ITEM\",X=\"REMOVE_ITEM\",$=\"HIGHLIGHT_ITEM\",J=46,Y=8,Z=13,Q=65,ee=27,te=38,ie=40,ne=33,se=34,re=\"text\",oe=\"select-one\",ae=\"select-multiple\",ce=function(){function e(e){var t=e.element,i=e.type,n=e.classNames,s=e.position;this.element=t,this.classNames=n,this.type=i,this.position=s,this.isOpen=!1,this.isFlipped=!1,this.isFocussed=!1,this.isDisabled=!1,this.isLoading=!1,this._onFocus=this._onFocus.bind(this),this._onBlur=this._onBlur.bind(this)}var t=e.prototype;return t.addEventListeners=function(){this.element.addEventListener(\"focus\",this._onFocus),this.element.addEventListener(\"blur\",this._onBlur)},t.removeEventListeners=function(){this.element.removeEventListener(\"focus\",this._onFocus),this.element.removeEventListener(\"blur\",this._onBlur)},t.shouldFlip=function(e){if(\"number\"!=typeof e)return!1;var t=!1;return\"auto\"===this.position?t=!window.matchMedia(\"(min-height: \"+(e+1)+\"px)\").matches:\"top\"===this.position&&(t=!0),t},t.setActiveDescendant=function(e){this.element.setAttribute(\"aria-activedescendant\",e)},t.removeActiveDescendant=function(){this.element.removeAttribute(\"aria-activedescendant\")},t.open=function(e){this.element.classList.add(this.classNames.openState),this.element.setAttribute(\"aria-expanded\",\"true\"),this.isOpen=!0,this.shouldFlip(e)&&(this.element.classList.add(this.classNames.flippedState),this.isFlipped=!0)},t.close=function(){this.element.classList.remove(this.classNames.openState),this.element.setAttribute(\"aria-expanded\",\"false\"),this.removeActiveDescendant(),this.isOpen=!1,this.isFlipped&&(this.element.classList.remove(this.classNames.flippedState),this.isFlipped=!1)},t.focus=function(){this.isFocussed||this.element.focus()},t.addFocusState=function(){this.element.classList.add(this.classNames.focusState)},t.removeFocusState=function(){this.element.classList.remove(this.classNames.focusState)},t.enable=function(){this.element.classList.remove(this.classNames.disabledState),this.element.removeAttribute(\"aria-disabled\"),this.type===oe&&this.element.setAttribute(\"tabindex\",\"0\"),this.isDisabled=!1},t.disable=function(){this.element.classList.add(this.classNames.disabledState),this.element.setAttribute(\"aria-disabled\",\"true\"),this.type===oe&&this.element.setAttribute(\"tabindex\",\"-1\"),this.isDisabled=!0},t.wrap=function(e){!function(e,t){void 0===t&&(t=document.createElement(\"div\")),e.nextSibling?e.parentNode.insertBefore(t,e.nextSibling):e.parentNode.appendChild(t),t.appendChild(e)}(e,this.element)},t.unwrap=function(e){this.element.parentNode.insertBefore(e,this.element),this.element.parentNode.removeChild(this.element)},t.addLoadingState=function(){this.element.classList.add(this.classNames.loadingState),this.element.setAttribute(\"aria-busy\",\"true\"),this.isLoading=!0},t.removeLoadingState=function(){this.element.classList.remove(this.classNames.loadingState),this.element.removeAttribute(\"aria-busy\"),this.isLoading=!1},t._onFocus=function(){this.isFocussed=!0},t._onBlur=function(){this.isFocussed=!1},e}();function le(e,t){for(var i=0;i0?this.element.scrollTop+o-s:e.offsetTop;requestAnimationFrame((function(){i._animateScroll(a,t)}))}},t._scrollDown=function(e,t,i){var n=(i-e)/t,s=n>1?n:1;this.element.scrollTop=e+s},t._scrollUp=function(e,t,i){var n=(e-i)/t,s=n>1?n:1;this.element.scrollTop=e-s},t._animateScroll=function(e,t){var i=this,n=this.element.scrollTop,s=!1;t>0?(this._scrollDown(n,4,e),ne&&(s=!0)),s&&requestAnimationFrame((function(){i._animateScroll(e,t)}))},e}();function de(e,t){for(var i=0;i0?\"treeitem\":\"option\"),Object.assign(g.dataset,{choice:\"\",id:l,value:h,selectText:i}),m?(g.classList.add(a),g.dataset.choiceDisabled=\"\",g.setAttribute(\"aria-disabled\",\"true\")):(g.classList.add(r),g.dataset.choiceSelectable=\"\"),g},input:function(e,t){var i=e.input,n=e.inputCloned,s=Object.assign(document.createElement(\"input\"),{type:\"text\",className:i+\" \"+n,autocomplete:\"off\",autocapitalize:\"off\",spellcheck:!1});return s.setAttribute(\"role\",\"textbox\"),s.setAttribute(\"aria-autocomplete\",\"list\"),s.setAttribute(\"aria-label\",t),s},dropdown:function(e){var t=e.list,i=e.listDropdown,n=document.createElement(\"div\");return n.classList.add(t,i),n.setAttribute(\"aria-expanded\",\"false\"),n},notice:function(e,t,i){var n=e.item,s=e.itemChoice,r=e.noResults,o=e.noChoices;void 0===i&&(i=\"\");var a=[n,s];return\"no-choices\"===i?a.push(o):\"no-results\"===i&&a.push(r),Object.assign(document.createElement(\"div\"),{innerHTML:t,className:a.join(\" \")})},option:function(e){var t=e.label,i=e.value,n=e.customProperties,s=e.active,r=e.disabled,o=new Option(t,i,!1,s);return n&&(o.dataset.customProperties=n),o.disabled=r,o}},be=function(e){return void 0===e&&(e=!0),{type:q,active:e}},ye=function(e,t){return{type:$,id:e,highlighted:t}},Ee=function(e){var t=e.value,i=e.id,n=e.active,s=e.disabled;return{type:z,value:t,id:i,active:n,disabled:s}},Ie=function(e){return{type:\"SET_IS_LOADING\",isLoading:e}};function Se(e,t){for(var i=0;i=0?this._store.getGroupById(s):null;return this._store.dispatch(ye(i,!0)),t&&this.passedElement.triggerEvent(H,{id:i,value:o,label:c,groupValue:l&&l.value?l.value:null}),this},r.unhighlightItem=function(e){if(!e)return this;var t=e.id,i=e.groupId,n=void 0===i?-1:i,s=e.value,r=void 0===s?\"\":s,o=e.label,a=void 0===o?\"\":o,c=n>=0?this._store.getGroupById(n):null;return this._store.dispatch(ye(t,!1)),this.passedElement.triggerEvent(H,{id:t,value:r,label:a,groupValue:c&&c.value?c.value:null}),this},r.highlightAll=function(){var e=this;return this._store.items.forEach((function(t){return e.highlightItem(t)})),this},r.unhighlightAll=function(){var e=this;return this._store.items.forEach((function(t){return e.unhighlightItem(t)})),this},r.removeActiveItemsByValue=function(e){var t=this;return this._store.activeItems.filter((function(t){return t.value===e})).forEach((function(e){return t._removeItem(e)})),this},r.removeActiveItems=function(e){var t=this;return this._store.activeItems.filter((function(t){return t.id!==e})).forEach((function(e){return t._removeItem(e)})),this},r.removeHighlightedItems=function(e){var t=this;return void 0===e&&(e=!1),this._store.highlightedActiveItems.forEach((function(i){t._removeItem(i),e&&t._triggerChange(i.value)})),this},r.showDropdown=function(e){var t=this;return this.dropdown.isActive||requestAnimationFrame((function(){t.dropdown.show(),t.containerOuter.open(t.dropdown.distanceFromTopWindow),!e&&t._canSearch&&t.input.focus(),t.passedElement.triggerEvent(D,{})})),this},r.hideDropdown=function(e){var t=this;return this.dropdown.isActive?(requestAnimationFrame((function(){t.dropdown.hide(),t.containerOuter.close(),!e&&t._canSearch&&(t.input.removeActiveDescendant(),t.input.blur()),t.passedElement.triggerEvent(M,{})})),this):this},r.getValue=function(e){void 0===e&&(e=!1);var t=this._store.activeItems.reduce((function(t,i){var n=e?i.value:i;return t.push(n),t}),[]);return this._isSelectOneElement?t[0]:t},r.setValue=function(e){var t=this;return this.initialised?(e.forEach((function(e){return t._setChoiceOrItem(e)})),this):this},r.setChoiceByValue=function(e){var t=this;return!this.initialised||this._isTextElement||(Array.isArray(e)?e:[e]).forEach((function(e){return t._findAndSelectChoiceByValue(e)})),this},r.setChoices=function(e,t,i,n){var s=this;if(void 0===e&&(e=[]),void 0===t&&(t=\"value\"),void 0===i&&(i=\"label\"),void 0===n&&(n=!1),!this.initialised)throw new ReferenceError(\"setChoices was called on a non-initialized instance of Choices\");if(!this._isSelectElement)throw new TypeError(\"setChoices can't be used with INPUT based Choices\");if(\"string\"!=typeof t||!t)throw new TypeError(\"value parameter must be a name of 'value' field in passed objects\");if(n&&this.clearChoices(),\"function\"==typeof e){var r=e(this);if(\"function\"==typeof Promise&&r instanceof Promise)return new Promise((function(e){return requestAnimationFrame(e)})).then((function(){return s._handleLoadingState(!0)})).then((function(){return r})).then((function(e){return s.setChoices(e,t,i,n)})).catch((function(e){s.config.silent||console.error(e)})).then((function(){return s._handleLoadingState(!1)})).then((function(){return s}));if(!Array.isArray(r))throw new TypeError(\".setChoices first argument function must return either array of choices or Promise, got: \"+typeof r);return this.setChoices(r,t,i,!1)}if(!Array.isArray(e))throw new TypeError(\".setChoices must be called either with array of choices with a function resulting into Promise of array of choices\");return this.containerOuter.removeLoadingState(),this._startLoading(),e.forEach((function(e){e.choices?s._addGroup({id:parseInt(e.id,10)||null,group:e,valueKey:t,labelKey:i}):s._addChoice({value:e[t],label:e[i],isSelected:e.selected,isDisabled:e.disabled,customProperties:e.customProperties,placeholder:e.placeholder})})),this._stopLoading(),this},r.clearChoices=function(){return this._store.dispatch({type:U}),this},r.clearStore=function(){return this._store.dispatch({type:\"CLEAR_ALL\"}),this},r.clearInput=function(){var e=!this._isSelectOneElement;return this.input.clear(e),!this._isTextElement&&this._canSearch&&(this._isSearching=!1,this._store.dispatch(be(!0))),this},r._render=function(){if(!this._store.isLoading()){this._currentState=this._store.state;var e=this._currentState.choices!==this._prevState.choices||this._currentState.groups!==this._prevState.groups||this._currentState.items!==this._prevState.items,t=this._isSelectElement,i=this._currentState.items!==this._prevState.items;e&&(t&&this._renderChoices(),i&&this._renderItems(),this._prevState=this._currentState)}},r._renderChoices=function(){var e=this,t=this._store,i=t.activeGroups,n=t.activeChoices,s=document.createDocumentFragment();if(this.choiceList.clear(),this.config.resetScrollPosition&&requestAnimationFrame((function(){return e.choiceList.scrollToTop()})),i.length>=1&&!this._isSearching){var r=n.filter((function(e){return!0===e.placeholder&&-1===e.groupId}));r.length>=1&&(s=this._createChoicesFragment(r,s)),s=this._createGroupsFragment(i,n,s)}else n.length>=1&&(s=this._createChoicesFragment(n,s));if(s.childNodes&&s.childNodes.length>0){var o=this._store.activeItems,a=this._canAddItem(o,this.input.value);a.response?(this.choiceList.append(s),this._highlightChoice()):this.choiceList.append(this._getTemplate(\"notice\",a.notice))}else{var c,l;this._isSearching?(l=\"function\"==typeof this.config.noResultsText?this.config.noResultsText():this.config.noResultsText,c=this._getTemplate(\"notice\",l,\"no-results\")):(l=\"function\"==typeof this.config.noChoicesText?this.config.noChoicesText():this.config.noChoicesText,c=this._getTemplate(\"notice\",l,\"no-choices\")),this.choiceList.append(c)}},r._renderItems=function(){var e=this._store.activeItems||[];this.itemList.clear();var t=this._createItemsFragment(e);t.childNodes&&this.itemList.append(t)},r._createGroupsFragment=function(e,t,i){var n=this;return void 0===i&&(i=document.createDocumentFragment()),this.config.shouldSort&&e.sort(this.config.sorter),e.forEach((function(e){var s=function(e){return t.filter((function(t){return n._isSelectOneElement?t.groupId===e.id:t.groupId===e.id&&(\"always\"===n.config.renderSelectedChoices||!t.selected)}))}(e);if(s.length>=1){var r=n._getTemplate(\"choiceGroup\",e);i.appendChild(r),n._createChoicesFragment(s,i,!0)}})),i},r._createChoicesFragment=function(e,t,i){var n=this;void 0===t&&(t=document.createDocumentFragment()),void 0===i&&(i=!1);var s=this.config,r=s.renderSelectedChoices,o=s.searchResultLimit,a=s.renderChoiceLimit,c=this._isSearching?w:this.config.sorter,l=function(e){if(\"auto\"!==r||n._isSelectOneElement||!e.selected){var i=n._getTemplate(\"choice\",e,n.config.itemSelectText);t.appendChild(i)}},h=e;\"auto\"!==r||this._isSelectOneElement||(h=e.filter((function(e){return!e.selected})));var u=h.reduce((function(e,t){return t.placeholder?e.placeholderChoices.push(t):e.normalChoices.push(t),e}),{placeholderChoices:[],normalChoices:[]}),d=u.placeholderChoices,p=u.normalChoices;(this.config.shouldSort||this._isSearching)&&p.sort(c);var m=h.length,f=this._isSelectOneElement?[].concat(d,p):p;this._isSearching?m=o:a&&a>0&&!i&&(m=a);for(var v=0;v=n){var o=s?this._searchChoices(e):0;this.passedElement.triggerEvent(j,{value:e,resultCount:o})}else r&&(this._isSearching=!1,this._store.dispatch(be(!0)))}},r._canAddItem=function(e,t){var i=!0,n=\"function\"==typeof this.config.addItemText?this.config.addItemText(t):this.config.addItemText;if(!this._isSelectOneElement){var s=function(e,t,i){return void 0===i&&(i=\"value\"),e.some((function(e){return\"string\"==typeof t?e[i]===t.trim():e[i]===t}))}(e,t);this.config.maxItemCount>0&&this.config.maxItemCount<=e.length&&(i=!1,n=\"function\"==typeof this.config.maxItemText?this.config.maxItemText(this.config.maxItemCount):this.config.maxItemText),!this.config.duplicateItemsAllowed&&s&&i&&(i=!1,n=\"function\"==typeof this.config.uniqueItemText?this.config.uniqueItemText(t):this.config.uniqueItemText),this._isTextElement&&this.config.addItems&&i&&\"function\"==typeof this.config.addItemFilter&&!this.config.addItemFilter(t)&&(i=!1,n=\"function\"==typeof this.config.customAddItemText?this.config.customAddItemText(t):this.config.customAddItemText)}return{response:i,notice:n}},r._searchChoices=function(e){var t=\"string\"==typeof e?e.trim():e,i=\"string\"==typeof this._currentValue?this._currentValue.trim():this._currentValue;if(t.length<1&&t===i+\" \")return 0;var n=this._store.searchableChoices,r=t,o=[].concat(this.config.searchFields),a=Object.assign(this.config.fuseOptions,{keys:o}),c=new s.a(n,a).search(r);return this._currentValue=t,this._highlightPosition=0,this._isSearching=!0,this._store.dispatch(function(e){return{type:G,results:e}}(c)),c.length},r._addEventListeners=function(){var e=document.documentElement;e.addEventListener(\"touchend\",this._onTouchEnd,!0),this.containerOuter.element.addEventListener(\"keydown\",this._onKeyDown,!0),this.containerOuter.element.addEventListener(\"mousedown\",this._onMouseDown,!0),e.addEventListener(\"click\",this._onClick,{passive:!0}),e.addEventListener(\"touchmove\",this._onTouchMove,{passive:!0}),this.dropdown.element.addEventListener(\"mouseover\",this._onMouseOver,{passive:!0}),this._isSelectOneElement&&(this.containerOuter.element.addEventListener(\"focus\",this._onFocus,{passive:!0}),this.containerOuter.element.addEventListener(\"blur\",this._onBlur,{passive:!0})),this.input.element.addEventListener(\"keyup\",this._onKeyUp,{passive:!0}),this.input.element.addEventListener(\"focus\",this._onFocus,{passive:!0}),this.input.element.addEventListener(\"blur\",this._onBlur,{passive:!0}),this.input.element.form&&this.input.element.form.addEventListener(\"reset\",this._onFormReset,{passive:!0}),this.input.addEventListeners()},r._removeEventListeners=function(){var e=document.documentElement;e.removeEventListener(\"touchend\",this._onTouchEnd,!0),this.containerOuter.element.removeEventListener(\"keydown\",this._onKeyDown,!0),this.containerOuter.element.removeEventListener(\"mousedown\",this._onMouseDown,!0),e.removeEventListener(\"click\",this._onClick),e.removeEventListener(\"touchmove\",this._onTouchMove),this.dropdown.element.removeEventListener(\"mouseover\",this._onMouseOver),this._isSelectOneElement&&(this.containerOuter.element.removeEventListener(\"focus\",this._onFocus),this.containerOuter.element.removeEventListener(\"blur\",this._onBlur)),this.input.element.removeEventListener(\"keyup\",this._onKeyUp),this.input.element.removeEventListener(\"focus\",this._onFocus),this.input.element.removeEventListener(\"blur\",this._onBlur),this.input.element.form&&this.input.element.form.removeEventListener(\"reset\",this._onFormReset),this.input.removeEventListeners()},r._onKeyDown=function(e){var t,i=e.target,n=e.keyCode,s=e.ctrlKey,r=e.metaKey,o=this._store.activeItems,a=this.input.isFocussed,c=this.dropdown.isActive,l=this.itemList.hasChildren(),h=String.fromCharCode(n),u=J,d=Y,p=Z,m=Q,f=ee,v=te,g=ie,_=ne,b=se,y=s||r;!this._isTextElement&&/[a-zA-Z0-9-_ ]/.test(h)&&this.showDropdown();var E=((t={})[m]=this._onAKey,t[p]=this._onEnterKey,t[f]=this._onEscapeKey,t[v]=this._onDirectionKey,t[_]=this._onDirectionKey,t[g]=this._onDirectionKey,t[b]=this._onDirectionKey,t[d]=this._onDeleteKey,t[u]=this._onDeleteKey,t);E[n]&&E[n]({event:e,target:i,keyCode:n,metaKey:r,activeItems:o,hasFocusedInput:a,hasActiveDropdown:c,hasItems:l,hasCtrlDownKeyPressed:y})},r._onKeyUp=function(e){var t=e.target,i=e.keyCode,n=this.input.value,s=this._store.activeItems,r=this._canAddItem(s,n),o=J,a=Y;if(this._isTextElement)if(r.notice&&n){var c=this._getTemplate(\"notice\",r.notice);this.dropdown.element.innerHTML=c.outerHTML,this.showDropdown(!0)}else this.hideDropdown(!0);else{var l=(i===o||i===a)&&!t.value,h=!this._isTextElement&&this._isSearching,u=this._canSearch&&r.response;l&&h?(this._isSearching=!1,this._store.dispatch(be(!0))):u&&this._handleSearch(this.input.value)}this._canSearch=this.config.searchEnabled},r._onAKey=function(e){var t=e.hasItems;e.hasCtrlDownKeyPressed&&t&&(this._canSearch=!1,this.config.removeItems&&!this.input.value&&this.input.element===document.activeElement&&this.highlightAll())},r._onEnterKey=function(e){var t=e.event,i=e.target,n=e.activeItems,s=e.hasActiveDropdown,r=Z,o=i.hasAttribute(\"data-button\");if(this._isTextElement&&i.value){var a=this.input.value;this._canAddItem(n,a).response&&(this.hideDropdown(!0),this._addItem({value:a}),this._triggerChange(a),this.clearInput())}if(o&&(this._handleButtonAction(n,i),t.preventDefault()),s){var c=this.dropdown.getChild(\".\"+this.config.classNames.highlightedState);c&&(n[0]&&(n[0].keyCode=r),this._handleChoiceAction(n,c)),t.preventDefault()}else this._isSelectOneElement&&(this.showDropdown(),t.preventDefault())},r._onEscapeKey=function(e){e.hasActiveDropdown&&(this.hideDropdown(!0),this.containerOuter.focus())},r._onDirectionKey=function(e){var t,i,n,s=e.event,r=e.hasActiveDropdown,o=e.keyCode,a=e.metaKey,c=ie,l=ne,h=se;if(r||this._isSelectOneElement){this.showDropdown(),this._canSearch=!1;var u,d=o===c||o===h?1:-1,p=\"[data-choice-selectable]\";if(a||o===h||o===l)u=d>0?this.dropdown.element.querySelector(\"[data-choice-selectable]:last-of-type\"):this.dropdown.element.querySelector(p);else{var m=this.dropdown.element.querySelector(\".\"+this.config.classNames.highlightedState);u=m?function(e,t,i){if(void 0===i&&(i=1),e instanceof Element&&\"string\"==typeof t){for(var n=(i>0?\"next\":\"previous\")+\"ElementSibling\",s=e[n];s;){if(s.matches(t))return s;s=s[n]}return s}}(m,p,d):this.dropdown.element.querySelector(p)}u&&(t=u,i=this.choiceList.element,void 0===(n=d)&&(n=1),t&&(n>0?i.scrollTop+i.offsetHeight>=t.offsetTop+t.offsetHeight:t.offsetTop>=i.scrollTop)||this.choiceList.scrollToChildElement(u,d),this._highlightChoice(u)),s.preventDefault()}},r._onDeleteKey=function(e){var t=e.event,i=e.target,n=e.hasFocusedInput,s=e.activeItems;!n||i.value||this._isSelectOneElement||(this._handleBackspace(s),t.preventDefault())},r._onTouchMove=function(){this._wasTap&&(this._wasTap=!1)},r._onTouchEnd=function(e){var t=(e||e.touches[0]).target;this._wasTap&&this.containerOuter.element.contains(t)&&((t===this.containerOuter.element||t===this.containerInner.element)&&(this._isTextElement?this.input.focus():this._isSelectMultipleElement&&this.showDropdown()),e.stopPropagation()),this._wasTap=!0},r._onMouseDown=function(e){var t=e.target;if(t instanceof HTMLElement){if(we&&this.choiceList.element.contains(t)){var i=this.choiceList.element.firstElementChild,n=\"ltr\"===this._direction?e.offsetX>=i.offsetWidth:e.offsetX0&&this.unhighlightAll(),this.containerOuter.removeFocusState(),this.hideDropdown(!0))},r._onFocus=function(e){var t,i=this,n=e.target;this.containerOuter.element.contains(n)&&((t={}).text=function(){n===i.input.element&&i.containerOuter.addFocusState()},t[\"select-one\"]=function(){i.containerOuter.addFocusState(),n===i.input.element&&i.showDropdown(!0)},t[\"select-multiple\"]=function(){n===i.input.element&&(i.showDropdown(!0),i.containerOuter.addFocusState())},t)[this.passedElement.element.type]()},r._onBlur=function(e){var t=this,i=e.target;if(this.containerOuter.element.contains(i)&&!this._isScrollingOnIe){var n,s=this._store.activeItems.some((function(e){return e.highlighted}));((n={}).text=function(){i===t.input.element&&(t.containerOuter.removeFocusState(),s&&t.unhighlightAll(),t.hideDropdown(!0))},n[\"select-one\"]=function(){t.containerOuter.removeFocusState(),(i===t.input.element||i===t.containerOuter.element&&!t._canSearch)&&t.hideDropdown(!0)},n[\"select-multiple\"]=function(){i===t.input.element&&(t.containerOuter.removeFocusState(),t.hideDropdown(!0),s&&t.unhighlightAll())},n)[this.passedElement.element.type]()}else this._isScrollingOnIe=!1,this.input.element.focus()},r._onFormReset=function(){this._store.dispatch({type:\"RESET_TO\",state:this._initialState})},r._highlightChoice=function(e){var t=this;void 0===e&&(e=null);var i=Array.from(this.dropdown.element.querySelectorAll(\"[data-choice-selectable]\"));if(i.length){var n=e;Array.from(this.dropdown.element.querySelectorAll(\".\"+this.config.classNames.highlightedState)).forEach((function(e){e.classList.remove(t.config.classNames.highlightedState),e.setAttribute(\"aria-selected\",\"false\")})),n?this._highlightPosition=i.indexOf(n):(n=i.length>this._highlightPosition?i[this._highlightPosition]:i[i.length-1])||(n=i[0]),n.classList.add(this.config.classNames.highlightedState),n.setAttribute(\"aria-selected\",\"true\"),this.passedElement.triggerEvent(B,{el:n}),this.dropdown.isActive&&(this.input.setActiveDescendant(n.id),this.containerOuter.setActiveDescendant(n.id))}},r._addItem=function(e){var t=e.value,i=e.label,n=void 0===i?null:i,s=e.choiceId,r=void 0===s?-1:s,o=e.groupId,a=void 0===o?-1:o,c=e.customProperties,l=void 0===c?null:c,h=e.placeholder,u=void 0!==h&&h,d=e.keyCode,p=void 0===d?null:d,m=\"string\"==typeof t?t.trim():t,f=p,v=l,g=this._store.items,_=n||m,b=r||-1,y=a>=0?this._store.getGroupById(a):null,E=g?g.length+1:1;return this.config.prependValue&&(m=this.config.prependValue+m.toString()),this.config.appendValue&&(m+=this.config.appendValue.toString()),this._store.dispatch(function(e){var t=e.value,i=e.label,n=e.id,s=e.choiceId,r=e.groupId,o=e.customProperties,a=e.placeholder,c=e.keyCode;return{type:W,value:t,label:i,id:n,choiceId:s,groupId:r,customProperties:o,placeholder:a,keyCode:c}}({value:m,label:_,id:E,choiceId:b,groupId:a,customProperties:l,placeholder:u,keyCode:f})),this._isSelectOneElement&&this.removeActiveItems(E),this.passedElement.triggerEvent(K,{id:E,value:m,label:_,customProperties:v,groupValue:y&&y.value?y.value:void 0,keyCode:f}),this},r._removeItem=function(e){if(!e||!E(\"Object\",e))return this;var t=e.id,i=e.value,n=e.label,s=e.choiceId,r=e.groupId,o=r>=0?this._store.getGroupById(r):null;return this._store.dispatch(function(e,t){return{type:X,id:e,choiceId:t}}(t,s)),o&&o.value?this.passedElement.triggerEvent(R,{id:t,value:i,label:n,groupValue:o.value}):this.passedElement.triggerEvent(R,{id:t,value:i,label:n}),this},r._addChoice=function(e){var t=e.value,i=e.label,n=void 0===i?null:i,s=e.isSelected,r=void 0!==s&&s,o=e.isDisabled,a=void 0!==o&&o,c=e.groupId,l=void 0===c?-1:c,h=e.customProperties,u=void 0===h?null:h,d=e.placeholder,p=void 0!==d&&d,m=e.keyCode,f=void 0===m?null:m;if(null!=t){var v=this._store.choices,g=n||t,_=v?v.length+1:1,b=this._baseId+\"-\"+this._idNames.itemChoice+\"-\"+_;this._store.dispatch(function(e){var t=e.value,i=e.label,n=e.id,s=e.groupId,r=e.disabled,o=e.elementId,a=e.customProperties,c=e.placeholder,l=e.keyCode;return{type:V,value:t,label:i,id:n,groupId:s,disabled:r,elementId:o,customProperties:a,placeholder:c,keyCode:l}}({id:_,groupId:l,elementId:b,value:t,label:g,disabled:a,customProperties:u,placeholder:p,keyCode:f})),r&&this._addItem({value:t,label:g,choiceId:_,customProperties:u,placeholder:p,keyCode:f})}},r._addGroup=function(e){var t=this,i=e.group,n=e.id,s=e.valueKey,r=void 0===s?\"value\":s,o=e.labelKey,a=void 0===o?\"label\":o,c=E(\"Object\",i)?i.choices:Array.from(i.getElementsByTagName(\"OPTION\")),l=n||Math.floor((new Date).valueOf()*Math.random()),h=!!i.disabled&&i.disabled;c?(this._store.dispatch(Ee({value:i.label,id:l,active:!0,disabled:h})),c.forEach((function(e){var i=e.disabled||e.parentNode&&e.parentNode.disabled;t._addChoice({value:e[r],label:E(\"Object\",e)?e[a]:e.innerHTML,isSelected:e.selected,isDisabled:i,groupId:l,customProperties:e.customProperties,placeholder:e.placeholder})}))):this._store.dispatch(Ee({value:i.label,id:i.id,active:!1,disabled:i.disabled}))},r._getTemplate=function(e){var t;if(!e)return null;for(var i=this.config.classNames,n=arguments.length,s=new Array(n>1?n-1:0),r=1;r{var e;return this.input_el.name=null!==(e=this.model.name)&&void 0!==e?e:\"\"})),this.connect(this.model.properties.value.change,(()=>{this.input_el.value=this.format_value,this.old_value=this.input_el.value})),this.connect(this.model.properties.low.change,(()=>{const{value:e,low:t,high:l}=this.model;null!=t&&null!=l&&d.assert(t<=l,\"Invalid bounds, low must be inferior to high\"),null!=e&&null!=t&&(this.model.value=Math.max(e,t))})),this.connect(this.model.properties.high.change,(()=>{const{value:e,low:t,high:l}=this.model;null!=t&&null!=l&&d.assert(l>=t,\"Invalid bounds, high must be superior to low\"),null!=e&&null!=l&&(this.model.value=Math.min(e,l))})),this.connect(this.model.properties.high.change,(()=>this.input_el.placeholder=this.model.placeholder)),this.connect(this.model.properties.disabled.change,(()=>this.input_el.disabled=this.model.disabled)),this.connect(this.model.properties.placeholder.change,(()=>this.input_el.placeholder=this.model.placeholder))}get format_value(){return null!=this.model.value?this.model.pretty(this.model.value):\"\"}_set_input_filter(e){this.input_el.addEventListener(\"input\",(()=>{const{selectionStart:t,selectionEnd:l}=this.input_el;if(e(this.input_el.value))this.old_value=this.input_el.value;else{const e=this.old_value.length-this.input_el.value.length;this.input_el.value=this.old_value,t&&l&&this.input_el.setSelectionRange(t-1,l+e)}}))}render(){super.render(),this.input_el=a.input({type:\"text\",class:p.input,name:this.model.name,value:this.format_value,disabled:this.model.disabled,placeholder:this.model.placeholder}),this.old_value=this.format_value,this.set_input_filter(),this.input_el.addEventListener(\"change\",(()=>this.change_input())),this.input_el.addEventListener(\"focusout\",(()=>this.input_el.value=this.format_value)),this.group_el.appendChild(this.input_el)}set_input_filter(){\"int\"==this.model.mode?this._set_input_filter((e=>_.test(e))):\"float\"==this.model.mode&&this._set_input_filter((e=>m.test(e)))}bound_value(e){let t=e;const{low:l,high:i}=this.model;return t=null!=l?Math.max(l,t):t,t=null!=i?Math.min(i,t):t,t}get value(){let e=\"\"!=this.input_el.value?Number(this.input_el.value):null;return null!=e&&(e=this.bound_value(e)),e}change_input(){null==this.value?this.model.value=null:Number.isNaN(this.value)||(this.model.value=this.value)}}l.NumericInputView=c,c.__name__=\"NumericInputView\";class v extends h.InputWidget{constructor(e){super(e)}static init_NumericInput(){this.prototype.default_view=c,this.define((({Number:e,String:t,Enum:l,Ref:i,Or:n,Nullable:s})=>({value:[s(e),null],placeholder:[t,\"\"],mode:[l(\"int\",\"float\"),\"int\"],format:[s(n(t,i(o.TickFormatter))),null],low:[s(e),null],high:[s(e),null]})))}_formatter(e,t){return r.isString(t)?u.format(e,t):t.doFormat([e],{loc:0})[0]}pretty(e){return null!=this.format?this._formatter(e,this.format):`${e}`}}l.NumericInput=v,v.__name__=\"NumericInput\",v.init_NumericInput()},\n", + " 455: function _(e,t,r,s,i){s();const n=e(444),_=e(43);class a extends n.MarkupView{render(){super.render();const e=_.pre({style:{overflow:\"auto\"}},this.model.text);this.markup_el.appendChild(e)}}r.PreTextView=a,a.__name__=\"PreTextView\";class o extends n.Markup{constructor(e){super(e)}static init_PreText(){this.prototype.default_view=a}}r.PreText=o,o.__name__=\"PreText\",o.init_PreText()},\n", + " 456: function _(t,o,i,e,a){e();const n=t(1),u=t(430),s=t(43),c=n.__importStar(t(328));class _ extends u.ButtonGroupView{change_active(t){this.model.active!==t&&(this.model.active=t)}_update_active(){const{active:t}=this.model;this._buttons.forEach(((o,i)=>{s.classes(o).toggle(c.active,t===i)}))}}i.RadioButtonGroupView=_,_.__name__=\"RadioButtonGroupView\";class r extends u.ButtonGroup{constructor(t){super(t)}static init_RadioButtonGroup(){this.prototype.default_view=_,this.define((({Int:t,Nullable:o})=>({active:[o(t),null]})))}}i.RadioButtonGroup=r,r.__name__=\"RadioButtonGroup\",r.init_RadioButtonGroup()},\n", + " 457: function _(e,i,t,n,a){n();const s=e(1),o=e(43),l=e(34),d=e(432),p=s.__importStar(e(427));class u extends d.InputGroupView{render(){super.render();const e=o.div({class:[p.input_group,this.model.inline?p.inline:null]});this.el.appendChild(e);const i=l.uniqueId(),{active:t,labels:n}=this.model;this._inputs=[];for(let a=0;athis.change_active(a))),this._inputs.push(s),this.model.disabled&&(s.disabled=!0),a==t&&(s.checked=!0);const l=o.label({},s,o.span({},n[a]));e.appendChild(l)}}change_active(e){this.model.active=e}}t.RadioGroupView=u,u.__name__=\"RadioGroupView\";class r extends d.InputGroup{constructor(e){super(e)}static init_RadioGroup(){this.prototype.default_view=u,this.define((({Boolean:e,Int:i,String:t,Array:n,Nullable:a})=>({active:[a(i),null],labels:[n(t),[]],inline:[e,!1]})))}}t.RadioGroup=r,r.__name__=\"RadioGroup\",r.init_RadioGroup()},\n", + " 458: function _(e,t,i,r,a){r();const n=e(1).__importStar(e(183)),s=e(438),_=e(8);class d extends s.AbstractRangeSliderView{}i.RangeSliderView=d,d.__name__=\"RangeSliderView\";class o extends s.AbstractSlider{constructor(e){super(e),this.behaviour=\"drag\",this.connected=[!1,!0,!1]}static init_RangeSlider(){this.prototype.default_view=d,this.override({format:\"0[.]00\"})}_formatter(e,t){return _.isString(t)?n.format(e,t):t.compute(e)}}i.RangeSlider=o,o.__name__=\"RangeSlider\",o.init_RangeSlider()},\n", + " 459: function _(e,t,n,i,s){i();const l=e(1),u=e(43),a=e(8),o=e(13),_=e(426),p=l.__importStar(e(427));class r extends _.InputWidgetView{constructor(){super(...arguments),this._known_values=new Set}connect_signals(){super.connect_signals();const{value:e,options:t}=this.model.properties;this.on_change(e,(()=>{this._update_value()})),this.on_change(t,(()=>{u.empty(this.input_el),u.append(this.input_el,...this.options_el()),this._update_value()}))}options_el(){const{_known_values:e}=this;function t(t){return t.map((t=>{let n,i;return a.isString(t)?n=i=t:[n,i]=t,e.add(n),u.option({value:n},i)}))}e.clear();const{options:n}=this.model;return a.isArray(n)?t(n):o.entries(n).map((([e,n])=>u.optgroup({label:e},t(n))))}render(){super.render(),this.input_el=u.select({class:p.input,name:this.model.name,disabled:this.model.disabled},this.options_el()),this._update_value(),this.input_el.addEventListener(\"change\",(()=>this.change_input())),this.group_el.appendChild(this.input_el)}change_input(){const e=this.input_el.value;this.model.value=e,super.change_input()}_update_value(){const{value:e}=this.model;this._known_values.has(e)?this.input_el.value=e:this.input_el.removeAttribute(\"value\")}}n.SelectView=r,r.__name__=\"SelectView\";class c extends _.InputWidget{constructor(e){super(e)}static init_Select(){this.prototype.default_view=r,this.define((({String:e,Array:t,Tuple:n,Dict:i,Or:s})=>{const l=t(s(e,n(e,e)));return{value:[e,\"\"],options:[s(l,i(l)),[]]}}))}}n.Select=c,c.__name__=\"Select\",c.init_Select()},\n", + " 460: function _(t,e,i,r,s){r();const _=t(1).__importStar(t(183)),a=t(438),n=t(8);class o extends a.AbstractSliderView{}i.SliderView=o,o.__name__=\"SliderView\";class d extends a.AbstractSlider{constructor(t){super(t),this.behaviour=\"tap\",this.connected=[!0,!1]}static init_Slider(){this.prototype.default_view=o,this.override({format:\"0[.]00\"})}_formatter(t,e){return n.isString(e)?_.format(t,e):e.compute(t)}}i.Slider=d,d.__name__=\"Slider\",d.init_Slider()},\n", + " 461: function _(e,t,i,n,s){n();const l=e(454),o=e(43),{min:r,max:a,floor:h,abs:_}=Math;function u(e){return h(e)!==e?e.toFixed(16).replace(/0+$/,\"\").split(\".\")[1].length:0}class d extends l.NumericInputView{*buttons(){yield this.btn_up_el,yield this.btn_down_el}initialize(){super.initialize(),this._handles={interval:void 0,timeout:void 0},this._interval=200}connect_signals(){super.connect_signals();const e=this.model.properties;this.on_change(e.disabled,(()=>{for(const e of this.buttons())o.toggle_attribute(e,\"disabled\",this.model.disabled)}))}render(){super.render(),this.wrapper_el=o.div({class:\"bk-spin-wrapper\"}),this.group_el.replaceChild(this.wrapper_el,this.input_el),this.btn_up_el=o.button({class:\"bk-spin-btn bk-spin-btn-up\"}),this.btn_down_el=o.button({class:\"bk-spin-btn bk-spin-btn-down\"}),this.wrapper_el.appendChild(this.input_el),this.wrapper_el.appendChild(this.btn_up_el),this.wrapper_el.appendChild(this.btn_down_el);for(const e of this.buttons())o.toggle_attribute(e,\"disabled\",this.model.disabled),e.addEventListener(\"mousedown\",(e=>this._btn_mouse_down(e))),e.addEventListener(\"mouseup\",(()=>this._btn_mouse_up())),e.addEventListener(\"mouseleave\",(()=>this._btn_mouse_leave()));this.input_el.addEventListener(\"keydown\",(e=>this._input_key_down(e))),this.input_el.addEventListener(\"keyup\",(()=>this.model.value_throttled=this.model.value)),this.input_el.addEventListener(\"wheel\",(e=>this._input_mouse_wheel(e))),this.input_el.addEventListener(\"wheel\",function(e,t,i=!1){let n;return function(...s){const l=this,o=i&&void 0===n;void 0!==n&&clearTimeout(n),n=setTimeout((function(){n=void 0,i||e.apply(l,s)}),t),o&&e.apply(l,s)}}((()=>{this.model.value_throttled=this.model.value}),this.model.wheel_wait,!1))}get precision(){const{low:e,high:t,step:i}=this.model,n=u;return a(n(_(null!=e?e:0)),n(_(null!=t?t:0)),n(_(i)))}remove(){this._stop_incrementation(),super.remove()}_start_incrementation(e){clearInterval(this._handles.interval),this._counter=0;const{step:t}=this.model,i=e=>{if(this._counter+=1,this._counter%5==0){const t=Math.floor(this._counter/5);t<10?(clearInterval(this._handles.interval),this._handles.interval=setInterval((()=>i(e)),this._interval/(t+1))):t>=10&&t<=13&&(clearInterval(this._handles.interval),this._handles.interval=setInterval((()=>i(2*e)),this._interval/10))}this.increment(e)};this._handles.interval=setInterval((()=>i(e*t)),this._interval)}_stop_incrementation(){clearTimeout(this._handles.timeout),this._handles.timeout=void 0,clearInterval(this._handles.interval),this._handles.interval=void 0,this.model.value_throttled=this.model.value}_btn_mouse_down(e){e.preventDefault();const t=e.currentTarget===this.btn_up_el?1:-1;this.increment(t*this.model.step),this.input_el.focus(),this._handles.timeout=setTimeout((()=>this._start_incrementation(t)),this._interval)}_btn_mouse_up(){this._stop_incrementation()}_btn_mouse_leave(){this._stop_incrementation()}_input_mouse_wheel(e){if(document.activeElement===this.input_el){e.preventDefault();const t=e.deltaY>0?-1:1;this.increment(t*this.model.step)}}_input_key_down(e){switch(e.keyCode){case o.Keys.Up:return e.preventDefault(),this.increment(this.model.step);case o.Keys.Down:return e.preventDefault(),this.increment(-this.model.step);case o.Keys.PageUp:return e.preventDefault(),this.increment(this.model.page_step_multiplier*this.model.step);case o.Keys.PageDown:return e.preventDefault(),this.increment(-this.model.page_step_multiplier*this.model.step)}}adjust_to_precision(e){return this.bound_value(Number(e.toFixed(this.precision)))}increment(e){const{low:t,high:i}=this.model;null==this.model.value?e>0?this.model.value=null!=t?t:null!=i?r(0,i):0:e<0&&(this.model.value=null!=i?i:null!=t?a(t,0):0):this.model.value=this.adjust_to_precision(this.model.value+e)}change_input(){super.change_input(),this.model.value_throttled=this.model.value}}i.SpinnerView=d,d.__name__=\"SpinnerView\";class p extends l.NumericInput{constructor(e){super(e)}static init_Spinner(){this.prototype.default_view=d,this.define((({Number:e,Nullable:t})=>({value_throttled:[t(e),null],step:[e,1],page_step_multiplier:[e,10],wheel_wait:[e,100]}))),this.override({mode:\"float\"})}}i.Spinner=p,p.__name__=\"Spinner\",p.init_Spinner()},\n", + " 462: function _(e,t,s,n,i){n();const r=e(1),o=e(425),p=e(43),c=r.__importStar(e(427));class l extends o.TextLikeInputView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.rows.change,(()=>this.input_el.rows=this.model.rows)),this.connect(this.model.properties.cols.change,(()=>this.input_el.cols=this.model.cols))}_render_input(){this.input_el=p.textarea({class:c.input})}render(){super.render(),this.input_el.cols=this.model.cols,this.input_el.rows=this.model.rows}}s.TextAreaInputView=l,l.__name__=\"TextAreaInputView\";class _ extends o.TextLikeInput{constructor(e){super(e)}static init_TextAreaInput(){this.prototype.default_view=l,this.define((({Int:e})=>({cols:[e,20],rows:[e,2]}))),this.override({max_length:500})}}s.TextAreaInput=_,_.__name__=\"TextAreaInput\",_.init_TextAreaInput()},\n", + " 463: function _(e,t,i,s,c){s();const o=e(1),a=e(419),n=e(43),l=o.__importStar(e(328));class _ extends a.AbstractButtonView{connect_signals(){super.connect_signals(),this.connect(this.model.properties.active.change,(()=>this._update_active()))}render(){super.render(),this._update_active()}click(){this.model.active=!this.model.active,super.click()}_update_active(){n.classes(this.button_el).toggle(l.active,this.model.active)}}i.ToggleView=_,_.__name__=\"ToggleView\";class g extends a.AbstractButton{constructor(e){super(e)}static init_Toggle(){this.prototype.default_view=_,this.define((({Boolean:e})=>({active:[e,!1]}))),this.override({label:\"Toggle\"})}}i.Toggle=g,g.__name__=\"Toggle\",g.init_Toggle()},\n", + " }, 417, {\"models/widgets/main\":417,\"models/widgets/index\":418,\"models/widgets/abstract_button\":419,\"models/widgets/control\":420,\"models/widgets/widget\":488,\"models/widgets/abstract_icon\":422,\"models/widgets/autocomplete_input\":423,\"models/widgets/text_input\":424,\"models/widgets/text_like_input\":425,\"models/widgets/input_widget\":426,\"styles/widgets/inputs.css\":427,\"models/widgets/button\":428,\"models/widgets/checkbox_button_group\":429,\"models/widgets/button_group\":430,\"models/widgets/checkbox_group\":431,\"models/widgets/input_group\":432,\"models/widgets/color_picker\":433,\"models/widgets/date_picker\":434,\"styles/widgets/flatpickr.css\":436,\"models/widgets/date_range_slider\":437,\"models/widgets/abstract_slider\":438,\"styles/widgets/sliders.css\":440,\"styles/widgets/nouislider.css\":441,\"models/widgets/date_slider\":442,\"models/widgets/div\":443,\"models/widgets/markup\":444,\"styles/clearfix.css\":445,\"models/widgets/dropdown\":446,\"models/widgets/file_input\":447,\"models/widgets/multiselect\":448,\"models/widgets/paragraph\":449,\"models/widgets/password_input\":450,\"models/widgets/multichoice\":451,\"styles/widgets/choices.css\":453,\"models/widgets/numeric_input\":454,\"models/widgets/pretext\":455,\"models/widgets/radio_button_group\":456,\"models/widgets/radio_group\":457,\"models/widgets/range_slider\":458,\"models/widgets/selectbox\":459,\"models/widgets/slider\":460,\"models/widgets/spinner\":461,\"models/widgets/textarea_input\":462,\"models/widgets/toggle\":463}, {});});\n", + "\n", + " /* END bokeh-widgets.min.js */\n", + " },\n", + " \n", + " function(Bokeh) {\n", + " /* BEGIN bokeh-tables.min.js */\n", + " /*!\n", + " * Copyright (c) 2012 - 2021, Anaconda, Inc., and Bokeh Contributors\n", + " * All rights reserved.\n", + " * \n", + " * Redistribution and use in source and binary forms, with or without modification,\n", + " * are permitted provided that the following conditions are met:\n", + " * \n", + " * Redistributions of source code must retain the above copyright notice,\n", + " * this list of conditions and the following disclaimer.\n", + " * \n", + " * Redistributions in binary form must reproduce the above copyright notice,\n", + " * this list of conditions and the following disclaimer in the documentation\n", + " * and/or other materials provided with the distribution.\n", + " * \n", + " * Neither the name of Anaconda nor the names of any contributors\n", + " * may be used to endorse or promote products derived from this software\n", + " * without specific prior written permission.\n", + " * \n", + " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n", + " * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n", + " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n", + " * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n", + " * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n", + " * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n", + " * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n", + " * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n", + " * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n", + " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n", + " * THE POSSIBILITY OF SUCH DAMAGE.\n", + " */\n", + " (function(root, factory) {\n", + " factory(root[\"Bokeh\"], \"2.3.3\");\n", + " })(this, function(Bokeh, version) {\n", + " var define;\n", + " return (function(modules, entry, aliases, externals) {\n", + " const bokeh = typeof Bokeh !== \"undefined\" && (version != null ? Bokeh[version] : Bokeh);\n", + " if (bokeh != null) {\n", + " return bokeh.register_plugin(modules, entry, aliases);\n", + " } else {\n", + " throw new Error(\"Cannot find Bokeh \" + version + \". You have to load it prior to loading plugins.\");\n", + " }\n", + " })\n", + " ({\n", + " 464: function _(t,e,o,r,s){r();const _=t(1).__importStar(t(465));o.Tables=_;t(7).register_models(_)},\n", + " 465: function _(g,a,r,e,t){e();const o=g(1);o.__exportStar(g(466),r),o.__exportStar(g(469),r),t(\"DataTable\",g(472).DataTable),t(\"TableColumn\",g(490).TableColumn),t(\"TableWidget\",g(489).TableWidget);var n=g(492);t(\"AvgAggregator\",n.AvgAggregator),t(\"MinAggregator\",n.MinAggregator),t(\"MaxAggregator\",n.MaxAggregator),t(\"SumAggregator\",n.SumAggregator);var A=g(493);t(\"GroupingInfo\",A.GroupingInfo),t(\"DataCube\",A.DataCube)},\n", + " 466: function _(e,t,i,s,r){s();const a=e(1),n=e(43),l=e(240),u=e(53),d=e(467),o=a.__importStar(e(468));class _ extends l.DOMView{constructor(e){const{model:t,parent:i}=e.column;super(Object.assign({model:t,parent:i},e)),this.args=e,this.initialize(),this.render()}get emptyValue(){return null}initialize(){super.initialize(),this.inputEl=this._createInput(),this.defaultValue=null}async lazy_initialize(){throw new Error(\"unsupported\")}css_classes(){return super.css_classes().concat(o.cell_editor)}render(){super.render(),this.args.container.append(this.el),this.el.appendChild(this.inputEl),this.renderEditor(),this.disableNavigation()}renderEditor(){}disableNavigation(){this.inputEl.addEventListener(\"keydown\",(e=>{switch(e.keyCode){case n.Keys.Left:case n.Keys.Right:case n.Keys.Up:case n.Keys.Down:case n.Keys.PageUp:case n.Keys.PageDown:e.stopImmediatePropagation()}}))}destroy(){this.remove()}focus(){this.inputEl.focus()}show(){}hide(){}position(){}getValue(){return this.inputEl.value}setValue(e){this.inputEl.value=e}serializeValue(){return this.getValue()}isValueChanged(){return!(\"\"==this.getValue()&&null==this.defaultValue)&&this.getValue()!==this.defaultValue}applyValue(e,t){const i=this.args.grid.getData(),s=i.index.indexOf(e[d.DTINDEX_NAME]);i.setField(s,this.args.column.field,t)}loadValue(e){const t=e[this.args.column.field];this.defaultValue=null!=t?t:this.emptyValue,this.setValue(this.defaultValue)}validateValue(e){if(this.args.column.validator){const t=this.args.column.validator(e);if(!t.valid)return t}return{valid:!0,msg:null}}validate(){return this.validateValue(this.getValue())}}i.CellEditorView=_,_.__name__=\"CellEditorView\";class c extends u.Model{}i.CellEditor=c,c.__name__=\"CellEditor\";class p extends _{get emptyValue(){return\"\"}_createInput(){return n.input({type:\"text\"})}renderEditor(){this.inputEl.focus(),this.inputEl.select()}loadValue(e){super.loadValue(e),this.inputEl.defaultValue=this.defaultValue,this.inputEl.select()}}i.StringEditorView=p,p.__name__=\"StringEditorView\";class h extends c{static init_StringEditor(){this.prototype.default_view=p,this.define((({String:e,Array:t})=>({completions:[t(e),[]]})))}}i.StringEditor=h,h.__name__=\"StringEditor\",h.init_StringEditor();class E extends _{_createInput(){return n.textarea()}renderEditor(){this.inputEl.focus(),this.inputEl.select()}}i.TextEditorView=E,E.__name__=\"TextEditorView\";class V extends c{static init_TextEditor(){this.prototype.default_view=E}}i.TextEditor=V,V.__name__=\"TextEditor\",V.init_TextEditor();class m extends _{_createInput(){return n.select()}renderEditor(){for(const e of this.model.options)this.inputEl.appendChild(n.option({value:e},e));this.focus()}}i.SelectEditorView=m,m.__name__=\"SelectEditorView\";class f extends c{static init_SelectEditor(){this.prototype.default_view=m,this.define((({String:e,Array:t})=>({options:[t(e),[]]})))}}i.SelectEditor=f,f.__name__=\"SelectEditor\",f.init_SelectEditor();class x extends _{_createInput(){return n.input({type:\"text\"})}}i.PercentEditorView=x,x.__name__=\"PercentEditorView\";class g extends c{static init_PercentEditor(){this.prototype.default_view=x}}i.PercentEditor=g,g.__name__=\"PercentEditor\",g.init_PercentEditor();class w extends _{_createInput(){return n.input({type:\"checkbox\"})}renderEditor(){this.focus()}loadValue(e){this.defaultValue=!!e[this.args.column.field],this.inputEl.checked=this.defaultValue}serializeValue(){return this.inputEl.checked}}i.CheckboxEditorView=w,w.__name__=\"CheckboxEditorView\";class v extends c{static init_CheckboxEditor(){this.prototype.default_view=w}}i.CheckboxEditor=v,v.__name__=\"CheckboxEditor\",v.init_CheckboxEditor();class y extends _{_createInput(){return n.input({type:\"text\"})}renderEditor(){this.inputEl.focus(),this.inputEl.select()}remove(){super.remove()}serializeValue(){var e;return null!==(e=parseInt(this.getValue(),10))&&void 0!==e?e:0}loadValue(e){super.loadValue(e),this.inputEl.defaultValue=this.defaultValue,this.inputEl.select()}validateValue(e){return isNaN(e)?{valid:!1,msg:\"Please enter a valid integer\"}:super.validateValue(e)}}i.IntEditorView=y,y.__name__=\"IntEditorView\";class I extends c{static init_IntEditor(){this.prototype.default_view=y,this.define((({Int:e})=>({step:[e,1]})))}}i.IntEditor=I,I.__name__=\"IntEditor\",I.init_IntEditor();class b extends _{_createInput(){return n.input({type:\"text\"})}renderEditor(){this.inputEl.focus(),this.inputEl.select()}remove(){super.remove()}serializeValue(){var e;return null!==(e=parseFloat(this.getValue()))&&void 0!==e?e:0}loadValue(e){super.loadValue(e),this.inputEl.defaultValue=this.defaultValue,this.inputEl.select()}validateValue(e){return isNaN(e)?{valid:!1,msg:\"Please enter a valid number\"}:super.validateValue(e)}}i.NumberEditorView=b,b.__name__=\"NumberEditorView\";class N extends c{static init_NumberEditor(){this.prototype.default_view=b,this.define((({Number:e})=>({step:[e,.01]})))}}i.NumberEditor=N,N.__name__=\"NumberEditor\",N.init_NumberEditor();class S extends _{_createInput(){return n.input({type:\"text\"})}}i.TimeEditorView=S,S.__name__=\"TimeEditorView\";class C extends c{static init_TimeEditor(){this.prototype.default_view=S}}i.TimeEditor=C,C.__name__=\"TimeEditor\",C.init_TimeEditor();class D extends _{_createInput(){return n.input({type:\"text\"})}get emptyValue(){return new Date}renderEditor(){this.inputEl.focus(),this.inputEl.select()}destroy(){super.destroy()}show(){super.show()}hide(){super.hide()}position(){return super.position()}getValue(){}setValue(e){}}i.DateEditorView=D,D.__name__=\"DateEditorView\";class T extends c{static init_DateEditor(){this.prototype.default_view=D}}i.DateEditor=T,T.__name__=\"DateEditor\",T.init_DateEditor()},\n", + " 467: function _(_,n,i,t,d){t(),i.DTINDEX_NAME=\"__bkdt_internal_index__\"},\n", + " 468: function _(e,l,o,t,r){t(),o.root=\"bk-root\",o.data_table=\"bk-data-table\",o.cell_special_defaults=\"bk-cell-special-defaults\",o.cell_select=\"bk-cell-select\",o.cell_index=\"bk-cell-index\",o.header_index=\"bk-header-index\",o.cell_editor=\"bk-cell-editor\",o.cell_editor_completion=\"bk-cell-editor-completion\",o.default='.bk-root .bk-data-table{box-sizing:content-box;font-size:11px;}.bk-root .bk-data-table input[type=\"checkbox\"]{margin-left:4px;margin-right:4px;}.bk-root .bk-cell-special-defaults{border-right-color:silver;border-right-style:solid;background:#f5f5f5;}.bk-root .bk-cell-select{border-right-color:silver;border-right-style:solid;background:#f5f5f5;}.bk-root .slick-cell.bk-cell-index{border-right-color:silver;border-right-style:solid;background:#f5f5f5;text-align:right;background:#f0f0f0;color:#909090;}.bk-root .bk-header-index .slick-column-name{float:right;}.bk-root .slick-row.selected .bk-cell-index{background-color:transparent;}.bk-root .slick-row.odd{background:#f0f0f0;}.bk-root .slick-cell{padding-left:4px;padding-right:4px;border-right-color:transparent;border:0.25px solid transparent;}.bk-root .slick-cell .bk{line-height:inherit;}.bk-root .slick-cell.active{border-style:dashed;}.bk-root .slick-cell.selected{background-color:#F0F8FF;}.bk-root .slick-cell.editable{padding-left:0;padding-right:0;}.bk-root .bk-cell-editor{display:contents;}.bk-root .bk-cell-editor input,.bk-root .bk-cell-editor select{width:100%;height:100%;border:0;margin:0;padding:0;outline:0;background:transparent;vertical-align:baseline;}.bk-root .bk-cell-editor input{padding-left:4px;padding-right:4px;}.bk-root .bk-cell-editor-completion{font-size:11px;}'},\n", + " 469: function _(t,e,r,a,n){a();const i=t(1),o=i.__importDefault(t(181)),s=i.__importStar(t(183)),l=t(470),c=t(43),m=t(20),u=t(8),_=t(34),F=t(22),d=t(53);class f extends d.Model{constructor(t){super(t)}doFormat(t,e,r,a,n){return null==r?\"\":(r+\"\").replace(/&/g,\"&\").replace(//g,\">\")}}r.CellFormatter=f,f.__name__=\"CellFormatter\";class h extends f{constructor(t){super(t)}static init_StringFormatter(){this.define((({Color:t,Nullable:e})=>({font_style:[m.FontStyle,\"normal\"],text_align:[m.TextAlign,\"left\"],text_color:[e(t),null]})))}doFormat(t,e,r,a,n){const{font_style:i,text_align:o,text_color:s}=this,l=c.div({},null==r?\"\":`${r}`);switch(i){case\"bold\":l.style.fontWeight=\"bold\";break;case\"italic\":l.style.fontStyle=\"italic\"}return null!=o&&(l.style.textAlign=o),null!=s&&(l.style.color=F.color2css(s)),l.outerHTML}}r.StringFormatter=h,h.__name__=\"StringFormatter\",h.init_StringFormatter();class g extends h{constructor(t){super(t)}static init_ScientificFormatter(){this.define((({Number:t,String:e,Nullable:r})=>({nan_format:[r(e),null],precision:[t,10],power_limit_high:[t,5],power_limit_low:[t,-3]})))}get scientific_limit_low(){return 10**this.power_limit_low}get scientific_limit_high(){return 10**this.power_limit_high}doFormat(t,e,r,a,n){const i=Math.abs(r)<=this.scientific_limit_low||Math.abs(r)>=this.scientific_limit_high;let o=this.precision;return o<1&&(o=1),r=null!=r&&!isNaN(r)||null==this.nan_format?0==r?_.to_fixed(r,1):i?r.toExponential(o):_.to_fixed(r,o):this.nan_format,super.doFormat(t,e,r,a,n)}}r.ScientificFormatter=g,g.__name__=\"ScientificFormatter\",g.init_ScientificFormatter();class p extends h{constructor(t){super(t)}static init_NumberFormatter(){this.define((({String:t,Nullable:e})=>({format:[t,\"0,0\"],language:[t,\"en\"],rounding:[m.RoundingFunction,\"round\"],nan_format:[e(t),null]})))}doFormat(t,e,r,a,n){const{format:i,language:o,nan_format:l}=this,c=(()=>{switch(this.rounding){case\"round\":case\"nearest\":return Math.round;case\"floor\":case\"rounddown\":return Math.floor;case\"ceil\":case\"roundup\":return Math.ceil}})();return r=null!=r&&!isNaN(r)||null==l?s.format(r,i,o,c):l,super.doFormat(t,e,r,a,n)}}r.NumberFormatter=p,p.__name__=\"NumberFormatter\",p.init_NumberFormatter();class S extends f{constructor(t){super(t)}static init_BooleanFormatter(){this.define((({String:t})=>({icon:[t,\"check\"]})))}doFormat(t,e,r,a,n){return r?c.i({class:this.icon}).outerHTML:\"\"}}r.BooleanFormatter=S,S.__name__=\"BooleanFormatter\",S.init_BooleanFormatter();class b extends h{constructor(t){super(t)}static init_DateFormatter(){this.define((({String:t,Nullable:e})=>({format:[t,\"ISO-8601\"],nan_format:[e(t),null]})))}getFormat(){switch(this.format){case\"ATOM\":case\"W3C\":case\"RFC-3339\":case\"ISO-8601\":return\"%Y-%m-%d\";case\"COOKIE\":return\"%a, %d %b %Y\";case\"RFC-850\":return\"%A, %d-%b-%y\";case\"RFC-1123\":case\"RFC-2822\":return\"%a, %e %b %Y\";case\"RSS\":case\"RFC-822\":case\"RFC-1036\":return\"%a, %e %b %y\";case\"TIMESTAMP\":return;default:return this.format}}doFormat(t,e,r,a,n){const{nan_format:i}=this;let s;return s=null!=(r=u.isString(r)?parseInt(r,10):r)&&!isNaN(r)&&-9223372036854776!==r||null==i?null==r?\"\":o.default(r,this.getFormat()):i,super.doFormat(t,e,s,a,n)}}r.DateFormatter=b,b.__name__=\"DateFormatter\",b.init_DateFormatter();class x extends f{constructor(t){super(t)}static init_HTMLTemplateFormatter(){this.define((({String:t})=>({template:[t,\"<%= value %>\"]})))}doFormat(t,e,r,a,n){const{template:i}=this;if(null==r)return\"\";return l._.template(i)(Object.assign(Object.assign({},n),{value:r}))}}r.HTMLTemplateFormatter=x,x.__name__=\"HTMLTemplateFormatter\",x.init_HTMLTemplateFormatter()},\n", + " 470: function _(e,n,t,f,i){var o=e(471),d=o.template;function r(e,n,t){return d(e,n,t)}r._=o,n.exports=r,\"function\"==typeof define&&define.amd?define((function(){return r})):\"undefined\"==typeof window&&\"undefined\"==typeof navigator||(window.UnderscoreTemplate=r)},\n", + " 471: function _(r,e,n,t,a){\n", + " // (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n", + " // Underscore may be freely distributed under the MIT license.\n", + " var u={},c=Array.prototype,o=Object.prototype,l=c.slice,i=o.toString,f=o.hasOwnProperty,s=c.forEach,p=Object.keys,_=Array.isArray,h=function(){},v=h.each=h.forEach=function(r,e,n){if(null!=r)if(s&&r.forEach===s)r.forEach(e,n);else if(r.length===+r.length){for(var t=0,a=r.length;t\":\">\",'\"':\""\",\"'\":\"'\"}},y={escape:new RegExp(\"[\"+h.keys(g.escape).join(\"\")+\"]\",\"g\")};h.each([\"escape\"],(function(r){h[r]=function(e){return null==e?\"\":(\"\"+e).replace(y[r],(function(e){return g[r][e]}))}})),h.templateSettings={evaluate:/<%([\\s\\S]+?)%>/g,interpolate:/<%=([\\s\\S]+?)%>/g,escape:/<%-([\\s\\S]+?)%>/g};var j=/(.)^/,b={\"'\":\"'\",\"\\\\\":\"\\\\\",\"\\r\":\"r\",\"\\n\":\"n\",\"\\t\":\"t\",\"\\u2028\":\"u2028\",\"\\u2029\":\"u2029\"},w=/\\\\|'|\\r|\\n|\\t|\\u2028|\\u2029/g;h.template=function(r,e,n){var t;n=h.defaults({},n,h.templateSettings);var a=new RegExp([(n.escape||j).source,(n.interpolate||j).source,(n.evaluate||j).source].join(\"|\")+\"|$\",\"g\"),u=0,c=\"__p+='\";r.replace(a,(function(e,n,t,a,o){return c+=r.slice(u,o).replace(w,(function(r){return\"\\\\\"+b[r]})),n&&(c+=\"'+\\n((__t=(\"+n+\"))==null?'':_.escape(__t))+\\n'\"),t&&(c+=\"'+\\n((__t=(\"+t+\"))==null?'':__t)+\\n'\"),a&&(c+=\"';\\n\"+a+\"\\n__p+='\"),u=o+e.length,e})),c+=\"';\\n\",n.variable||(c=\"with(obj||{}){\\n\"+c+\"}\\n\"),c=\"var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\\n\"+c+\"return __p;\\n\";try{t=new Function(n.variable||\"obj\",\"_\",c)}catch(r){throw r.source=c,r}if(e)return t(e,h);var o=function(r){return t.call(this,r,h)};return o.source=\"function(\"+(n.variable||\"obj\")+\"){\\n\"+c+\"}\",o},e.exports=h},\n", + " 472: function _(e,t,i,s,o){s();const n=e(1),l=e(473),r=e(477),d=e(478),a=e(479),h=e(34),u=e(8),c=e(9),_=e(13),m=e(19),g=e(488),p=e(467),f=e(489),b=e(490),w=n.__importStar(e(468)),x=w,C=n.__importDefault(e(491));i.AutosizeModes={fit_columns:\"FCV\",fit_viewport:\"FVC\",force_fit:\"LFF\",none:\"NOA\"};let z=!1;class v{constructor(e,t){this.init(e,t)}init(e,t){if(p.DTINDEX_NAME in e.data)throw new Error(`special name ${p.DTINDEX_NAME} cannot be used as a data table column`);this.source=e,this.view=t,this.index=[...this.view.indices]}getLength(){return this.index.length}getItem(e){const t={};for(const i of _.keys(this.source.data))t[i]=this.source.data[i][this.index[e]];return t[p.DTINDEX_NAME]=this.index[e],t}getField(e,t){return t==p.DTINDEX_NAME?this.index[e]:this.source.data[t][this.index[e]]}setField(e,t,i){const s=this.index[e];this.source.patch({[t]:[[s,i]]})}getRecords(){return c.range(0,this.getLength()).map((e=>this.getItem(e)))}getItems(){return this.getRecords()}slice(e,t,i){return e=null!=e?e:0,t=null!=t?t:this.getLength(),i=null!=i?i:1,c.range(e,t,i).map((e=>this.getItem(e)))}sort(e){let t=e.map((e=>[e.sortCol.field,e.sortAsc?1:-1]));0==t.length&&(t=[[p.DTINDEX_NAME,1]]);const i=this.getRecords(),s=this.index.slice();this.index.sort(((e,o)=>{for(const[n,l]of t){const t=i[s.indexOf(e)][n],r=i[s.indexOf(o)][n];if(t!==r)return u.isNumber(t)&&u.isNumber(r)?l*(t-r||+isNaN(t)-+isNaN(r)):`${t}`>`${r}`?l:-l}return 0}))}}i.TableDataProvider=v,v.__name__=\"TableDataProvider\";class A extends g.WidgetView{constructor(){super(...arguments),this._in_selection_update=!1,this._width=null}connect_signals(){super.connect_signals(),this.connect(this.model.change,(()=>this.render())),this.connect(this.model.source.streaming,(()=>this.updateGrid())),this.connect(this.model.source.patching,(()=>this.updateGrid())),this.connect(this.model.source.change,(()=>this.updateGrid())),this.connect(this.model.source.properties.data.change,(()=>this.updateGrid())),this.connect(this.model.source.selected.change,(()=>this.updateSelection())),this.connect(this.model.source.selected.properties.indices.change,(()=>this.updateSelection()))}remove(){var e;null===(e=this.grid)||void 0===e||e.destroy(),super.remove()}styles(){return[...super.styles(),C.default,w.default]}update_position(){super.update_position(),this.grid.resizeCanvas()}after_layout(){super.after_layout(),this.updateLayout(!0,!1)}box_sizing(){const e=super.box_sizing();return\"fit_viewport\"===this.model.autosize_mode&&null!=this._width&&(e.width=this._width),e}updateLayout(e,t){const s=this.autosize;s===i.AutosizeModes.fit_columns||s===i.AutosizeModes.force_fit?(e||this.grid.resizeCanvas(),this.grid.autosizeColumns()):e&&t&&s===i.AutosizeModes.fit_viewport&&this.invalidate_layout()}updateGrid(){if(this.model.view.compute_indices(),this.data.init(this.model.source,this.model.view),this.model.sortable){const e=this.grid.getColumns(),t=this.grid.getSortColumns().map((t=>({sortCol:{field:e[this.grid.getColumnIndex(t.columnId)].field},sortAsc:t.sortAsc})));this.data.sort(t)}this.grid.invalidate(),this.updateLayout(!0,!0)}updateSelection(){if(this._in_selection_update)return;const{selected:e}=this.model.source,t=e.indices.map((e=>this.data.index.indexOf(e))).sort();this._in_selection_update=!0,this.grid.setSelectedRows(t),this._in_selection_update=!1;const i=this.grid.getViewport(),s=this.model.get_scroll_index(i,t);null!=s&&this.grid.scrollRowToTop(s)}newIndexColumn(){return{id:h.uniqueId(),name:this.model.index_header,field:p.DTINDEX_NAME,width:this.model.index_width,behavior:\"select\",cannotTriggerInsert:!0,resizable:!1,selectable:!1,sortable:!0,cssClass:x.cell_index,headerCssClass:x.header_index}}css_classes(){return super.css_classes().concat(x.data_table)}get autosize(){let e;return e=!0===this.model.fit_columns?i.AutosizeModes.force_fit:!1===this.model.fit_columns?i.AutosizeModes.none:i.AutosizeModes[this.model.autosize_mode],e}render(){var e;const t=this.model.columns.map((e=>Object.assign(Object.assign({},e.toColumn()),{parent:this})));let s=null;if(\"checkbox\"==this.model.selectable&&(s=new r.CheckboxSelectColumn({cssClass:x.cell_select}),t.unshift(s.getColumnDefinition())),null!=this.model.index_position){const e=this.model.index_position,i=this.newIndexColumn();-1==e?t.push(i):e<-1?t.splice(e+1,0,i):t.splice(e,0,i)}let{reorderable:o}=this.model;!o||\"undefined\"!=typeof $&&null!=$.fn&&null!=$.fn.sortable||(z||(m.logger.warn(\"jquery-ui is required to enable DataTable.reorderable\"),z=!0),o=!1);let n=-1,h=!1;const{frozen_rows:c,frozen_columns:_}=this.model,g=null==_?-1:_-1;null!=c&&(h=c<0,n=Math.abs(c));const p={enableCellNavigation:!1!==this.model.selectable,enableColumnReorder:o,autosizeColsMode:this.autosize,multiColumnSort:this.model.sortable,editable:this.model.editable,autoEdit:this.model.auto_edit,autoHeight:!1,rowHeight:this.model.row_height,frozenColumn:g,frozenRow:n,frozenBottom:h},f=null!=this.grid;if(this.data=new v(this.model.source,this.model.view),this.grid=new a.Grid(this.el,this.data,t,p),this.autosize==i.AutosizeModes.fit_viewport){this.grid.autosizeColumns();let i=0;for(const s of t)i+=null!==(e=s.width)&&void 0!==e?e:0;this._width=Math.ceil(i)}if(this.grid.onSort.subscribe(((e,t)=>{if(!this.model.sortable)return;const i=t.sortCols;null!=i&&(this.data.sort(i),this.grid.invalidate(),this.updateSelection(),this.grid.render(),this.model.header_row||this._hide_header(),this.model.update_sort_columns(i))})),!1!==this.model.selectable){this.grid.setSelectionModel(new l.RowSelectionModel({selectActiveRow:null==s})),null!=s&&this.grid.registerPlugin(s);const e={dataItemColumnValueExtractor(e,t){let i=e[t.field];return u.isString(i)&&(i=i.replace(/\\n/g,\"\\\\n\")),i},includeHeaderWhenCopying:!1};this.grid.registerPlugin(new d.CellExternalCopyManager(e)),this.grid.onSelectedRowsChanged.subscribe(((e,t)=>{this._in_selection_update||(this.model.source.selected.indices=t.rows.map((e=>this.data.index[e])))})),this.updateSelection(),this.model.header_row||this._hide_header()}f&&this.updateLayout(f,!1)}_hide_header(){for(const e of this.el.querySelectorAll(\".slick-header-columns\"))e.style.height=\"0px\";this.grid.resizeCanvas()}}i.DataTableView=A,A.__name__=\"DataTableView\";class D extends f.TableWidget{constructor(e){super(e),this._sort_columns=[]}get sort_columns(){return this._sort_columns}static init_DataTable(){this.prototype.default_view=A,this.define((({Array:e,Boolean:t,Int:i,Ref:s,String:o,Enum:n,Or:l,Nullable:r})=>({autosize_mode:[n(\"fit_columns\",\"fit_viewport\",\"none\",\"force_fit\"),\"force_fit\"],auto_edit:[t,!1],columns:[e(s(b.TableColumn)),[]],fit_columns:[r(t),null],frozen_columns:[r(i),null],frozen_rows:[r(i),null],sortable:[t,!0],reorderable:[t,!0],editable:[t,!1],selectable:[l(t,n(\"checkbox\")),!0],index_position:[r(i),0],index_header:[o,\"#\"],index_width:[i,40],scroll_to_selection:[t,!0],header_row:[t,!0],row_height:[i,25]}))),this.override({width:600,height:400})}update_sort_columns(e){this._sort_columns=e.map((({sortCol:e,sortAsc:t})=>({field:e.field,sortAsc:t})))}get_scroll_index(e,t){return this.scroll_to_selection&&0!=t.length?c.some(t,(t=>e.top<=t&&t<=e.bottom))?null:Math.max(0,Math.min(...t)-1):null}}i.DataTable=D,D.__name__=\"DataTable\",D.init_DataTable()},\n", + " 473: function _(e,t,n,o,r){var l=e(474),i=e(476);t.exports={RowSelectionModel:function(e){var t,n,o,r=[],c=this,u=new i.EventHandler,s={selectActiveRow:!0};function a(e){return function(){n||(n=!0,e.apply(this,arguments),n=!1)}}function f(e){for(var t=[],n=0;n=0&&r0&&t-1 in e)}w.fn=w.prototype={jquery:b,constructor:w,length:0,toArray:function(){return i.call(this)},get:function(e){return null==e?i.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=w.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return w.each(this,e)},map:function(e){return this.pushStack(w.map(this,(function(t,n){return e.call(t,n,t)})))},slice:function(){return this.pushStack(i.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(w.grep(this,(function(e,t){return(t+1)%2})))},odd:function(){return this.pushStack(w.grep(this,(function(e,t){return t%2})))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n+~]|[\\\\x20\\\\t\\\\r\\\\n\\\\f])[\\\\x20\\\\t\\\\r\\\\n\\\\f]*\"),U=new RegExp(M+\"|>\"),X=new RegExp(F),V=new RegExp(\"^\"+I+\"$\"),G={ID:new RegExp(\"^#(\"+I+\")\"),CLASS:new RegExp(\"^\\\\.(\"+I+\")\"),TAG:new RegExp(\"^(\"+I+\"|[*])\"),ATTR:new RegExp(\"^\"+W),PSEUDO:new RegExp(\"^\"+F),CHILD:new RegExp(\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\([\\\\x20\\\\t\\\\r\\\\n\\\\f]*(even|odd|(([+-]|)(\\\\d*)n|)[\\\\x20\\\\t\\\\r\\\\n\\\\f]*(?:([+-]|)[\\\\x20\\\\t\\\\r\\\\n\\\\f]*(\\\\d+)|))[\\\\x20\\\\t\\\\r\\\\n\\\\f]*\\\\)|)\",\"i\"),bool:new RegExp(\"^(?:\"+R+\")$\",\"i\"),needsContext:new RegExp(\"^[\\\\x20\\\\t\\\\r\\\\n\\\\f]*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\([\\\\x20\\\\t\\\\r\\\\n\\\\f]*((?:-\\\\d)?\\\\d*)[\\\\x20\\\\t\\\\r\\\\n\\\\f]*\\\\)|)(?=[^-]|$)\",\"i\")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\\d$/i,K=/^[^{]+\\{\\s*\\[native \\w/,Z=/^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,ee=/[+~]/,te=new RegExp(\"\\\\\\\\[\\\\da-fA-F]{1,6}[\\\\x20\\\\t\\\\r\\\\n\\\\f]?|\\\\\\\\([^\\\\r\\\\n\\\\f])\",\"g\"),ne=function(e,t){var n=\"0x\"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|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(){p()},ae=be((function(e){return!0===e.disabled&&\"fieldset\"===e.nodeName.toLowerCase()}),{dir:\"parentNode\",next:\"legend\"});try{H.apply(j=O.call(w.childNodes),w.childNodes),j[w.childNodes.length].nodeType}catch(e){H={apply:j.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}function se(e,t,r,i){var o,s,l,c,f,h,y,m=t&&t.ownerDocument,w=t?t.nodeType:9;if(r=r||[],\"string\"!=typeof e||!e||1!==w&&9!==w&&11!==w)return r;if(!i&&(p(t),t=t||d,g)){if(11!==w&&(f=Z.exec(e)))if(o=f[1]){if(9===w){if(!(l=t.getElementById(o)))return r;if(l.id===o)return r.push(l),r}else if(m&&(l=m.getElementById(o))&&x(t,l)&&l.id===o)return r.push(l),r}else{if(f[2])return H.apply(r,t.getElementsByTagName(e)),r;if((o=f[3])&&n.getElementsByClassName&&t.getElementsByClassName)return H.apply(r,t.getElementsByClassName(o)),r}if(n.qsa&&!A[e+\" \"]&&(!v||!v.test(e))&&(1!==w||\"object\"!==t.nodeName.toLowerCase())){if(y=e,m=t,1===w&&(U.test(e)||z.test(e))){for((m=ee.test(e)&&ye(t.parentNode)||t)===t&&n.scope||((c=t.getAttribute(\"id\"))?c=c.replace(re,ie):t.setAttribute(\"id\",c=b)),s=(h=a(e)).length;s--;)h[s]=(c?\"#\"+c:\":scope\")+\" \"+xe(h[s]);y=h.join(\",\")}try{return H.apply(r,m.querySelectorAll(y)),r}catch(t){A(e,!0)}finally{c===b&&t.removeAttribute(\"id\")}}}return u(e.replace($,\"$1\"),t,r,i)}function ue(){var e=[];return function t(n,i){return e.push(n+\" \")>r.cacheLength&&delete t[e.shift()],t[n+\" \"]=i}}function le(e){return e[b]=!0,e}function ce(e){var t=d.createElement(\"fieldset\");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){for(var n=e.split(\"|\"),i=n.length;i--;)r.attrHandle[n[i]]=t}function pe(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 de(e){return function(t){return\"input\"===t.nodeName.toLowerCase()&&t.type===e}}function he(e){return function(t){var n=t.nodeName.toLowerCase();return(\"input\"===n||\"button\"===n)&&t.type===e}}function ge(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&&ae(t)===e:t.disabled===e:\"label\"in t&&t.disabled===e}}function ve(e){return le((function(t){return t=+t,le((function(n,r){for(var i,o=e([],n.length,t),a=o.length;a--;)n[i=o[a]]&&(n[i]=!(r[i]=n[i]))}))}))}function ye(e){return e&&void 0!==e.getElementsByTagName&&e}for(t in n=se.support={},o=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||\"HTML\")},p=se.setDocument=function(e){var t,i,a=e?e.ownerDocument||e:w;return a!=d&&9===a.nodeType&&a.documentElement?(h=(d=a).documentElement,g=!o(d),w!=d&&(i=d.defaultView)&&i.top!==i&&(i.addEventListener?i.addEventListener(\"unload\",oe,!1):i.attachEvent&&i.attachEvent(\"onunload\",oe)),n.scope=ce((function(e){return h.appendChild(e).appendChild(d.createElement(\"div\")),void 0!==e.querySelectorAll&&!e.querySelectorAll(\":scope fieldset div\").length})),n.attributes=ce((function(e){return e.className=\"i\",!e.getAttribute(\"className\")})),n.getElementsByTagName=ce((function(e){return e.appendChild(d.createComment(\"\")),!e.getElementsByTagName(\"*\").length})),n.getElementsByClassName=K.test(d.getElementsByClassName),n.getById=ce((function(e){return h.appendChild(e).id=b,!d.getElementsByName||!d.getElementsByName(b).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&&g){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&&g){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&&g)return t.getElementsByClassName(e)},y=[],v=[],(n.qsa=K.test(d.querySelectorAll))&&(ce((function(e){var t;h.appendChild(e).innerHTML=\"\",e.querySelectorAll(\"[msallowcapture^='']\").length&&v.push(\"[*^$]=[\\\\x20\\\\t\\\\r\\\\n\\\\f]*(?:''|\\\"\\\")\"),e.querySelectorAll(\"[selected]\").length||v.push(\"\\\\[[\\\\x20\\\\t\\\\r\\\\n\\\\f]*(?:value|\"+R+\")\"),e.querySelectorAll(\"[id~=\"+b+\"-]\").length||v.push(\"~=\"),(t=d.createElement(\"input\")).setAttribute(\"name\",\"\"),e.appendChild(t),e.querySelectorAll(\"[name='']\").length||v.push(\"\\\\[[\\\\x20\\\\t\\\\r\\\\n\\\\f]*name[\\\\x20\\\\t\\\\r\\\\n\\\\f]*=[\\\\x20\\\\t\\\\r\\\\n\\\\f]*(?:''|\\\"\\\")\"),e.querySelectorAll(\":checked\").length||v.push(\":checked\"),e.querySelectorAll(\"a#\"+b+\"+*\").length||v.push(\".#.+[+~]\"),e.querySelectorAll(\"\\\\\\f\"),v.push(\"[\\\\r\\\\n\\\\f]\")})),ce((function(e){e.innerHTML=\"\";var t=d.createElement(\"input\");t.setAttribute(\"type\",\"hidden\"),e.appendChild(t).setAttribute(\"name\",\"D\"),e.querySelectorAll(\"[name=d]\").length&&v.push(\"name[\\\\x20\\\\t\\\\r\\\\n\\\\f]*[*^$|!~]?=\"),2!==e.querySelectorAll(\":enabled\").length&&v.push(\":enabled\",\":disabled\"),h.appendChild(e).disabled=!0,2!==e.querySelectorAll(\":disabled\").length&&v.push(\":enabled\",\":disabled\"),e.querySelectorAll(\"*,:x\"),v.push(\",.*:\")}))),(n.matchesSelector=K.test(m=h.matches||h.webkitMatchesSelector||h.mozMatchesSelector||h.oMatchesSelector||h.msMatchesSelector))&&ce((function(e){n.disconnectedMatch=m.call(e,\"*\"),m.call(e,\"[s!='']:x\"),y.push(\"!=\",F)})),v=v.length&&new RegExp(v.join(\"|\")),y=y.length&&new RegExp(y.join(\"|\")),t=K.test(h.compareDocumentPosition),x=t||K.test(h.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},N=t?function(e,t){if(e===t)return f=!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==d||e.ownerDocument==w&&x(w,e)?-1:t==d||t.ownerDocument==w&&x(w,t)?1:c?P(c,e)-P(c,t):0:4&r?-1:1)}:function(e,t){if(e===t)return f=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==d?-1:t==d?1:i?-1:o?1:c?P(c,e)-P(c,t):0;if(i===o)return pe(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)s.unshift(n);for(;a[r]===s[r];)r++;return r?pe(a[r],s[r]):a[r]==w?-1:s[r]==w?1:0},d):d},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(p(e),n.matchesSelector&&g&&!A[t+\" \"]&&(!y||!y.test(t))&&(!v||!v.test(t)))try{var r=m.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){A(t,!0)}return se(t,d,null,[e]).length>0},se.contains=function(e,t){return(e.ownerDocument||e)!=d&&p(e),x(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=d&&p(e);var i=r.attrHandle[t.toLowerCase()],o=i&&D.call(r.attrHandle,t.toLowerCase())?i(e,t,!g):void 0;return void 0!==o?o:n.attributes||!g?e.getAttribute(t):(o=e.getAttributeNode(t))&&o.specified?o.value:null},se.escape=function(e){return(e+\"\").replace(re,ie)},se.error=function(e){throw new Error(\"Syntax error, unrecognized expression: \"+e)},se.uniqueSort=function(e){var t,r=[],i=0,o=0;if(f=!n.detectDuplicates,c=!n.sortStable&&e.slice(0),e.sort(N),f){for(;t=e[o++];)t===e[o]&&(i=r.push(o));for(;i--;)e.splice(r[i],1)}return c=null,e},i=se.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=se.selectors={cacheLength:50,createPseudo:le,match:G,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]||se.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]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||\"\":n&&X.test(n)&&(t=a(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=E[e+\" \"];return t||(t=new RegExp(\"(^|[\\\\x20\\\\t\\\\r\\\\n\\\\f])\"+e+\"(\"+M+\"|$)\"))&&E(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=se.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(B,\" \")+\" \").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),a=\"last\"!==e.slice(-4),s=\"of-type\"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,f,p,d,h,g=o!==a?\"nextSibling\":\"previousSibling\",v=t.parentNode,y=s&&t.nodeName.toLowerCase(),m=!u&&!s,x=!1;if(v){if(o){for(;g;){for(p=t;p=p[g];)if(s?p.nodeName.toLowerCase()===y:1===p.nodeType)return!1;h=g=\"only\"===e&&!h&&\"nextSibling\"}return!0}if(h=[a?v.firstChild:v.lastChild],a&&m){for(x=(d=(l=(c=(f=(p=v)[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]||[])[0]===T&&l[1])&&l[2],p=d&&v.childNodes[d];p=++d&&p&&p[g]||(x=d=0)||h.pop();)if(1===p.nodeType&&++x&&p===t){c[e]=[T,d,x];break}}else if(m&&(x=d=(l=(c=(f=(p=t)[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]||[])[0]===T&&l[1]),!1===x)for(;(p=++d&&p&&p[g]||(x=d=0)||h.pop())&&((s?p.nodeName.toLowerCase()!==y:1!==p.nodeType)||!++x||(m&&((c=(f=p[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]=[T,x]),p!==t)););return(x-=i)===r||x%r==0&&x/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||se.error(\"unsupported pseudo: \"+e);return i[b]?i(t):i.length>1?(n=[e,e,\"\",t],r.setFilters.hasOwnProperty(e.toLowerCase())?le((function(e,n){for(var r,o=i(e,t),a=o.length;a--;)e[r=P(e,o[a])]=!(n[r]=o[a])})):function(e){return i(e,0,n)}):i}},pseudos:{not:le((function(e){var t=[],n=[],r=s(e.replace($,\"$1\"));return r[b]?le((function(e,t,n,i){for(var o,a=r(e,null,i,[]),s=e.length;s--;)(o=a[s])&&(e[s]=!(t[s]=o))})):function(e,i,o){return t[0]=e,r(t,null,o,n),t[0]=null,!n.pop()}})),has:le((function(e){return function(t){return se(e,t).length>0}})),contains:le((function(e){return e=e.replace(te,ne),function(t){return(t.textContent||i(t)).indexOf(e)>-1}})),lang:le((function(e){return V.test(e||\"\")||se.error(\"unsupported lang: \"+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=g?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===h},focus:function(e){return e===d.activeElement&&(!d.hasFocus||d.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!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 Q.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:ve((function(){return[0]})),last:ve((function(e,t){return[t-1]})),eq:ve((function(e,t,n){return[n<0?n+t:n]})),even:ve((function(e,t){for(var n=0;nt?t:n;--r>=0;)e.push(r);return e})),gt:ve((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 Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s-1&&(o[l]=!(a[l]=f))}}else y=Te(y===a?y.splice(h,y.length):y),i?i(null,a,y,u):H.apply(a,y)}))}function Ee(e){for(var t,n,i,o=e.length,a=r.relative[e[0].type],s=a||r.relative[\" \"],u=a?1:0,c=be((function(e){return e===t}),s,!0),f=be((function(e){return P(t,e)>-1}),s,!0),p=[function(e,n,r){var i=!a&&(r||n!==l)||((t=n).nodeType?c(e,n,r):f(e,n,r));return t=null,i}];u1&&we(p),u>1&&xe(e.slice(0,u-1).concat({value:\" \"===e[u-2].type?\"*\":\"\"})).replace($,\"$1\"),n,u0,i=e.length>0,o=function(o,a,s,u,c){var f,h,v,y=0,m=\"0\",x=o&&[],b=[],w=l,C=o||i&&r.find.TAG(\"*\",c),E=T+=null==w?1:Math.random()||.1,S=C.length;for(c&&(l=a==d||a||c);m!==S&&null!=(f=C[m]);m++){if(i&&f){for(h=0,a||f.ownerDocument==d||(p(f),s=!g);v=e[h++];)if(v(f,a||d,s)){u.push(f);break}c&&(T=E)}n&&((f=!v&&f)&&y--,o&&x.push(f))}if(y+=m,n&&m!==y){for(h=0;v=t[h++];)v(x,b,a,s);if(o){if(y>0)for(;m--;)x[m]||b[m]||(b[m]=q.call(u));b=Te(b)}H.apply(u,b),c&&!o&&b.length>0&&y+t.length>1&&se.uniqueSort(u)}return c&&(T=E,l=w),x};return n?le(o):o}(o,i))).selector=e}return s},u=se.select=function(e,t,n,i){var o,u,l,c,f,p=\"function\"==typeof e&&e,d=!i&&a(e=p.selector||e);if(n=n||[],1===d.length){if((u=d[0]=d[0].slice(0)).length>2&&\"ID\"===(l=u[0]).type&&9===t.nodeType&&g&&r.relative[u[1].type]){if(!(t=(r.find.ID(l.matches[0].replace(te,ne),t)||[])[0]))return n;p&&(t=t.parentNode),e=e.slice(u.shift().value.length)}for(o=G.needsContext.test(e)?0:u.length;o--&&(l=u[o],!r.relative[c=l.type]);)if((f=r.find[c])&&(i=f(l.matches[0].replace(te,ne),ee.test(u[0].type)&&ye(t.parentNode)||t))){if(u.splice(o,1),!(e=i.length&&xe(u)))return H.apply(n,i),n;break}}return(p||s(e,d))(i,t,!g,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},n.sortStable=b.split(\"\").sort(N).join(\"\")===b,n.detectDuplicates=!!f,p(),n.sortDetached=ce((function(e){return 1&e.compareDocumentPosition(d.createElement(\"fieldset\"))})),ce((function(e){return e.innerHTML=\"\",\"#\"===e.firstChild.getAttribute(\"href\")}))||fe(\"type|href|height|width\",(function(e,t,n){if(!n)return e.getAttribute(t,\"type\"===t.toLowerCase()?1:2)})),n.attributes&&ce((function(e){return e.innerHTML=\"\",e.firstChild.setAttribute(\"value\",\"\"),\"\"===e.firstChild.getAttribute(\"value\")}))||fe(\"value\",(function(e,t,n){if(!n&&\"input\"===e.nodeName.toLowerCase())return e.defaultValue})),ce((function(e){return null==e.getAttribute(\"disabled\")}))||fe(R,(function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null})),se}(e);w.find=C,w.expr=C.selectors,w.expr[\":\"]=w.expr.pseudos,w.uniqueSort=w.unique=C.uniqueSort,w.text=C.getText,w.isXMLDoc=C.isXML,w.contains=C.contains,w.escapeSelector=C.escape;var E=function(e,t,n){for(var r=[],i=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(i&&w(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=w.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i;function D(e,t,n){return h(t)?w.grep(e,(function(e,r){return!!t.call(e,r,e)!==n})):t.nodeType?w.grep(e,(function(e){return e===t!==n})):\"string\"!=typeof t?w.grep(e,(function(e){return s.call(t,e)>-1!==n})):w.filter(t,e,n)}w.filter=function(e,t,n){var r=t[0];return n&&(e=\":not(\"+e+\")\"),1===t.length&&1===r.nodeType?w.find.matchesSelector(r,e)?[r]:[]:w.find.matches(e,w.grep(t,(function(e){return 1===e.nodeType})))},w.fn.extend({find:function(e){var t,n,r=this.length,i=this;if(\"string\"!=typeof e)return this.pushStack(w(e).filter((function(){for(t=0;t1?w.uniqueSort(n):n},filter:function(e){return this.pushStack(D(this,e||[],!1))},not:function(e){return this.pushStack(D(this,e||[],!0))},is:function(e){return!!D(this,\"string\"==typeof e&&k.test(e)?w(e):e||[],!1).length}});var j,q=/^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/;(w.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]:q.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 w?t[0]:t,w.merge(this,w.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:v,!0)),N.test(r[1])&&w.isPlainObject(t))for(r in t)h(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=v.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):h(e)?void 0!==n.ready?n.ready(e):e(w):w.makeArray(e,this)}).prototype=w.fn,j=w(v);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}w.fn.extend({has:function(e){var t=w(e,this),n=t.length;return this.filter((function(){for(var e=0;e-1:1===n.nodeType&&w.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(o.length>1?w.uniqueSort(o):o)},index:function(e){return e?\"string\"==typeof e?s.call(w(e),this[0]):s.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(w.uniqueSort(w.merge(this.get(),w(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),w.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return E(e,\"parentNode\")},parentsUntil:function(e,t,n){return E(e,\"parentNode\",n)},next:function(e){return O(e,\"nextSibling\")},prev:function(e){return O(e,\"previousSibling\")},nextAll:function(e){return E(e,\"nextSibling\")},prevAll:function(e){return E(e,\"previousSibling\")},nextUntil:function(e,t,n){return E(e,\"nextSibling\",n)},prevUntil:function(e,t,n){return E(e,\"previousSibling\",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,\"template\")&&(e=e.content||e),w.merge([],e.childNodes))}},(function(e,t){w.fn[e]=function(n,r){var i=w.map(this,t,n);return\"Until\"!==e.slice(-5)&&(r=n),r&&\"string\"==typeof r&&(i=w.filter(r,i)),this.length>1&&(H[e]||w.uniqueSort(i),L.test(e)&&i.reverse()),this.pushStack(i)}}));var P=/[^\\x20\\t\\r\\n\\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&h(i=e.promise)?i.call(e).done(t).fail(n):e&&h(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}w.Callbacks=function(e){e=\"string\"==typeof e?function(e){var t={};return w.each(e.match(P)||[],(function(e,n){t[n]=!0})),t}(e):w.extend({},e);var t,n,r,i,o=[],a=[],s=-1,u=function(){for(i=i||e.once,r=t=!0;a.length;s=-1)for(n=a.shift();++s-1;)o.splice(n,1),n<=s&&s--})),this},has:function(e){return e?w.inArray(e,o)>-1:o.length>0},empty:function(){return o&&(o=[]),this},disable:function(){return i=a=[],o=n=\"\",this},disabled:function(){return!o},lock:function(){return i=a=[],n||t||(o=n=\"\"),this},locked:function(){return!!i},fireWith:function(e,n){return i||(n=[e,(n=n||[]).slice?n.slice():n],a.push(n),t||u()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},w.extend({Deferred:function(t){var n=[[\"notify\",\"progress\",w.Callbacks(\"memory\"),w.Callbacks(\"memory\"),2],[\"resolve\",\"done\",w.Callbacks(\"once memory\"),w.Callbacks(\"once memory\"),0,\"resolved\"],[\"reject\",\"fail\",w.Callbacks(\"once memory\"),w.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 w.Deferred((function(t){w.each(n,(function(n,r){var i=h(e[r[4]])&&e[r[4]];o[r[1]]((function(){var e=i&&i.apply(this,arguments);e&&h(e.promise)?e.promise().progress(t.notify).done(t.resolve).fail(t.reject):t[r[0]+\"With\"](this,i?[e]:arguments)}))})),e=null})).promise()},then:function(t,r,i){var o=0;function a(t,n,r,i){return function(){var s=this,u=arguments,l=function(){var e,l;if(!(t=o&&(r!==M&&(s=void 0,u=[e]),n.rejectWith(s,u))}};t?c():(w.Deferred.getStackHook&&(c.stackTrace=w.Deferred.getStackHook()),e.setTimeout(c))}}return w.Deferred((function(e){n[0][3].add(a(0,e,h(i)?i:R,e.notifyWith)),n[1][3].add(a(0,e,h(t)?t:R)),n[2][3].add(a(0,e,h(r)?r:M))})).promise()},promise:function(e){return null!=e?w.extend(e,i):i}},o={};return w.each(n,(function(e,t){var a=t[2],s=t[5];i[t[1]]=a.add,s&&a.add((function(){r=s}),n[3-e][2].disable,n[3-e][3].disable,n[0][2].lock,n[0][3].lock),a.add(t[3].fire),o[t[0]]=function(){return o[t[0]+\"With\"](this===o?void 0:this,arguments),this},o[t[0]+\"With\"]=a.fireWith})),i.promise(o),t&&t.call(o,o),o},when:function(e){var t=arguments.length,n=t,r=Array(n),o=i.call(arguments),a=w.Deferred(),s=function(e){return function(n){r[e]=this,o[e]=arguments.length>1?i.call(arguments):n,--t||a.resolveWith(r,o)}};if(t<=1&&(I(e,a.done(s(n)).resolve,a.reject,!t),\"pending\"===a.state()||h(o[n]&&o[n].then)))return a.then();for(;n--;)I(o[n],s(n),a.reject);return a.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;w.Deferred.exceptionHook=function(t,n){e.console&&e.console.warn&&t&&W.test(t.name)&&e.console.warn(\"jQuery.Deferred exception: \"+t.message,t.stack,n)},w.readyException=function(t){e.setTimeout((function(){throw t}))};var F=w.Deferred();function B(){v.removeEventListener(\"DOMContentLoaded\",B),e.removeEventListener(\"load\",B),w.ready()}w.fn.ready=function(e){return F.then(e).catch((function(e){w.readyException(e)})),this},w.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--w.readyWait:w.isReady)||(w.isReady=!0,!0!==e&&--w.readyWait>0||F.resolveWith(v,[w]))}}),w.ready.then=F.then,\"complete\"===v.readyState||\"loading\"!==v.readyState&&!v.documentElement.doScroll?e.setTimeout(w.ready):(v.addEventListener(\"DOMContentLoaded\",B),e.addEventListener(\"load\",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if(\"object\"===x(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,h(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(w(e),n)})),t))for(;s1,null,!0)},removeData:function(e){return this.each((function(){Q.remove(this,e)}))}}),w.extend({queue:function(e,t,n){var r;if(e)return t=(t||\"fx\")+\"queue\",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,w.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||\"fx\";var n=w.queue(e,t),r=n.length,i=n.shift(),o=w._queueHooks(e,t);\"inprogress\"===i&&(i=n.shift(),r--),i&&(\"fx\"===t&&n.unshift(\"inprogress\"),delete o.stop,i.call(e,(function(){w.dequeue(e,t)}),o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+\"queueHooks\";return Y.get(e,n)||Y.access(e,n,{empty:w.Callbacks(\"once memory\").add((function(){Y.remove(e,[t+\"queue\",n])}))})}}),w.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,ge=/^$|^module$|\\/(?:java|ecma)script/i;fe=v.createDocumentFragment().appendChild(v.createElement(\"div\")),(pe=v.createElement(\"input\")).setAttribute(\"type\",\"radio\"),pe.setAttribute(\"checked\",\"checked\"),pe.setAttribute(\"name\",\"t\"),fe.appendChild(pe),d.checkClone=fe.cloneNode(!0).cloneNode(!0).lastChild.checked,fe.innerHTML=\"\",d.noCloneChecked=!!fe.cloneNode(!0).lastChild.defaultValue,fe.innerHTML=\"\",d.option=!!fe.lastChild;var ve={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&&A(e,t)?w.merge([e],n):n}function me(e,t){for(var n=0,r=e.length;n\",\"\"]);var xe=/<|&#?\\w+;/;function be(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d-1)i&&i.push(o);else if(l=ie(o),a=ye(f.appendChild(o),\"script\"),l&&me(a),n)for(c=0;o=a[c++];)ge.test(o.type||\"\")&&n.push(o);return f}var we=/^key/,Te=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ce=/^([^.]*)(?:\\.(.+)|)/;function Ee(){return!0}function Se(){return!1}function ke(e,t){return e===function(){try{return v.activeElement}catch(e){}}()==(\"focus\"===t)}function Ae(e,t,n,r,i,o){var a,s;if(\"object\"==typeof t){for(s in\"string\"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],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=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return w().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=w.guid++)),e.each((function(){w.event.add(this,t,i,r,n)}))}function Ne(e,t,n){n?(Y.set(e,t,!1),w.event.add(e,t,{namespace:!1,handler:function(e){var r,o,a=Y.get(this,t);if(1&e.isTrigger&&this[t]){if(a.length)(w.event.special[t]||{}).delegateType&&e.stopPropagation();else if(a=i.call(arguments),Y.set(this,t,a),r=n(this,t),this[t](),a!==(o=Y.get(this,t))||r?Y.set(this,t,!1):o={},a!==o)return e.stopImmediatePropagation(),e.preventDefault(),o.value}else a.length&&(Y.set(this,t,{value:w.event.trigger(w.extend(a[0],w.Event.prototype),a.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,t)&&w.event.add(e,t,Ee)}w.event={global:{},add:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(e);if(V(e))for(n.handler&&(n=(o=n).handler,i=o.selector),i&&w.find.matchesSelector(re,i),n.guid||(n.guid=w.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(t){return void 0!==w&&w.event.triggered!==t.type?w.event.dispatch.apply(e,arguments):void 0}),l=(t=(t||\"\").match(P)||[\"\"]).length;l--;)d=g=(s=Ce.exec(t[l])||[])[1],h=(s[2]||\"\").split(\".\").sort(),d&&(f=w.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=w.event.special[d]||{},c=w.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&w.expr.match.needsContext.test(i),namespace:h.join(\".\")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(e,r,h,a)||e.addEventListener&&e.addEventListener(d,a)),f.add&&(f.add.call(e,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),w.event.global[d]=!0)},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){for(l=(t=(t||\"\").match(P)||[\"\"]).length;l--;)if(d=g=(s=Ce.exec(t[l])||[])[1],h=(s[2]||\"\").split(\".\").sort(),d){for(f=w.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp(\"(^|\\\\.)\"+h.join(\"\\\\.(?:.*\\\\.|)\")+\"(\\\\.|$)\"),a=o=p.length;o--;)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&(\"**\"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||w.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)w.event.remove(e,d+t[l],n,r,!0);w.isEmptyObject(u)&&Y.remove(e,\"handle events\")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=w.event.fix(e),l=(Y.get(this,\"events\")||Object.create(null))[u.type]||[],c=w.event.special[u.type]||{};for(s[0]=u,t=1;t=1))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&(\"click\"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n-1:w.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u\\s*$/g;function Le(e,t){return A(e,\"table\")&&A(11!==t.nodeType?t:t.firstChild,\"tr\")&&w(e).children(\"tbody\")[0]||e}function He(e){return e.type=(null!==e.getAttribute(\"type\"))+\"/\"+e.type,e}function Oe(e){return\"true/\"===(e.type||\"\").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute(\"type\"),e}function Pe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,\"handle events\"),s)for(n=0,r=s[i].length;n1&&\"string\"==typeof v&&!d.checkClone&&je.test(v))return e.each((function(i){var o=e.eq(i);y&&(t[0]=v.call(this,i,o.html())),Me(o,t,n,r)}));if(p&&(a=(i=be(t,e[0].ownerDocument,!1,e,r)).firstChild,1===i.childNodes.length&&(i=a),a||r)){for(u=(s=w.map(ye(i,\"script\"),He)).length;f0&&me(a,!u&&ye(e,\"script\")),s},cleanData:function(e){for(var t,n,r,i=w.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?w.event.remove(n,r):w.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),w.fn.extend({detach:function(e){return Ie(this,e,!0)},remove:function(e){return Ie(this,e)},text:function(e){return $(this,(function(e){return void 0===e?w.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 Me(this,arguments,(function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Le(this,e).appendChild(e)}))},prepend:function(){return Me(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Le(this,e);t.insertBefore(e,t.firstChild)}}))},before:function(){return Me(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this)}))},after:function(){return Me(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&&(w.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 w.clone(this,e,t)}))},html:function(e){return $(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&&!De.test(e)&&!ve[(he.exec(e)||[\"\",\"\"])[1].toLowerCase()]){e=w.htmlPrefilter(e);try{for(;n3,re.removeChild(t)),s}}))}();var Ue=[\"Webkit\",\"Moz\",\"ms\"],Xe=v.createElement(\"div\").style,Ve={};function Ge(e){var t=w.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){for(var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;n--;)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ye=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,Je={position:\"absolute\",visibility:\"hidden\",display:\"block\"},Ke={letterSpacing:\"0\",fontWeight:\"400\"};function Ze(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||\"px\"):t}function et(e,t,n,r,i,o){var a=\"width\"===t?1:0,s=0,u=0;if(n===(r?\"border\":\"content\"))return 0;for(;a<4;a+=2)\"margin\"===n&&(u+=w.css(e,n+ne[a],!0,i)),r?(\"content\"===n&&(u-=w.css(e,\"padding\"+ne[a],!0,i)),\"margin\"!==n&&(u-=w.css(e,\"border\"+ne[a]+\"Width\",!0,i))):(u+=w.css(e,\"padding\"+ne[a],!0,i),\"padding\"!==n?u+=w.css(e,\"border\"+ne[a]+\"Width\",!0,i):s+=w.css(e,\"border\"+ne[a]+\"Width\",!0,i));return!r&&o>=0&&(u+=Math.max(0,Math.ceil(e[\"offset\"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function tt(e,t,n){var r=Fe(e),i=(!d.boxSizingReliable()||n)&&\"border-box\"===w.css(e,\"boxSizing\",!1,r),o=i,a=_e(e,t,r),s=\"offset\"+t[0].toUpperCase()+t.slice(1);if(We.test(a)){if(!n)return a;a=\"auto\"}return(!d.boxSizingReliable()&&i||!d.reliableTrDimensions()&&A(e,\"tr\")||\"auto\"===a||!parseFloat(a)&&\"inline\"===w.css(e,\"display\",!1,r))&&e.getClientRects().length&&(i=\"border-box\"===w.css(e,\"boxSizing\",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+et(e,t,n||(i?\"border\":\"content\"),o,r,a)+\"px\"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}w.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=_e(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,a,s=X(t),u=Qe.test(t),l=e.style;if(u||(t=Ge(s)),a=w.cssHooks[t]||w.cssHooks[s],void 0===n)return a&&\"get\"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];\"string\"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o=\"number\"),null!=n&&n==n&&(\"number\"!==o||u||(n+=i&&i[3]||(w.cssNumber[s]?\"\":\"px\")),d.clearCloneStyle||\"\"!==n||0!==t.indexOf(\"background\")||(l[t]=\"inherit\"),a&&\"set\"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Qe.test(t)||(t=Ge(s)),(a=w.cssHooks[t]||w.cssHooks[s])&&\"get\"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=_e(e,t,r)),\"normal\"===i&&t in Ke&&(i=Ke[t]),\"\"===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),w.each([\"height\",\"width\"],(function(e,t){w.cssHooks[t]={get:function(e,n,r){if(n)return!Ye.test(w.css(e,\"display\"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,t,r):Be(e,Je,(function(){return tt(e,t,r)}))},set:function(e,n,r){var i,o=Fe(e),a=!d.scrollboxSize()&&\"absolute\"===o.position,s=(a||r)&&\"border-box\"===w.css(e,\"boxSizing\",!1,o),u=r?et(e,t,r,s,o):0;return s&&a&&(u-=Math.ceil(e[\"offset\"+t[0].toUpperCase()+t.slice(1)]-parseFloat(o[t])-et(e,t,\"border\",!1,o)-.5)),u&&(i=te.exec(n))&&\"px\"!==(i[3]||\"px\")&&(e.style[t]=n,n=w.css(e,t)),Ze(0,n,u)}}})),w.cssHooks.marginLeft=ze(d.reliableMarginLeft,(function(e,t){if(t)return(parseFloat(_e(e,\"marginLeft\"))||e.getBoundingClientRect().left-Be(e,{marginLeft:0},(function(){return e.getBoundingClientRect().left})))+\"px\"})),w.each({margin:\"\",padding:\"\",border:\"Width\"},(function(e,t){w.cssHooks[e+t]={expand:function(n){for(var r=0,i={},o=\"string\"==typeof n?n.split(\" \"):[n];r<4;r++)i[e+ne[r]+t]=o[r]||o[r-2]||o[0];return i}},\"margin\"!==e&&(w.cssHooks[e+t].set=Ze)})),w.fn.extend({css:function(e,t){return $(this,(function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Fe(e),i=t.length;a1)}}),w.Tween=nt,nt.prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||w.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(w.cssNumber[n]?\"\":\"px\")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=w.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):nt.propHooks._default.set(this),this}},nt.prototype.init.prototype=nt.prototype,nt.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=w.css(e.elem,e.prop,\"\"))&&\"auto\"!==t?t:0},set:function(e){w.fx.step[e.prop]?w.fx.step[e.prop](e):1!==e.elem.nodeType||!w.cssHooks[e.prop]&&null==e.elem.style[Ge(e.prop)]?e.elem[e.prop]=e.now:w.style(e.elem,e.prop,e.now+e.unit)}}},nt.propHooks.scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},w.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:\"swing\"},w.fx=nt.prototype.init,w.fx.step={};var rt,it,ot=/^(?:toggle|show|hide)$/,at=/queueHooks$/;function st(){it&&(!1===v.hidden&&e.requestAnimationFrame?e.requestAnimationFrame(st):e.setTimeout(st,w.fx.interval),w.fx.tick())}function ut(){return e.setTimeout((function(){rt=void 0})),rt=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=ne[r])]=i[\"padding\"+n]=e;return t&&(i.opacity=i.width=e),i}function ct(e,t,n){for(var r,i=(ft.tweeners[t]||[]).concat(ft.tweeners[\"*\"]),o=0,a=i.length;o1)},removeAttr:function(e){return this.each((function(){w.removeAttr(this,e)}))}}),w.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return void 0===e.getAttribute?w.prop(e,t,n):(1===o&&w.isXMLDoc(e)||(i=w.attrHooks[t.toLowerCase()]||(w.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void w.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=w.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!d.radioValue&&\"radio\"===t&&A(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(P);if(i&&1===e.nodeType)for(;n=i[r++];)e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?w.removeAttr(e,n):e.setAttribute(n,n),n}},w.each(w.expr.match.bool.source.match(/\\w+/g),(function(e,t){var n=dt[t]||w.find.attr;dt[t]=function(e,t,r){var i,o,a=t.toLowerCase();return r||(o=dt[a],dt[a]=i,i=null!=n(e,t,r)?a:null,dt[a]=o),i}}));var ht=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(P)||[]).join(\" \")}function yt(e){return e.getAttribute&&e.getAttribute(\"class\")||\"\"}function mt(e){return Array.isArray(e)?e:\"string\"==typeof e&&e.match(P)||[]}w.fn.extend({prop:function(e,t){return $(this,w.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each((function(){delete this[w.propFix[e]||e]}))}}),w.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&w.isXMLDoc(e)||(t=w.propFix[t]||t,i=w.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=w.find.attr(e,\"tabindex\");return t?parseInt(t,10):ht.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:\"htmlFor\",class:\"className\"}}),d.optSelected||(w.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)}}),w.each([\"tabIndex\",\"readOnly\",\"maxLength\",\"cellSpacing\",\"cellPadding\",\"rowSpan\",\"colSpan\",\"useMap\",\"frameBorder\",\"contentEditable\"],(function(){w.propFix[this.toLowerCase()]=this})),w.fn.extend({addClass:function(e){var t,n,r,i,o,a,s,u=0;if(h(e))return this.each((function(t){w(this).addClass(e.call(this,t,yt(this)))}));if((t=mt(e)).length)for(;n=this[u++];)if(i=yt(n),r=1===n.nodeType&&\" \"+vt(i)+\" \"){for(a=0;o=t[a++];)r.indexOf(\" \"+o+\" \")<0&&(r+=o+\" \");i!==(s=vt(r))&&n.setAttribute(\"class\",s)}return this},removeClass:function(e){var t,n,r,i,o,a,s,u=0;if(h(e))return this.each((function(t){w(this).removeClass(e.call(this,t,yt(this)))}));if(!arguments.length)return this.attr(\"class\",\"\");if((t=mt(e)).length)for(;n=this[u++];)if(i=yt(n),r=1===n.nodeType&&\" \"+vt(i)+\" \"){for(a=0;o=t[a++];)for(;r.indexOf(\" \"+o+\" \")>-1;)r=r.replace(\" \"+o+\" \",\" \");i!==(s=vt(r))&&n.setAttribute(\"class\",s)}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):h(e)?this.each((function(n){w(this).toggleClass(e.call(this,n,yt(this),t),t)})):this.each((function(){var t,i,o,a;if(r)for(i=0,o=w(this),a=mt(e);t=a[i++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&\"boolean\"!==n||((t=yt(this))&&Y.set(this,\"__className__\",t),this.setAttribute&&this.setAttribute(\"class\",t||!1===e?\"\":Y.get(this,\"__className__\")||\"\"))}))},hasClass:function(e){var t,n,r=0;for(t=\" \"+e+\" \";n=this[r++];)if(1===n.nodeType&&(\" \"+vt(yt(n))+\" \").indexOf(t)>-1)return!0;return!1}});var xt=/\\r/g;w.fn.extend({val:function(e){var t,n,r,i=this[0];return arguments.length?(r=h(e),this.each((function(n){var i;1===this.nodeType&&(null==(i=r?e.call(this,n,w(this).val()):e)?i=\"\":\"number\"==typeof i?i+=\"\":Array.isArray(i)&&(i=w.map(i,(function(e){return null==e?\"\":e+\"\"}))),(t=w.valHooks[this.type]||w.valHooks[this.nodeName.toLowerCase()])&&\"set\"in t&&void 0!==t.set(this,i,\"value\")||(this.value=i))}))):i?(t=w.valHooks[i.type]||w.valHooks[i.nodeName.toLowerCase()])&&\"get\"in t&&void 0!==(n=t.get(i,\"value\"))?n:\"string\"==typeof(n=i.value)?n.replace(xt,\"\"):null==n?\"\":n:void 0}}),w.extend({valHooks:{option:{get:function(e){var t=w.find.attr(e,\"value\");return null!=t?t:vt(w.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a=\"select-one\"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),w.each([\"radio\",\"checkbox\"],(function(){w.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=w.inArray(w(e).val(),t)>-1}},d.checkOn||(w.valHooks[this].get=function(e){return null===e.getAttribute(\"value\")?\"on\":e.value})})),d.focusin=\"onfocusin\"in e;var bt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};w.extend(w.event,{trigger:function(t,n,r,i){var o,a,s,u,l,f,p,d,y=[r||v],m=c.call(t,\"type\")?t.type:t,x=c.call(t,\"namespace\")?t.namespace.split(\".\"):[];if(a=d=s=r=r||v,3!==r.nodeType&&8!==r.nodeType&&!bt.test(m+w.event.triggered)&&(m.indexOf(\".\")>-1&&(x=m.split(\".\"),m=x.shift(),x.sort()),l=m.indexOf(\":\")<0&&\"on\"+m,(t=t[w.expando]?t:new w.Event(m,\"object\"==typeof t&&t)).isTrigger=i?2:3,t.namespace=x.join(\".\"),t.rnamespace=t.namespace?new RegExp(\"(^|\\\\.)\"+x.join(\"\\\\.(?:.*\\\\.|)\")+\"(\\\\.|$)\"):null,t.result=void 0,t.target||(t.target=r),n=null==n?[t]:w.makeArray(n,[t]),p=w.event.special[m]||{},i||!p.trigger||!1!==p.trigger.apply(r,n))){if(!i&&!p.noBubble&&!g(r)){for(u=p.delegateType||m,bt.test(u+m)||(a=a.parentNode);a;a=a.parentNode)y.push(a),s=a;s===(r.ownerDocument||v)&&y.push(s.defaultView||s.parentWindow||e)}for(o=0;(a=y[o++])&&!t.isPropagationStopped();)d=a,t.type=o>1?u:p.bindType||m,(f=(Y.get(a,\"events\")||Object.create(null))[t.type]&&Y.get(a,\"handle\"))&&f.apply(a,n),(f=l&&a[l])&&f.apply&&V(a)&&(t.result=f.apply(a,n),!1===t.result&&t.preventDefault());return t.type=m,i||t.isDefaultPrevented()||p._default&&!1!==p._default.apply(y.pop(),n)||!V(r)||l&&h(r[m])&&!g(r)&&((s=r[l])&&(r[l]=null),w.event.triggered=m,t.isPropagationStopped()&&d.addEventListener(m,wt),r[m](),t.isPropagationStopped()&&d.removeEventListener(m,wt),w.event.triggered=void 0,s&&(r[l]=s)),t.result}},simulate:function(e,t,n){var r=w.extend(new w.Event,n,{type:e,isSimulated:!0});w.event.trigger(r,null,t)}}),w.fn.extend({trigger:function(e,t){return this.each((function(){w.event.trigger(e,t,this)}))},triggerHandler:function(e,t){var n=this[0];if(n)return w.event.trigger(e,t,n,!0)}}),d.focusin||w.each({focus:\"focusin\",blur:\"focusout\"},(function(e,t){var n=function(e){w.event.simulate(t,e.target,w.event.fix(e))};w.event.special[t]={setup:function(){var r=this.ownerDocument||this.document||this,i=Y.access(r,t);i||r.addEventListener(e,n,!0),Y.access(r,t,(i||0)+1)},teardown:function(){var r=this.ownerDocument||this.document||this,i=Y.access(r,t)-1;i?Y.access(r,t,i):(r.removeEventListener(e,n,!0),Y.remove(r,t))}}}));var Tt=e.location,Ct={guid:Date.now()},Et=/\\?/;w.parseXML=function(t){var n;if(!t||\"string\"!=typeof t)return null;try{n=(new e.DOMParser).parseFromString(t,\"text/xml\")}catch(e){n=void 0}return n&&!n.getElementsByTagName(\"parsererror\").length||w.error(\"Invalid XML: \"+t),n};var St=/\\[\\]$/,kt=/\\r?\\n/g,At=/^(?:submit|button|image|reset|file)$/i,Nt=/^(?:input|select|textarea|keygen)/i;function Dt(e,t,n,r){var i;if(Array.isArray(t))w.each(t,(function(t,i){n||St.test(e)?r(e,i):Dt(e+\"[\"+(\"object\"==typeof i&&null!=i?t:\"\")+\"]\",i,n,r)}));else if(n||\"object\"!==x(t))r(e,t);else for(i in t)Dt(e+\"[\"+i+\"]\",t[i],n,r)}w.param=function(e,t){var n,r=[],i=function(e,t){var n=h(t)?t():t;r[r.length]=encodeURIComponent(e)+\"=\"+encodeURIComponent(null==n?\"\":n)};if(null==e)return\"\";if(Array.isArray(e)||e.jquery&&!w.isPlainObject(e))w.each(e,(function(){i(this.name,this.value)}));else for(n in e)Dt(n,e[n],t,i);return r.join(\"&\")},w.fn.extend({serialize:function(){return w.param(this.serializeArray())},serializeArray:function(){return this.map((function(){var e=w.prop(this,\"elements\");return e?w.makeArray(e):this})).filter((function(){var e=this.type;return this.name&&!w(this).is(\":disabled\")&&Nt.test(this.nodeName)&&!At.test(e)&&(this.checked||!de.test(e))})).map((function(e,t){var n=w(this).val();return null==n?null:Array.isArray(n)?w.map(n,(function(e){return{name:t.name,value:e.replace(kt,\"\\r\\n\")}})):{name:t.name,value:n.replace(kt,\"\\r\\n\")}})).get()}});var jt=/%20/g,qt=/#.*$/,Lt=/([?&])_=[^&]*/,Ht=/^(.*?):[ \\t]*([^\\r\\n]*)$/gm,Ot=/^(?:GET|HEAD)$/,Pt=/^\\/\\//,Rt={},Mt={},It=\"*/\".concat(\"*\"),Wt=v.createElement(\"a\");function Ft(e){return function(t,n){\"string\"!=typeof t&&(n=t,t=\"*\");var r,i=0,o=t.toLowerCase().match(P)||[];if(h(n))for(;r=o[i++];)\"+\"===r[0]?(r=r.slice(1)||\"*\",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function Bt(e,t,n,r){var i={},o=e===Mt;function a(s){var u;return i[s]=!0,w.each(e[s]||[],(function(e,s){var l=s(t,n,r);return\"string\"!=typeof l||o||i[l]?o?!(u=l):void 0:(t.dataTypes.unshift(l),a(l),!1)})),u}return a(t.dataTypes[0])||!i[\"*\"]&&a(\"*\")}function $t(e,t){var n,r,i=w.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&w.extend(!0,e,r),e}Wt.href=Tt.href,w.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Tt.href,type:\"GET\",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Tt.protocol),global:!0,processData:!0,async:!0,contentType:\"application/x-www-form-urlencoded; charset=UTF-8\",accepts:{\"*\":It,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\":w.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?$t($t(e,w.ajaxSettings),t):$t(w.ajaxSettings,e)},ajaxPrefilter:Ft(Rt),ajaxTransport:Ft(Mt),ajax:function(t,n){\"object\"==typeof t&&(n=t,t=void 0),n=n||{};var r,i,o,a,s,u,l,c,f,p,d=w.ajaxSetup({},n),h=d.context||d,g=d.context&&(h.nodeType||h.jquery)?w(h):w.event,y=w.Deferred(),m=w.Callbacks(\"once memory\"),x=d.statusCode||{},b={},T={},C=\"canceled\",E={readyState:0,getResponseHeader:function(e){var t;if(l){if(!a)for(a={};t=Ht.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 l?o:null},setRequestHeader:function(e,t){return null==l&&(e=T[e.toLowerCase()]=T[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)E.always(e[E.status]);else for(t in e)x[t]=[x[t],e[t]];return this},abort:function(e){var t=e||C;return r&&r.abort(t),S(0,t),this}};if(y.promise(E),d.url=((t||d.url||Tt.href)+\"\").replace(Pt,Tt.protocol+\"//\"),d.type=n.method||n.type||d.method||d.type,d.dataTypes=(d.dataType||\"*\").toLowerCase().match(P)||[\"\"],null==d.crossDomain){u=v.createElement(\"a\");try{u.href=d.url,u.href=u.href,d.crossDomain=Wt.protocol+\"//\"+Wt.host!=u.protocol+\"//\"+u.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&\"string\"!=typeof d.data&&(d.data=w.param(d.data,d.traditional)),Bt(Rt,d,n,E),l)return E;for(f in(c=w.event&&d.global)&&0==w.active++&&w.event.trigger(\"ajaxStart\"),d.type=d.type.toUpperCase(),d.hasContent=!Ot.test(d.type),i=d.url.replace(qt,\"\"),d.hasContent?d.data&&d.processData&&0===(d.contentType||\"\").indexOf(\"application/x-www-form-urlencoded\")&&(d.data=d.data.replace(jt,\"+\")):(p=d.url.slice(i.length),d.data&&(d.processData||\"string\"==typeof d.data)&&(i+=(Et.test(i)?\"&\":\"?\")+d.data,delete d.data),!1===d.cache&&(i=i.replace(Lt,\"$1\"),p=(Et.test(i)?\"&\":\"?\")+\"_=\"+Ct.guid+++p),d.url=i+p),d.ifModified&&(w.lastModified[i]&&E.setRequestHeader(\"If-Modified-Since\",w.lastModified[i]),w.etag[i]&&E.setRequestHeader(\"If-None-Match\",w.etag[i])),(d.data&&d.hasContent&&!1!==d.contentType||n.contentType)&&E.setRequestHeader(\"Content-Type\",d.contentType),E.setRequestHeader(\"Accept\",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(\"*\"!==d.dataTypes[0]?\", \"+It+\"; q=0.01\":\"\"):d.accepts[\"*\"]),d.headers)E.setRequestHeader(f,d.headers[f]);if(d.beforeSend&&(!1===d.beforeSend.call(h,E,d)||l))return E.abort();if(C=\"abort\",m.add(d.complete),E.done(d.success),E.fail(d.error),r=Bt(Mt,d,n,E)){if(E.readyState=1,c&&g.trigger(\"ajaxSend\",[E,d]),l)return E;d.async&&d.timeout>0&&(s=e.setTimeout((function(){E.abort(\"timeout\")}),d.timeout));try{l=!1,r.send(b,S)}catch(e){if(l)throw e;S(-1,e)}}else S(-1,\"No Transport\");function S(t,n,a,u){var f,p,v,b,T,C=n;l||(l=!0,s&&e.clearTimeout(s),r=void 0,o=u||\"\",E.readyState=t>0?4:0,f=t>=200&&t<300||304===t,a&&(b=function(e,t,n){for(var r,i,o,a,s=e.contents,u=e.dataTypes;\"*\"===u[0];)u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader(\"Content-Type\"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+\" \"+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(d,E,a)),!f&&w.inArray(\"script\",d.dataTypes)>-1&&(d.converters[\"text script\"]=function(){}),b=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];for(o=c.shift();o;)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if(\"*\"===o)o=u;else if(\"*\"!==u&&u!==o){if(!(a=l[u+\" \"+o]||l[\"* \"+o]))for(i in l)if((s=i.split(\" \"))[1]===o&&(a=l[u+\" \"+s[0]]||l[\"* \"+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e.throws)t=a(t);else try{t=a(t)}catch(e){return{state:\"parsererror\",error:a?e:\"No conversion from \"+u+\" to \"+o}}}return{state:\"success\",data:t}}(d,b,E,f),f?(d.ifModified&&((T=E.getResponseHeader(\"Last-Modified\"))&&(w.lastModified[i]=T),(T=E.getResponseHeader(\"etag\"))&&(w.etag[i]=T)),204===t||\"HEAD\"===d.type?C=\"nocontent\":304===t?C=\"notmodified\":(C=b.state,p=b.data,f=!(v=b.error))):(v=C,!t&&C||(C=\"error\",t<0&&(t=0))),E.status=t,E.statusText=(n||C)+\"\",f?y.resolveWith(h,[p,C,E]):y.rejectWith(h,[E,C,v]),E.statusCode(x),x=void 0,c&&g.trigger(f?\"ajaxSuccess\":\"ajaxError\",[E,d,f?p:v]),m.fireWith(h,[E,C]),c&&(g.trigger(\"ajaxComplete\",[E,d]),--w.active||w.event.trigger(\"ajaxStop\")))}return E},getJSON:function(e,t,n){return w.get(e,t,n,\"json\")},getScript:function(e,t){return w.get(e,void 0,t,\"script\")}}),w.each([\"get\",\"post\"],(function(e,t){w[t]=function(e,n,r,i){return h(n)&&(i=i||r,r=n,n=void 0),w.ajax(w.extend({url:e,type:t,dataType:i,data:n,success:r},w.isPlainObject(e)&&e))}})),w.ajaxPrefilter((function(e){var t;for(t in e.headers)\"content-type\"===t.toLowerCase()&&(e.contentType=e.headers[t]||\"\")})),w._evalUrl=function(e,t,n){return w.ajax({url:e,type:\"GET\",dataType:\"script\",cache:!0,async:!1,global:!1,converters:{\"text script\":function(){}},dataFilter:function(e){w.globalEval(e,t,n)}})},w.fn.extend({wrapAll:function(e){var t;return this[0]&&(h(e)&&(e=e.call(this[0])),t=w(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 h(e)?this.each((function(t){w(this).wrapInner(e.call(this,t))})):this.each((function(){var t=w(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)}))},wrap:function(e){var t=h(e);return this.each((function(n){w(this).wrapAll(t?e.call(this,n):e)}))},unwrap:function(e){return this.parent(e).not(\"body\").each((function(){w(this).replaceWith(this.childNodes)})),this}}),w.expr.pseudos.hidden=function(e){return!w.expr.pseudos.visible(e)},w.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},w.ajaxSettings.xhr=function(){try{return new e.XMLHttpRequest}catch(e){}};var _t={0:200,1223:204},zt=w.ajaxSettings.xhr();d.cors=!!zt&&\"withCredentials\"in zt,d.ajax=zt=!!zt,w.ajaxTransport((function(t){var n,r;if(d.cors||zt&&!t.crossDomain)return{send:function(i,o){var a,s=t.xhr();if(s.open(t.type,t.url,t.async,t.username,t.password),t.xhrFields)for(a in t.xhrFields)s[a]=t.xhrFields[a];for(a in t.mimeType&&s.overrideMimeType&&s.overrideMimeType(t.mimeType),t.crossDomain||i[\"X-Requested-With\"]||(i[\"X-Requested-With\"]=\"XMLHttpRequest\"),i)s.setRequestHeader(a,i[a]);n=function(e){return function(){n&&(n=r=s.onload=s.onerror=s.onabort=s.ontimeout=s.onreadystatechange=null,\"abort\"===e?s.abort():\"error\"===e?\"number\"!=typeof s.status?o(0,\"error\"):o(s.status,s.statusText):o(_t[s.status]||s.status,s.statusText,\"text\"!==(s.responseType||\"text\")||\"string\"!=typeof s.responseText?{binary:s.response}:{text:s.responseText},s.getAllResponseHeaders()))}},s.onload=n(),r=s.onerror=s.ontimeout=n(\"error\"),void 0!==s.onabort?s.onabort=r:s.onreadystatechange=function(){4===s.readyState&&e.setTimeout((function(){n&&r()}))},n=n(\"abort\");try{s.send(t.hasContent&&t.data||null)}catch(e){if(n)throw e}},abort:function(){n&&n()}}})),w.ajaxPrefilter((function(e){e.crossDomain&&(e.contents.script=!1)})),w.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 w.globalEval(e),e}}}),w.ajaxPrefilter(\"script\",(function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type=\"GET\")})),w.ajaxTransport(\"script\",(function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(r,i){t=w(\"" + ], + "text/plain": [ + ":HoloMap [Time (TRs)]\n", + " :Chord [source,target] (value,sign)" + ] + }, + "execution_count": 12, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "1001" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# intact\n", + "if debug_mode:\n", + " pthresh = 50\n", + " max_frames = np.min([20, intact_disfc.shape[0], scrambled_disfc.shape[0]])\n", + "else:\n", + " pthresh = 95\n", + " max_frames = np.min([intact_disfc.shape[0], scrambled_disfc.shape[0]])\n", + "cthresh = np.min([np.percentile(np.abs(scrambled_disfc), pthresh), np.percentile(np.abs(intact_disfc), pthresh)])\n", + "\n", + "max_frames = np.min([max_frames, 100]) # comment out this line to display the full animation (takes a long time!)\n", + "animate_chord(intact_disfc[:max_frames, :], cthresh=cthresh)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":HoloMap [Time (TRs)]\n", + " :Chord [source,target] (value,sign)" + ] + }, + "execution_count": 13, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "2743" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# scrambled\n", + "animate_chord(scrambled_disfc[:max_frames, :], cthresh=cthresh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate animated brain network plots\n", + "\n", + "Run the cells below to generate the animations. Individual animated frames may be found in the `intact_frames` and `scrambled_frames` sub-folder of this directory. The frames are stitched together into an mp4 file in order to display the animation in the notebook. You can right-click on the animations to save the files.\n", + "\n", + "The next cell generates an animation for the \"intact\" experimental condition, and the subsequent cell generates an animation for the \"word-scrambled\" experimental condition." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:matplotlib.animation:Animation.save using \n", + "INFO:matplotlib.animation:MovieWriter._run: running command: ffmpeg -f rawvideo -vcodec rawvideo -s 432x288 -pix_fmt rgba -r 20.0 -loglevel error -i pipe: -vcodec h264 -pix_fmt yuv420p -y /tmp/tmpcgcso4cq/temp.m4v\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# intact\n", + "global_centers, global_widths = global_params(htfa)\n", + "\n", + "intact_ani = animate_connectome(global_centers, intact_disfc[:max_frames, :], cthresh=cthresh, figdir='intact_frames')\n", + "HTML(intact_ani.to_html5_video())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:matplotlib.animation:Animation.save using \n", + "INFO:matplotlib.animation:MovieWriter._run: running command: ffmpeg -f rawvideo -vcodec rawvideo -s 432x288 -pix_fmt rgba -r 20.0 -loglevel error -i pipe: -vcodec h264 -pix_fmt yuv420p -y /tmp/tmpwrq7s60h/temp.m4v\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# scrambled\n", + "scrambled_ani = animate_connectome(global_centers, scrambled_disfc[:max_frames, :], cthresh=cthresh, figdir='scrambled_frames')\n", + "HTML(scrambled_ani.to_html5_video())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary\n", + "\n", + "Using HTFA, we were able to quickly and easily examine and compare network dynamic patterns in a large fMRI dataset, using only modest computing resources. The resulting networks are intuitive and straightforward to visualize." + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "name": "data_visualization.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/iem/download_data.sh b/docs/examples/iem/download_data.sh new file mode 100644 index 00000000..22d76214 --- /dev/null +++ b/docs/examples/iem/download_data.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +wget -nc https://zenodo.org/record/4950267/files/RademakerEtAl2019_WM_S05_avgTime.npz +wget -nc https://zenodo.org/record/4950267/files/AL61_Bilat-V1_attnContrast.mat diff --git a/docs/examples/iem/iem.ipynb b/docs/examples/iem/iem.ipynb new file mode 100644 index 00000000..b4b14c33 --- /dev/null +++ b/docs/examples/iem/iem.ipynb @@ -0,0 +1,948 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inverted Encoding Model\n", + "\n", + "Author: Vy Vo (vy.vo@intel.com)\n", + "\n", + "## Overview\n", + "We provide examples of how to use the inverted encoding model (IEM) module in BrainIAK to reconstruct features of stimuli presented to human subjects. First, a forward encoding model is estimated, mapping a set of stimulus features to the accompanying fMRI response in a population of voxels. Then, the model is inverted to allow the user to feed in new fMRI responses and predict the accompanying stimulus features.\n", + "\n", + "The BrainIAK implementation allows for users to specify and fit an encoding model for stimulus features that are represented in either a 1-dimensional, circular space or a 2-dimensional space. We include examples for each of these from real fMRI studies of working memory and attention.\n", + "\n", + "While decoding methods such as support vector machines (SVM) can also take fMRI responses and predict stimulus features, they rely on general purpose algorithms to learn how features are represented in the data. When the encoding model is a better description for the data than a generic decoding algorithm, it is a more efficient way to estimate the response --> stimulus mapping. Our last example simulates responses from 1D receptive fields, and uses either SVM or an IEM to predict the stimulus feature. The IEM achieves higher accuracy with less data.\n", + "\n", + "## Annotated Bibliography\n", + "1. Brouwer, G.J., and Heeger, D.J. (2009). Decoding and reconstructing color from responses in human visual cortex. *Journal of Neuroscience* 29, 13992–14003. [`link`](https://doi.org/10.1523/JNEUROSCI.3577-09.2009) *Uses an inverted encoding model to reconstruct color in a continuous space, demonstrating how color is represented across a hierarchy of visual regions.*\n", + "\n", + "2. Naselaris, T., Kay, K. N., Nishimoto, S., & Gallant, J. L. (2011). Encoding and decoding in fMRI. *NeuroImage* 56(2), 400–410. [`link`](https://doi.org/10.1016/j.neuroimage.2010.07.073) *A review article distinguishing between the different uses of encoding and decoding approaches for fMRI.*\n", + "\n", + "3. Serences, J.T., and Saproo, S. (2012). Computational advances towards linking BOLD and behavior. *Neuropsychologia* 50, 435–446. [`link`](https://doi.org/10.1016/j.neuropsychologia.2011.07.013) *Describes the differences between encoding and decoding approaches and emphasizes how these approaches can test linking hypotheses between fMRI and behavior.*\n", + "\n", + "4. Sprague, T.C., Adam, K.C.S., Foster, J.J., Rahmati, M., Sutterer, D.W., and Vo, V.A. (2018). Inverted encoding models assay population-level stimulus representations, not single-unit neural tuning. *eNeuro* 5, 1–5. [`link`](https://doi.org/10.1523/ENEURO.0098-18.2018) *Argues that inverted encoding models are most useful when using population-level stimulus representations across experimental manipulations to pointedly test psychological theories.*\n", + "\n", + "5. Sprague, T.C., Boynton, G.M., and Serences, J.T. (2019). The importance of considering model choices when interpreting results in computational neuroimaging. *eNeuro* 6, 1–11. [`link`](https://doi.org/10.1523/ENEURO.0196-19.2019) *Describes the encoding model approach in the broader scope of computational models and acknowledges some important limitations.*\n", + "\n", + "## Table of Contents\n", + "* Example 1: Reconstructing items from working memory\n", + "* Example 2: Reconstruct 2D spatial position by contrast and attention\n", + "* Example 3: Comparing SVM and IEM with simulated data and low trial numbers\n", + "* Summary" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from brainiak.reconstruct import iem as IEM\n", + "import matplotlib.pyplot as plt\n", + "import scipy.io" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data associated with these examples are originally derived from these OSF repositories, but have been sorted and cleaned for easier use.\n", + "\n", + "* Dataset 1 from Rademaker et al. 2019, Nat. Neurosci. [Download here](https://zenodo.org/record/4950267/files/RademakerEtAl2019_WM_S05_avgTime.npz?download=1).\n", + "* Dataset 2 from Itthipuripat et al. 2019, J. Neurosci. [Download here](https://zenodo.org/record/4950267/files/AL61_Bilat-V1_attnContrast.mat?download=1).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1: Reconstructing items from working memory " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this study, [Rademaker et al.](https://www.nature.com/articles/s41593-019-0428-x) trained the IEM on an independent dataset where the participants viewed orientation gratings.\n", + "\n", + "In the test data, the participants viewed a target orientation, and held it working memory for 12 seconds. During this delay period, a distractor grating appeared in a portion of the trials. The orientation of the distractor was randomized relative to the remembered orientation.\n", + "\n", + "Using the fMRI data from the delay period, we will reconstruct both the orientation held in WM and the distractor orientation that was simultaneously being viewed. This sample data is from visual area V1." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['trn', 'trn_conds', 'tst_m', 'tst_m_conds', 'tst_d', 'tst_d_conds']\n" + ] + } + ], + "source": [ + "# Load the fMRI data from the WM experiment\n", + "wm_data = np.load(\"RademakerEtAl2019_WM_S05_avgTime.npz\")\n", + "print(list(wm_data.keys()))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up parameters\n", + "n_channels = 9\n", + "cos_exponent = 8\n", + "feature_resolution = 180\n", + "iem_obj0 = IEM.InvertedEncoding1D(n_channels, cos_exponent, \n", + " stimulus_mode='halfcircular',\n", + " channel_density=feature_resolution)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "iem_obj0 = iem_obj0.fit(wm_data['trn'], wm_data['trn_conds'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region so that the sum of all the basis functions is constant across the feature space. You also will likely want to ensure some overlap between the basis functions." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(9, 180)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Sum across channels')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Let's visualize the basis functions.\n", + "channels = iem_obj0.channels_\n", + "feature_axis = iem_obj0.channel_domain\n", + "print(channels.shape)\n", + "\n", + "plt.figure(figsize=[8, 3])\n", + "plt.subplot(1, 2, 1)\n", + "for i in range(0, channels.shape[0]):\n", + " plt.plot(feature_axis, channels[i,:])\n", + "plt.title('Channels (i.e. basis functions)')\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(np.sum(channels, 0))\n", + "plt.ylim(0, 2.5)\n", + "plt.title('Sum across channels')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have trained the IEM, we can test it on our two different conditions: holding an orientation in working memory, or viewing it as a distractor. Let's first look at the memory condition." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Test the model on remembered orientation\n", + "tst_mem_tc = wm_data['tst_m']\n", + "n_tst_mem, n_vox = tst_mem_tc.shape\n", + "mpred_features = iem_obj0._predict_feature_responses(wm_data['tst_m'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to collapse across trials from all the different orientations, we recenter all the reconstructions to be centered at the same point. To do this, we circularly shift the reconstruction based on the presented target orientation on that trial. We can then plot the average reconstruction across trials." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Orientation reconstructed from WM')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mpred_features_centered = np.ones((feature_resolution, n_tst_mem)) * np.nan\n", + "# Re-center all the reconstructions to a common point\n", + "shift_to = 90\n", + "for trial in range(n_tst_mem):\n", + " mpred_features_centered[:, trial] = np.roll(mpred_features[:, trial],\n", + " shift_to - int(wm_data['tst_m_conds'][trial]))\n", + "\n", + "avg_feats = mpred_features_centered.mean(axis=1)\n", + "plt.plot(iem_obj0.channel_domain - shift_to, avg_feats)\n", + "plt.ylim([-0.2, 1.0])\n", + "plt.xlabel('distance from presented orientation')\n", + "plt.ylabel('estimated channel response')\n", + "plt.title('Orientation reconstructed from WM')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that there is a robust representation of the remembered orientation in the data.\n", + "\n", + "Next, we look at the reconstruction of the distractor orientation during the working memory delay period. Recall that this is the orientation that is being visually presented to the participant." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Reconstruction of WM and distractor orientations')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABZmElEQVR4nO3dd3gU1dfA8e9JgVBC772XAIHQpSsdISKCgKigvvbuz4INFRsqVlCxITYEBUEQpIOA9N4xlNB7CQlJSLvvHzOBJSSbDWRLwvk8zz7Znbkzc3Yyu3dn5t5zxRiDUkoplRE/bweglFLKt2lFoZRSyimtKJRSSjmlFYVSSimntKJQSinllFYUSimlnNKKQl0TERkkInO8sN3WIhIhIjEi0tvT23cHEXldRH7OQnkjIjXs52NE5FX3RZdz2MdENW/HAbnn/6IVhQtEJFJE4uwD8KiIjBORgt6OKz2OXx5uWHcVe/0BqdOMMb8YY7q4Y3uZGA6MNsYUNMZMdZwhIi+KyN9ppkVkMG2A/dyIyHHH9yYigfY0n+9sZIx5yBjzZmbl7GO5kztiSO/48Ab7mNhzreuxP+dvZaH8EBFZmiYWl/4vvk4rCtf1MsYUBBoBYcCL3g3n6nj7Q5yNKgNbM5i3GGglIv4AIlIWCATC0kyrYZdNdQbo7vC6uz3tuuHN4+Nat52Ljm3fY4zRRyYPIBLo5PD6fWCGw+uWwDLgLLAR6OAwrxjwPXAY60tnqsO8+4FdwGlgGlDOYZ4BHgIi7PV+Dog9rwbwDxAFnAQm2tMX28udB2KA/kAH4CDwAnAU+AkYAixN8x4NUMN+ng/4ENhnb2OpPW2/XS7GftyQdl1AK2C1vdxqoJXDvEXAm8C/QDQwByjhZL+nu3+A3UAKEGfHkTfNcnmAWKCJ/fp2+3/wT5ppu9K8/1eA3x2mTQJetj4mGcY41I4nGtgG3Oowb4i970ba//u9QHeH+VXtmKKBucBo4Gcn23oOOGIfS/em+Z+NA96yn5cA/rKPm9PAEqwfhT+l2W/PA1Xs9dxn/38X2+v43T5eorCOq3oOcWTl+PCz9+s+4DjwI1DYXk+623b1OHD4vz2K9TnZm86xnNfe//uBY8AYIJ89rwPWZ+N/dmxHgHvseQ8AiUCC/V6mO/t/A3WBeCDZLn827f/FHZ95j30HenJjOfWBQ0UBVAA2A5/ar8sDp4Ae9oeis/26pD1/BjARKIr1q7a9Pf0m+x/e2D6YRzl+UOyD5i+gCFAJOAF0s+f9ivUF5gcEAW3SLFfD4XUHIAl4z95OPjKvKD7H+lIvD/hjffnn5dIHO8BhuYvrwqoUzwB3AQHAQPt1cXv+IvtDVsuOYxEwIoN9ntn+ufg/yWD5hcDT9vPRWF+sb6eZNjbN+6+P9WVSxP5/HbOnGSfb6QeUs/8X/bEq6bIO+yYR68vBH3gY60s+9cO/HPjIfn/tsL580q0ogG4O8RQAxpNxRfEu1hdioP1o67DNy/abw//0R3u9qV+i9wLBdmyfABsclsnK8XEv1hdjNaAg8Afwk7NtZ/E4MFiVbDGH2B33y8dYX8jF7PczHXg3zWdjuL2femD9wCiadp9m4f+d9nPl+H9xy2feI9+BntxYTn3YH64YrA+yAeYDRex5L6Qe+A7lZwODgbJYv+CKprPO74D3HV4XxPpSqeJw0DhWAL8BQ+3nPwJfAxXSWW96FUUCEOQwLb0D2mD9avHD+sXZMJ11V8F5RXEXsCrNMsuBIfbzRcArDvMeAWZlsM8z2z+ROK8oXgem2M83AjWxvmwdpw1O5/1/CzyI9cvuG3uaycKxsgG4xWHfOJ615Le3U8b+IkgCCjjMH0/GFcVYHCpVrMo2o4piOPCn43GQ5lhOr6Ko5uQ9FbHLFL6K42M+8IjD69r2/zHAxW278jm5KYNjWbC+yKs7zLuBS2ceHez34hjvcaBl2n2ahf+3s4rCLZ95Tzz0HoXrehtjgrEOrjpYp/dgXSvvJyJnUx9AG6xKoiJw2hhzJp31lcM6HQfAGBODdSZS3qHMUYfnsVgHFliXDARYJSJbReTeTGI/YYyJz/wtAtb7CsL65Z9Vl70n2z5ce09O15XB/nFmMdBGRIphnd1FYF0ebGVPq8/l9ydS/QjcbT9+zGwjInK3iGxw+N/X59KxAQ7v1xgTaz8taL+/M8aY8w5l0+47R+WAAy6W/QDrV/wcEdkjIkMzex+O6xYRfxEZISK7ReQcVuUC1vvK6vGR9pjYh1VJlE5v25ktn8FxkNHyJbEq57UO/59Z9vRUp4wxSQ6vnR2Trvy/nfHkZz5baUWRRcaYf7B+JYy0Jx3AOqMo4vAoYIwZYc8rJiJF0lnVYaxKBgARKQAUBw65EMNRY8z9xphyWL9+v8ikpZNJ8/o81gcoddtlHOadxLrWWt2F9aR12XuyVcKF95TZurKyf2zLsX4B3491TwRjzDl7vfcDh40xe9NZbglWJV8a69p7hkSkMtZZx2NYl9eKAFuwPtCZOQIUtd9XqkqZlK/oSlljTLQx5n/GmGpAOPCMiHRMnZ3RYg7P7wBuATph7cMq9nQh68dH2mMi9UzqWCbLpbt8BsdBRsufxDpjqOfw2SxsrEYprrhsvS78v7P0+XDzZz5baUVxdT4BOotIQ+BnoJeIdLV/iQWJSAcRqWCMOQL8jfVPLWo3t2xnr+NX4B4RaSQieYF3gJXGmMjMNi4i/USkgv3yDNYBmmK/PoZ1PdiZjUA9e9tBWJdpADDGpGBd5vhIRMrZ7+kGO8YT9nYyWv9MoJaI3CEiASLSHwjBuu6aVVe9f+z3EQesAZ7B+vJPtdSelt7ZhHWNCXoB4fZzZwpg7fsTACJyD9YvTFfi22fH94aI5BGRNvZ2M/IbMEREQkQkP/BaRgVFpKeI1BARwbr5mUzWjo9g4ALWr938WPs+Ne6sHh+/Ak+LSFW7Sfk7WDdiHX/FO3PVx4Ed6zfAxyJSCkBEyotIVxe3nXZfZfb/PgZUEJE82f1eMvnMu51WFFfBGHMC67LEMGPMAaxfXy9hHUAHsFqnpO7bu7CuQ+7Auv75lL2OecCrwGSsX4vVgQEuhtAMWCkiMVg36p40l9qNvw78YJ8a355B/P9hXceeh9XCIu0v52exbtivxmqd8R7gZ186eRv4115/yzTrPQX0xGpFcgrrdLmnMeaki+/LcV3Xsn9S/QOU4vL3t8Selm5FYW97qzEmo6a3juW2YbX+WY71JdEA++zFRXcALbD28Ws4udRljPkb6wfKAqzLSgucrLcm1v82xo7tC2PMQnveu8Ar9v/v2QyW/xHrEskhrJY9K9LMz8rxMRartdVirFZf8cDjTmK/TDYcBy9g7a8V9mW0eVj3SVzxHRBiv5epLvy/F2A12T4qIlcc8278zLudZP6jSSml1PVMzyiUUko55dWKQkTGipUiYUsG80VEPhORXSKySUQaezpGpZS63nn7jGIcVtv2jHTHut5aE6un5JceiEkppZQDr1YUxpjFWDfDMnIL8KOxrACK2Dl6lFJKeYivJ9Eqz+WdaQ7a0444FhKRB7DOOChQoECTOnXqeCxApZTKDdauXXvSGFMyvXm+XlG4xBjzNVb3dpo2bWrWrFnj5YiUUipnEZEMe/t7+x5FZg5xeW/UClxdL1+llFJXydcrimnA3Xbrp5ZAlN3bWSmllId49dKTiPyKlWSvhIgcxOqdGghgjBmDlRKiB1bPyljgHu9EqpRS1y9vD1k4MJP5BmtQEqVypcTERA4ePEh8vKvJfZW6NkFBQVSoUIHAwECXl8kVN7OVyqkOHjxIcHAwVapUwcrhp5T7GGM4deoUBw8epGrVqi4v5+v3KJTK1eLj4ylevLhWEsojRITixYtn+QxWKwqlvEwrCeVJV3O8aUWhlFLKKa0olFI+o0OHDniiw+y1bmfYsGHMmzfvqpbdsGEDM2fOzHK5adOmMWLEiKva5rXSm9lKKcC60WmMwc8vZ/5+TEpKIiDA/V9pycnJDB8+/KqX37BhA2vWrKFHjx5ZKhceHk54ePhVb/da5MwjQimVLSIjI6lduzZ333039evX58CBA3zwwQc0a9aM0NBQXnvttYvl6tSpw5AhQ6hVqxaDBg1i3rx5tG7dmpo1a7Jq1SoAzp8/z7333kvz5s0JCwvjzz//BGDcuHH07t2bzp07U6VKFUaPHs1HH31EWFgYLVu25PTpS7lBf/rpJxo1akT9+vVdWm94eDg33XQTHTt2zLBcXFwcAwYMoG7dutx6663ExcWluz/mz59PWFgYDRo04N577+XChQsAVKlShRdeeIHGjRvz+++/M2TIECZNmgTA2rVrad++PU2aNKFr164cOWL1Ce7QoQMvvPACzZs3p1atWixZsoSEhASGDRvGxIkTadSoERMnTmTVqlXccMMNhIWF0apVK3bu3JluuXHjxvHYY49d/H/cdNNNhIaG0rFjR/bv3w/AkCFDeOKJJ2jVqhXVqlW7GOO10jMKpXzEG9O3su3wuWxdZ0i5QrzWq57TMhEREfzwww+0bNmSOXPmEBERwapVqzDGEB4ezuLFi6lUqRK7du3i999/Z+zYsTRr1ozx48ezdOlSpk2bxjvvvMPUqVN5++23uemmmxg7dixnz56lefPmdOrUCYAtW7awfv164uPjqVGjBu+99x7r16/n6aef5scff+Spp54CIDY2lg0bNrB48WLuvfdetmzZ4nS969atY9OmTRQrVoyXXnop3XJfffUV+fPnZ/v27WzatInGja8c2iY+Pp4hQ4Ywf/58atWqxd13382XX355Ma7ixYuzbt06AGbNmgVY/WAef/xx/vzzT0qWLMnEiRN5+eWXGTt2LGCd5axatYqZM2fyxhtvMG/ePIYPH86aNWsYPXo0AOfOnWPJkiUEBAQwb948XnrpJSZPnnxFuXHjxl2M9fHHH2fw4MEMHjyYsWPH8sQTTzB16lQAjhw5wtKlS9mxYwfh4eH07ds3i0fNlbSiUOo6V7lyZVq2tIY/nzNnDnPmzCEsLAyAmJgYIiIiqFSpElWrVqVBgwYA1KtXj44dOyIiNGjQgMjIyIvLT5s2jZEjRwLWl2/qr90bb7yR4OBggoODKVy4ML169QKgQYMGbNq06WI8Awda/XDbtWvHuXPnOHv2rNP1du7cmWLFijnd/uLFi3niiScACA0NJTQ09Ir9sHPnTqpWrUqtWrUAGDx4MJ9//vnFiqJ///7pLrNlyxY6d+4MWJelypa9NBJCnz59AGjSpMnFfZRWVFQUgwcPJiIiAhEhMTEx3XKOli9fzh9//AHAXXfdxfPPP39xXu/evfHz8yMkJIRjx45lui5XaEWhlI/I7Je/uxQoUODic2MML774Ig8++OBlZSIjI8mbN+/F135+fhdf+/n5kZSUdHH5yZMnU7t27cuWX7lypUvLw5XNN0XE6XrTxp9euezguB3H7dWrV4/ly5enu0zqe/T397/sPTp69dVXufHGG5kyZQqRkZF06NDhmuJ03M9Wcotrp/colFIXde3albFjxxITEwPAoUOHOH78eJaWHzVq1MUvqPXr12c5hokTJwKwdOlSChcuTOHChV1eb0bl2rVrx/jx4wHrEpjjGUyq2rVrExkZya5duwDrXkn79u2dxlq7dm1OnDhxsaJITExk69atTpcJDg4mOjr64uuoqCjKly8PXH55KW05R61atWLChAkA/PLLL7Rt29bpNq+VVhRKqYu6dOnCHXfcwQ033ECDBg3o27dvhl9W6Xn11VdJTEwkNDSUevXq8eqrr2Y5hqCgIMLCwnjooYf47rvvsrTejMo9/PDDxMTEULduXYYNG0aTJk3S3e73339Pv379aNCgAX5+fjz00ENOY82TJw+TJk3ihRdeoGHDhjRq1Ihly5Y5XebGG29k27ZtF29SP//887z44ouEhYVddtaRtpyjUaNG8f333xMaGspPP/3Ep59+6nSb10qy69TEV+jARSon2b59O3Xr1vV2GOo6k95xJyJrjTFN0yuvZxRKKaWc0opCKaWUU1pRKKWUckorCqWUUk5pRaGUUsoprSiUUko5pRWFUuqi119//WL6i8xSaU+dOpVt27Zl27bfeeedbFtXZq63NOHXSisKpVS6hg8ffjHxXnqcVRQZpatwJqsVhTGGlJSULG8nNU24s/fmzNVWFOHh4QwdOvSqtultWlEodZ17++23qVWrFm3atGHnzp0Xpzum0h46dCghISGEhoby7LPPsmzZMqZNm8Zzzz1Ho0aN2L17Nx06dOCpp56iadOmfPrpp0yfPp0WLVoQFhZGp06dLiaoi4mJ4Z577qFBgwaEhoYyefJkhg4dSlxcHI0aNWLQoEEAfPTRR9SvX5/69evzySefAOmnRXekacLdQ5MCKuUr/h4KRzdn7zrLNIDuGV/uWLt2LRMmTGDDhg0kJSXRuHHjK9JbnDp1iilTprBjxw5EhLNnz1KkSBHCw8Pp2bPnZWmsExISLo4cd+bMGVasWIGI8O233/L+++/z4Ycf8uabb1K4cGE2b958sdxtt93G6NGj2bBhw8W4vv/+e1auXIkxhhYtWtC+fXuKFi16WVp0R5om3H20olDqOrZkyRJuvfVW8ufPD5DuCGqFCxcmKCiI++67j549e9KzZ88M1+eYivvgwYP079+fI0eOkJCQQNWqVQGYN2/exYR2AEWLFr1iPUuXLuXWW2+9mLG1T58+LFmyhPDw8MvSojvSNOHuoxWFUr7CyS9/bwoICGDVqlXMnz+fSZMmMXr0aBYsWJBuWcdU3I8//jjPPPMM4eHhLFq0iNdffz1b4kkv3ffVLne9pAm/VnqPQqnrWLt27Zg6dSpxcXFER0czffr0K8rExMQQFRVFjx49+Pjjj9m4cSPgPA02XJ4++4cffrg4vXPnznz++ecXX585cwaAwMDAi7/G27Zty9SpU4mNjeX8+fNMmTIl01TamibcfbSiUOo61rhxY/r370/Dhg3p3r07zZo1u6JMdHQ0PXv2JDQ0lDZt2vDRRx8BMGDAAD744APCwsLYvXv3Fcu9/vrr9OvXjyZNmlCiRImL01955RXOnDlD/fr1adiwIQsXLgTggQceIDQ0lEGDBtG4cWOGDBlC8+bNadGiBf/3f/93cdS9jGiacPfxappxEekGfAr4A98aY0akmV8J+AEoYpcZaoxx2i5N04yrnETTjCtvyDFpxkXEH/gc6A6EAANFJCRNsVeA34wxYcAA4AvPRqmUUsqbl56aA7uMMXuMMQnABOCWNGUMUMh+Xhg47MH4lFJK4d1WT+UBx94yB4EWacq8DswRkceBAsDVdaVUyocZYxARb4ehrhNXc7vB129mDwTGGWMqAD2An0TkiphF5AERWSMia06cOOHxIJW6WkFBQZw6dcpnmkGq3M0Yw6lTpwgKCsrSct48ozgEVHR4XcGe5ug+oBuAMWa5iAQBJYDjjoWMMV8DX4N1M9tdASt1tY5Hx7PpQBQ7j0Vz8EwcJ2MucCEphXwB0KPqWUrmP0SAnx95/IXAAD/89AxDuUlQUBAVKlTI0jLerChWAzVFpCpWBTEAuCNNmf1AR2CciNQFggA9ZVA5wtbDUczYdIS5244RcTzm4vRiBfJQsmBe8uXxJwoYtTqOY+fiiY63mlb6CYRWKELnkNKENyxHxWL5vfQOlLJ4raIwxiSJyGPAbKymr2ONMVtFZDiwxhgzDfgf8I2IPI11Y3uI0XN05cOSUwx/bjjEuGWRbDoYhb+fcEO14tzWpAJNKhelTplggoMC01329PkEth6OYvXe0/wTcZIPZu/kg9k7aVOjBENaVaFj3VJ6L0N5Rab9KESkFvAlUNoYU19EQoFwY8xbnggwq7QfhfIGYwyzthzlw7n/set4DDVLFeTOlpXp1bAcxQrkuap1HjwTy5R1hxi/aj9HouJpWKEwL3SrQ6saJTJfWKksctaPwpWK4h/gOeAruz8DIrLFGFM/2yPNBlpRKE/beOAsr0zdwuZDUdQoVZBnu9Sia70y2fbrPyk5hT/WH+KTuf9xOCqetjVLMKxnCDVLB2fL+pUC5xWFK5ee8htjVqU56LM+KolSucyFpGQ+mRfBV//splRwEB/2a0jvsPL4+2Xv5aEAfz9ub1qR8Ibl+HnFPkYv3MXNny3lmS61uL9ttWzfnlJpuVJRnBSR6lj3CBCRvsARt0allI/bciiKZ37bwH/HYri9aQVe6RlCoQzuPWSXoEB//q9tNXqHleeVKVsY8fcOZm89ysh+DalesqBbt62ub65ceqqG1fS0FXAG2AvcaYyJdHt0V0EvPSl3m7r+EC9M3kSR/IGM6BPKjXVKeTwGYwzTNx1h2J9bSEhK4aPbG9KtftnMF1QqA9d0j8JhJQUAP2NMxnmFfYBWFMpdkpJTGPH3Dr5dupfmVYvx5aDGFC+YN/MF3ejYuXge/GktGw6c5YmbavBUp1r46aUodRWuKSmgiDwpIoWAWOBjEVknIl2yO0ilfFnMhSTuGbeab5fu5e4bKvPL/7XweiUBULpQEBMeaEm/JhX4bMEuHvhpLecv6C1Elb1cSeFxrzHmHNAFKA7cBfjmUFxKucGZ8wkM+mYFy3afYkSfBgy/pT6B/r6T/SYo0J/3+4byRng9Fu48zqBvV3I2NsHbYalcxJWjPfU8tgfwozFmq8M0pXK14+fiGfD1CrYfjWbMnU0Y0LySt0NKl4gwuFUVvhjUmG2HzzHg6xUcj473dlgql3ClolgrInOwKorZIhIMpLg3LKW879DZOG7/ajkHzsTy/ZBmdA4p7e2QMtW1XhnGDmnG/tOx9BuznAOnY70dksoFXKko7gOGAs2MMbFAHuAet0allJediL7AoG9WcOp8Aj/d14LWOag3dJuaJfj5/1pwNjaRgd+s4GiUnlmoa5NpRWGMSQGOASEi0g6ohzU0qVK5UlRcInePXcWxcxcYd08zmlQu6u2QsqxxpaL8dF9zzsYmMujbFZyKueDtkFQO5kqrp/eAf7GGJX3Ofjzr5riU8orYhCTuHbeaXcej+fruJjSpXMzbIV210ApFGDukGYfOxnH32FVExSV6OySVQ7nSM7s3UNsYoz9JVK6WlJzCwz+vY/3+M3x+R2Pa1ix5aWb8OTi6GaKPwPkTEHMckuLBPxD880JgPihSCYpWhWJVIb9vVDDNqxZjzJ1NuP/HNdw7bjW//F8LggL9vR2WymFcqSj2AIGAVhQqVxv+1zb++e8E7/ZpQPcaQbBxAuyaD4fXw6mIywuLPwTmh+QESE7no1GoAlRuBVVaQ9X2VuXhJR1ql+LTAWE8On4d//ttI6MGhmmnPJUlrlQUscAGEZmPQ2VhjHnCbVEp5WE/LItk4vIIPq8bwc07voFZSyAlCQqUggpNIfR2KNsIilaGAiUhqAj42VdujYHEODi7H07vgdO74eAa2LMQNv9mlSkXBvX7Qv0+UKicx99fjwZleal7Xd6euZ3KxfPzfLc6Ho9B5VyuVBTT7IdSudKy9ZuJnjmSNfkXELz3HBSrBjc8BnXDrS94v0xu5YlAnvxQqo71SGUMnIyAiDmwZRLMeRnmvAK1u1vrr9zKWtZD/q9tVfacPM8Xi3ZTpUQBbm9aMfOFlMLFXE8ikgeoZb/caYzx2btimutJuSz2NGdnvUWBjePwlxRSanUnoNWjULm1e77AT+6Cjb/C2u8h9pRVCbV+CkJu8ViFkZicwj3fr2bFnlP8/H8taFmtuEe2q3zftQ5c1AH4AYjE6pFdERhsjFmcrVFmE60oVKYS42HVV5jFI0m5EMOfchOth7xN6coeuhyTGGdVGMs/h1O7rAqj83Co2s4jm4+KS+TWL/4lKjaRv55oQ9nC+TyyXeXbrikpIPAh0MUY094Y0w7oCnycnQEq5TH7V8KY1jB3GFsDQuiRMIIyg77yXCUBVguppvfCo6ug95cQcwJ+6AU/94VTu92++cL5Avn6ribEJybzyC/rSEjSRAvKOVcqikBjzM7UF8aY/7BaQSmVcyTGweyXYWxXSEpgbuMv6XnqCcI7d/TeGNR+/tDoDnh8rXVGcWAVfHEDLP4Aktyb1K9GqWDe79uQ9fvP8taMbW7dlsr5XKko1ojItyLSwX58A+i1HZVzHNsGX7WD5aOh6T1sCJ/JIyuL0KluKR5uX93b0UFgELR+Eh5bZd3oXvCWFe+B1W7d7M2hZbm/bVV+XL6PP9YddOu2VM7mSkXxMLANeMJ+bLOnKeX7Nk+CbztCfBTcNYWoju/z6O8RlCkcxIf9GvlWf4LgMnD7DzBwIlyIts5+Fr0Hye4bX+KFbnVoUbUYL0/Zwq7jPj0mmfIiV3I9XQBGA28ArwGfay9t5fOSE+HvoTD5PijbEB5cjKl2I69M3cLRc/F8NiCMwvl99Apq7W7wyDJo0BcWvQPjesCZSLdsKsDfj88GhpEvjz+P/7qB+MRkt2xH5Wyu5Hq6GdgNfIpVYewSke7uDkypqxZ/Dn7pCyu/hJaPwODpEFyGP9YdYvrGwzzTuRZhlXw80V9QYejzNfT5Fo5vhzFtYftfbtlU6UJBjOwXyvYj5xjx9w63bEPlbK62errRGNPBGNMeuBFt9aR8VfRR6xf43iVwyxfQ7V3wDyTy5HmG/bmFFlWL8ZAv3JdwVWg/eGgpFK8OEwfBvDcgJft/9d9UpzT3tK7CuGWRzNt2LNvXr3I2VyqKaGPMLofXewC9mKl8z8kI+K4znNoDd/wGYYMAK9nfkxM3EODvx8f9G+HvS/clXFG0MtwzCxrfDUs/gp9vg9jT2b6Zod3rEFK2EM9N2sixczqGhbrE1VZPM0VkiIgMBqYDq0Wkj4j0cXN8Srnm2Fbr5m9iHNwzA2p2ujjrq8V72HjgLO/c2oByRXJo57LAIAgfBb0+g33/WjfoT+7KfLksyBvgz2cDw4hLTOaFyZtwJWuDuj64UlEEYQ1c1B7oAJwA8gG9gJ5ui0wpVx3dAuN6Wum+751t9XS27TwazSfz/qNnaFluDi3rxSCzSZPBMPgvqxXXtx0hcmm2rr5GqYIM7VaHRTtPMGH1gWxdt8q5XMr15LaNi3TDuknuD3xrjBmRTpnbgdcBA2w0xtzhbJ2awuM6c3Qz/BBu9XYePN26lm9LTE6hzxfLOHw2jjlPt6N4wbxeDDSbnd4L42+3/oaPgkYDs23VKSmGO79bycYDZ5n1VDsqFsufbetWvuuaUniIyPsiUkhEAkVkvoicEJE7syEof+BzoDsQAgwUkZA0ZWoCLwKtjTH1gKeudbsqFzm27VIlMeSvyyoJgK/+2c3mQ1G81bt+7qokwBrf4r65VgbaqQ/BslHZtmo/P+GDfg3xE+F/v28kJUUvQV3vXLn01MUYcw7rMlMkUANrONRr1RzYZYzZY4xJACYAt6Qpcz9Wv40zAMaY49mwXZUbnN0PP/cB/zxWJVGs2mWzdxw9x6fzI+gZWpbuDXLBJaf05CsCgyZBvVut9OXzXrdSm2eD8kXyMaxXCKv2nmbsv3uzZZ0q53Klokgds+Jm4HdjTFQ2bbs84HgR9KA9zVEtoJaI/CsiK+xLVVcQkQdEZI2IrDlx4kQ2had81vmT8NOtkBgLd/1xRSWRmJzCs79vpFBQIG+E1/NSkB4SkAdu+w6a3ANLP4bpT2Zb89m+TSrQqW4pRs7Zyb5T57NlnSpncqWi+EtEdgBNgPkiUhLwVNu5AKAm1k30gcA3IlIkbSFjzNfGmKbGmKYlS5ZMO1vlJhdi4Jd+EHXQSnVR+sqK4Kt/drPl0LnceckpPX7+0PNjaPssrPsBJt0DSdeePEFEeKt3AwL9/HhpymZtBXUdcyWFx1CgFdDUHrAolisvEV2NQ1hjW6SqYE9zdBCYZoxJNMbsBf7DqjjU9Sg5CX4fAkc2Qt/vofINVxSJOBad+y85pUcEOr4KXd6GbX/C+P6QEHvNqy1TOIgXutfh312nmLRWEwder1y5mZ0feAT40p5UDkj3zngWrQZqikhVewS9AVw55OpUrLMJRKQE1qWoPdmwbZUTzX0Vds2Fm0dCnR5XzE5JMbw0ZTMF8gbk/ktOGWn1GNzyOexZBL8OyJbK4o7mlWhWpShvzdjOiWhN83Y9cuXS0/dAAtZZBVi/+t+61g0bY5KAx4DZwHbgN2PMVhEZLiLhdrHZwCkR2QYsBJ4zxpy61m2rHGjN97DiC2jxsDXoTzp+X3uA1ZFneKl73evjklNGwu6EW8fA3sXZUln4+Qnv9gklLiGZN6ZvzaYgVU7iSkVR3RjzPpAIYIyJxRoS9ZoZY2YaY2oZY6obY962pw0zxkyznxtjzDPGmBBjTANjzITs2K7KYfb8AzOfhRqdoEv6v1FOxlzgnZk7aF61GP2aVvBwgD6o4YBsrSxqlCrI4zfV4K9NRzQX1HXIlYoiQUTyYXV4Q0SqA3r+qTzjTCT8djcUqw59x4J/QLrF3p6xndiEJN65tT4iOSyXk7tkc2XxYPvq1C4dzCtTtxAdn5hNQaqcwJWK4jVgFlBRRH4B5gPPuzUqpcDK2zTxLqtvwB0TrNTb6fh310mmrD/EQ+2rU6NUsIeD9HFpK4vEuKteVZ4AP97rG8qx6Hjen7Uz8wVUruG0ohARP6Ao0AcYAvyK1fppkdsjU2rms3B0kzUuQ5q+EqniE5N5ZeoWqhTPz6M31vBwgDmEY2Xx2+BrGo+7UcUiDL6hCj+v3Memg2ezL0bl05xWFMaYFOB5Y8wpY8wMY8xfxpiTHopNXc/W/gDrf4Z2z1kjvmXgi0W72XvyPG/1bkBQoL8HA8xhGg6Anh9BxGyY8sA1dcp7pkstShTMy6tTt2h6j+uEK5ee5onIsyJSUUSKpT7cHpm6fh3eADOfg+o3QYcXMyy2+0QMXy7aRe9G5WhTs4Tn4supmt4Lnd+ErVNg+hOQknJVqykUFMjLPeqy8WCUZpi9TqR/Z/By/e2/jzpMM0D61wKUuhYXoq2exQVKWMOA+qV/lmCM4fVpWwkK9Oflm0PSLaPS0foJSIiBf96DPAWh2wirs14W3dKoHL+u2s/7s3fQrX4ZihXI44Zgla9wpWd21XQeWkko95jxP6ul023fQoHiGRabvfUoSyJO8r/OtSgZfB33mbgaHV60xhJfOQYWvn1VqxAR3uxdn5j4JN6fpeNs53auXHpSyjM2ToBNE6H9UCt9dgbiEpJ586/t1CkTzJ0tK3swwFxCBLq+A2F3weIPYMWXmS+Tjlqlg7m3TVUmrD7Auv1nsjlI5Uu0olC+4dRu+OsZqNwa2j3rtOgXi3Zx6Gwcb4TXI8BfD+GrIgK9PoW6vWDWUNg86apW80THmpQuZN3YTtYb27mWfsqU9yUnwqR7rZTZfb7J8L4EQOTJ83z1zx56NypHi2oZX5pSLvDzt+4DVW4NUx6C3QuzvIqCeQN4tWcIWw+f45eV+9wQpPIFGVYUItLY2cOTQapcbvFIOLIBen0GhdMOSXK54X9tI9BfeLFHXc/EltsFBsGA8VCiFky802pxlkU3NyhLmxolGDl7J6fPX30fDeW7nJ1RfOjkMdL9oanrwuH11nXy0P4QEu606Pztx1iw4zhPdqpJ6UJBHgrwOpCvCNw5GfIVhV/6wumsJWgWEV7rFcL5hGQ+mqs9tnOjDCsKY8yNTh43eTJIlUslxluXPAqWhu7vOS0an5jMG9O3UaNUQe5pXdVDAV5HCpWFO/+wOuL9dCvEZG3U4Zqlg7mrZWXGr9zPjqPn3BSk8haXxqMQkVdE5Gv7dU0R6en+0FSut/AtOLEDbhll/Zp14tsle9h/OpbXe9UjUG9gu0fJWjDod6uS+KWv1aclC57qVJNC+QIZPn2bjoaXy3htPAp1ndu3HJaNtsZ6rtHJadFj5+L5YtFuutYrrT2w3a1CU7j9Rzi6xbpnkYW8UEXy5+HpTrVYtvsUczQVea7i1fEo1HXqQgxMfQiKVIIub2Za/L1ZO0hKNrykN7A9o2ZnuGW0NUre9Cet7L0uGtSiEjVLFeSdmdu5kHT1+aSUb9HxKJTnzR0GZ/ZB7y8hr/O04BsPnOWPdYe4p00VKhcv4KEAFY3usHpwbxxvpftwUYC/H8N6hbDvVCzf/xvpvviUR+l4FMqzIpfCmu+sFBJVWjstaoxh+F/bKFEwL49pCnHPa/8CNBoEi96FDeNdXqxtzZJ0qluKUfMjOB4d78YAlae4kutpLjoehcoOifHWpYwileGmVzItPm3jYdbuO8NzXWsRHBTogQDVZUSg5ydQtT1Me9y6FOWil28OISE5hZGztblsbuBq85Eg4AxwDggRkXbuC0nlWos/gFO7oNcnkCe/06JxCcmM+HsH9coVom+Tip6JT10pIA/0/wmK17RGGzy2zaXFqpYowD2tq/L72oNsPhjl5iCVu7nSPPY94F/gZeA5++E8GY9SaR3bCv9+Ag0HWuNMZOKrxbs5EhXPa73q4e+nbSe8Kqiw1Ww2MD/80g/OHXFpscduqkGx/Hl4Y/pWbS6bw7lyRtEbqG2MudkY08t+OO9Cq5SjlGSY9oT1hdMl87TWR6LiGPPPbm5uUJbmVXWMLJ9QpCIM+g3izsD4262Wa5koFBTIs11rs2bfGf7a5FrlonyTKxXFHkAvEKurt/pbOLTGGiTHyRgTqd77ewcpBoZ2r+OB4JTLyjaEfuOss8NJ90ByUqaL3N60IiFlCzHi7x3EJ2pz2ZzKlYoiFtggIl+JyGepD3cHpnKJswdg/nCo3hEa9Mu0+Lr9Z5i64TD3t61KxWLO72MoL6jVBW4eCRFz4O/nMu1j4e8nvHJzXQ6djeOHZZGeiVFlO1eGQp1mP5TKGmOsEetMCvT8ONMhN1NSDG9M30ap4Lw80kGbw/qspvda/WD+/QSKVoHWTzot3qpGCW6qU4rRC3fRr2lFHTY1B8q0ojDG/OCJQFQutH06RMy27ksUzXwkuj83HmLjgbOM7NeQAnld+Q2jvKbja9aQtXNfg2LVoa7z9G8vdq9D108W89n8CF4Pr+eZGFW2caXVU2sRmSsi/4nIHhHZKyJZy0Osrj8J52HWi1C6PrR4KNPisQlJvPf3TkIrFKZPmPMxKZQP8PODW8dA+cbwx/2ZjmNRs3QwA5pX4ucV+9h78rxnYlTZxpV7FN8BHwFtgGZAU/vvNRORbiKyU0R2ichQJ+VuExEjIk2zY7vKA/55H84dhJs/BP/Mzw7GLNrN0XPxDOsZgp82h80ZAvPBgF8hf3H4dQCcO+y0+FOdapI3wI/3/t7hoQBVdnGloogyxvxtjDlujDmV+rjWDYuIP/A50B0IAQaKSEg65YKBJ4GV17pN5SHHd8Dy0dDoTqjUMtPiB8/E8tXiPfRqWI6mVbQ5bI4SXBoGTrBSko/v77TZbKngIB5qX51ZW4+yOvK0B4NU18qVimKhiHwgIjdk81CozYFdxpg9xpgEYAJwSzrl3gTeAzRpTE5gDMx8FvIUhM5vuLTIiL93IKLNYXOsMvWh7/dwbAv88YDVbyYD/9e2GqUL5eWtGdu1E14O4kpF0QLrctM7ZO9QqOWBAw6vD9rTLrIrpIrGmBnOViQiD4jIGhFZc+LEiWwITV21zZMgcgl0HAYFMh87Yk3kaf7adIQH2lWnfJF8HghQuUWtLlY/mZ0zYN5rGRbLl8efZ7vUZuOBs9oJLwdxpdXTjZ4IJC0R8cO6NzIks7LGmK+BrwGaNm2qP1O8JT4K5rwM5cKgyZBMi6c2hy1TKIiH2ldzf3zKvVo8CCcjYNkoKzdUk8HpFuvTuAJj/43kvVk76FKvNHkD/D0cqMoql5ICisjNIvK8iAxLfWTDtg8BjtneKtjTUgUD9YFFIhIJtASm6Q1tH7bwXWsYzZs/Ar/MP/yT1x1k86EohnavQ/482hw2V+g2whqxcMYzGWab9fcTXu5Rl4Nn4vhx2T7PxqeuiivNY8cA/YHHsUa26wdk3ig+c6uBmiJSVUTyAANw6NhnjIkyxpQwxlQxxlQBVgDhxpg12bBtld2ObYVVX1mdscpnfgsr5kIS78/eSaOKRQhvWM4DASqP8A+AvmOtM4rf7oYT/6VbrE3NEnSoXZJRCyI4c9714VaVd7hyRtHKGHM3cMYY8wZwA1DrWjdsjEkCHgNmA9uB34wxW0VkuIho0sGcxBiYNdRK+ufCOBMAXyzcxYnoCwzrpc1hc52gwnDHRPDPYyUQPJ9+I8kXu9cl5kISoxbs8nCAKqtcqSji7L+xIlIOa+zsstmxcWPMTGNMLWNMdWPM2/a0YcaYK1KGGGM66NmEj9o5E/Yuhg4vQf7Mm7ceOB3Lt0v3cmtYeRpXKuqBAJXHFa0MA8ZbfSsm3glJV46eXLtMMP2bVeSnFZFEaic8n+ZKRfGXiBQBPgDWAZFYI90pZX0BzH4ZStaxLju54J2Z2/EX4YVu2hw2V6vYHHp/AfuXWWnm02kO+3SnWgT6+/H+bO2E58tcGQr1TWPMWWPMZKx7E3WMMa+6PzSVI6wcA2f2Qte3XeqBvWLPKf7ecpRHOlSnTOEgDwSovKpBX+tMc9MEWHJlq/pShYJ4sF11Zm4+yhrthOezXG311EpE7sC6qX2LiNzt3rBUjhBzHP75AGp2tVq6ZCLZbg5bvkg+7m+nzWGvG+2fhwa3w4K3YMsfV8y+v11VSgXn5e2Z2gnPV7nS6uknrA52qbmeUvM9qevdgrcgKc46m3DBb2sOsP3IOV7sUYegQG07f90QgfBRULEFTH0YDl5+qzF/ngCe7VKb9fvPMnPzUS8FqZxx5YyiKdDaGPOIMeZx+/GEuwNTPu7IJlj3IzR/AErUzLT4ufhERs7eSfMqxbi5Qba0hVA5SWCQdXO7YGn4daA1oJWD25pUoE6ZYN6btYMLSToSnq9xpaLYApRxdyAqBzEGZr8E+YpalxVcMGp+BKdjExjWKwTJZAAjlUsVKAF3/AZJ8VZl4ZBA0N9PeKlHXfafjuWn5doJz9dkWFGIyHQRmQaUALaJyGwRmZb68FyIyudsn27lc7rRriwysffkecYti6RfkwrUL1/YAwEqn1WqjpVA8PhWmPIgpKRcnNWuVkna1SrJqAW7OBurnfB8ibNmKtmR+E/lNkkXYM4rUCoEmtzj0iJvz9hG3gB/nu1a283BqRyhZifo+o7VSXPhW1YCSduL3evQ47MljF6wi1d6XjHqgPKSDCsKY8w/ACJSFThijIm3X+cDSnsmPOVzVnwBZ/fBXVNcag67JOIE87YfZ2j3OpQK1uawytbiITi+HZZ8CCVqQ8P+ANQtW4h+TSrww/JI7r6hCpWK5/dyoApcu0fxO5Di8DrZnqauN9HHYPFIqNUdqt+UafGk5BTe/GsblYvn557WVdwfn8o5RKDHSKjcBqY9DgdWX5z1TOfaBPj58Z52wvMZrlQUAfbAQgDYz/O4LyTlsxa8aV16crE57PhV+/nvWAwv9airqaTVlQLyQP+foFA5mHDHxZZQZQoHcX+7aszYdIS1+854OUgFrlUUJxyT9InILcBJ94WkfNKRjbD+Z2vMgeLVMy1+NjaBj+b+R6vqxekSolcqVQbyF7MSCKZpCfVgu2qUKJiXd7QTnk9wpaJ4CHhJRPaLyH7gBeAB94alfIoxMOtF60Pd7jmXFvlkXgTn4hK1OazKXMnaV7SEKpA3gP91qcXafWeYtUU74XmbK7medhtjWgIhQIgxppUxZrf7Q1M+Y9ufsO9fK4V4viKZFt9+5Bw/Lo/kjhaVqFOmkPvjUzlfakuoHX9ZlziBfk0qUKt0QUbM2kFCUkomK1Du5FKuJwBjTIwxJibzkipXSYyHua9CqXoQlnmKL2MMr/25lcL5Anm2izaHVVnQ4iFoPBiWfgQbJxLg78eLPeqy71QsP6/QTnje5HJFoa5TKz6Hs/uh27suNYedtvEwqyJP83y3OhTJr20eVBaktoSq0tZuCbWKDrVK0qZGCT5bEEFUbKK3I7xuaUWhMhZ9FBZ/CHV6QrX2mRaPuZDE2zO207BCYfo3rZhpeaWuEJAHbv/xYksoiTrIiz3qEBWXyOeLdCQ8b8nwJ6KI9HG2oDHmynzBKneZPxySE6DzcJeKfzY/guPRF/j67qY6vKm6eqktob7tBL8OpN69s7itcQXG/RvJXS0rU7GYdsLzNGdnFL3sx33Ad8Ag+/Et4NpQZirnOrweNvwCLR92qTnsruPRjF26l/5NK9KoYhH3x6dytzQtof7XuQZ+fvD+7J3ejuy6lGFFYYy5xxhzDxCI1drpNmPMbUA9e5rKrYyBv4dC/hLQ7lkXihtem7aV/Hn8eb6b3sBW2cShJVTZNSO5v201pm88zPr92gnP01y5R1HRGHPE4fUxoJKb4lG+YOsfcGAFdHwVgjLP9vr3lqP8u+sUz3atTfGCeT0QoLputHgImgyBpR/xaPG1lCiYRzvheYErFcV8O8X4EBEZAswA5rk3LOU1iXEw9zUo3QDC7sq0eGxCEm/9tY2QsoUY1KKyBwJU1xWHllBBM5/k7aZxrI48w+ytx7wd2XXFlQ53jwFjgIb242tjzOPuDkx5ybLREHXAag7rl3l+ps8X7uJwVDzDb6mHv97AVu7gH2i3hCpPl83P0KpELCP+3q6d8DzI1eax64AZxpingdkiEuzGmJS3nDtidXaq2wuqts20+N6T5/lm8V76NC5P0yrFPBCgum7ZLaEk6QJfBXzA8VOnGb9SO+F5SqYVhYjcD0wCvrInlQemujEm5S3z34CUJOj8ZqZFjTEM+3MLeQL8GNq9jgeCU9c9uyVUwagIfijyLZ/N20lUnHbC8wRXzigeBVoD5wCMMRFAKXcGpbzg4FrY+Cu0fASKVc20+PRNR1gScZLnutbWAYmU59TshHR9l2bxy7gv8Re+WKid8DzBlYriguN4FCISAGiTg9zEGGtYygKloO3/Mi0eFZfI8OnbCK1QmDtb6g1s5WEtHoQmQ3g0YBqnl/1I5Mnz3o4o13OlovhHRF4C8olIZ6zR7aZnx8ZFpJuI7BSRXSIyNJ35z4jINhHZJCLzRUS/ldxhy2Q4uMpuDpt5ttf3Z+3g9PkLvHNrA72BrTzPbgmVULE1b/t/zfjJk7wdUa7nSkUxFDgBbAYeBGYaY16+1g2LiD/wOdAdK4X5QBFJO5r6eqCpMSYU6z7J+9e6XZVGQizMHQZlQqHRoEyLr9t/hvGr9jOkVVXql8+8j4VSbuEfSJ6BPxOXrwz3H36Fles3ejuiXM2ViuJxY8w3xph+xpi+xphvROTJbNh2c2CXMWaPfWlrAnCLYwFjzEJjTKz9cgVQIRu2qxwtGwXnDkG3EZk2h01MTuGlPzZTplAQz3Sp5aEAlcpA/mIEDf6dfJJE8emDSYyL9nZEuZYrFcXgdKYNyYZtlwcOOLw+aE/LyH3A3+nNEJEHRGSNiKw5ceJENoR2nYg6CEs/hpBboErrTIt//+9edhyN5rVe9SiYN/OU40q5W96yIexs8wlVkyM5/P3dkKJ9K9whw4pCRAaKyHSgqohMc3gsBE57LkQQkTuBpsAH6c03xnxtjGlqjGlasmRJT4aWs819DTAuNYc9eCaWj+dG0KluabrW0zGwle9o3PF2fi3yAJWPLyBujmuZjlXWOPtZuAw4ApQAPnSYHg1syoZtHwIcBy2oYE+7jIh0Al4G2htjLmTDdhXAvuWwZRK0ex6KOm8jYPWZ2IoIvHFLPR0DW/kUEaH5wFeY+Pl/9F/xMZSrB6H9vB1WrpJhRWGM2QfsA25w07ZXAzVFpCpWBTEAuMOxgIiEYXX062aMOe6mOK4/Kcnw9/NQqDy0eSrT4n9uOMyCHcd5tWcI5Yvkc398SmVRrTKFmNjkdVatO0LTPx/Fr1g1qNDE22HlGq70zG4pIqtFJEZEEkQkWUTOXeuGjTFJwGPAbGA78JsxZquIDBeRcLvYB0BB4HcR2SAi0651uwprnImjm6wBifIUcFr0ZMwF3pi+lcaVijCkVRXPxKfUVXi8SwhD/Z/lJEUwEwZC1BUXKNRVcuVm9mhgIBAB5AP+D6tZ6zUzxsw0xtQyxlQ3xrxtTxtmjJlmP+9kjCltjGlkP8Kdr1FlKj7KGrmuYkuof1umxV+btpXzF5J5v2+o9plQPq1I/jzc07U5d8Y+Q3J8NEwYaDX/VtfMpaSAxphdgL8xJtkY8z3Qzb1hKbf55304fxK6j7A6Ljkxe+tRZmw6whMda1CjlOaBVL5vYLOK+JUO4UV5CnNkE0x9WFtCZQNXKopYEckDbBCR90XkaReXU77mZASsHANhd0K5MKdFo2ITeWXqFkLKFuLB9pkPhaqULwjw92NYrxB+j67P0ipPwLap8M973g4rx3PlC/8uwB/rfsJ5rJZKmV+zUL5n9ksQmB86Dsu06FsztnH6fALv9w0l0F9/F6ico1X1EtwcWpb7drUkps7t8M8I2PKHt8PK0VwZuGifMSbOGHPOGPOGMeYZ+1KUykn+mwMRc6D981DQefLfxf+d4Pe1B3mwXTVN06FypFdvDiHQz4+nYwdjKra0LkEdWuftsHIsV1o99RSR9SJyWkTOiUh0drR6Uh6UlACzX4TiNaD5g06LnotPZOjkTVQrWYAnOtb0UIBKZa8yhYN4unMt5v4XxaJGH0GBkjDhDmtwLpVlrlxT+AQrjUdxY0whY0ywMSbzFKPKd6z6Ck7tgq7vQkAep0Vfn7aVY9EX+LBfQ4ICMx8KVSlfNaRVFeqUCeblOUeJ6/cLxJ+zKovEOG+HluO4UlEcALYYY3QMipzo3BFY9B7U7AK1ujgtOmvLEf5Yd4hHO1QnrFJRDwWolHsE+PvxVu/6HI6K59PNeeG2b+DwevjzUWsMFuUyVzK7PQ/MFJF/gIspNIwxH7ktKpV95rwMyQnQ3XnLj+PR8bz4x2YalC/M43rJSeUSTasU4/amFfh2yR5ua9yOmh2HWUP+lqwL7Z/zdng5hitnFG8DsUAQEOzwUL5uzyJrUKI2T0OxahkWM8bw4uTNnE9I5uP+DbWVk8pVhnavS8GgAF6ZugXT+ikI7Q8L34Jtf3o7tBzDlTOKcsaY+m6PRGWvpASY+RwUrZJpPqeJqw8w387lpB3rVG5TrEAeXuhWhxf/2MyUDYfp0+szOL0HpjxkfT7KNvR2iD7PlZ+OM0XE+cVt5XuWj4aT/0H3DyAw40R++0/F8uZf22hVvTj3aC4nlUv1b1qRsEpFeGvGdk4n+EH/XyBfMfh1IEQf83Z4Ps+ViuJhYJaIxGnz2Bzi7AFY/AHU6en0BnZScgrP/LYBPxE+6NcQP83lpHIpPz9hRJ9QouMTGT59KwSXhoHjIe6M3RIq3tsh+jRXOtwFG2P8jDH5tHlsDjH7RatVR7d3nRb7dH4Ea/ad4c3e9TV9uMr1apcJ5pEONZi64TALdxy3Ljnd+hUcWgPTHteWUE44G+Gujv23cXoPz4WosiRiHmyfbrXoKFIpw2L/7jrJ6IW76NekAr3DnI1Aq1Tu8ciN1alZqiAvT9lMzIUkCAmHG1+Bzb9ZwwKrdDk7o3jG/vthOo+Rbo5LXY2EWJj5PyheE254PMNiJ2Mu8NTEDVQrUYA3bqnnwQCV8q68Af681zeUI+fieX/WDmtiu2etlPvzh8OOGd4N0Ec5G+HuAftpd2PMZRfwRCTIrVGpq7PoXTgTCUNmZNgDOyXF8MxvG4mKS+THe5uTP48rDd+Uyj0aVyrKkFZVGLcskl4Ny9GsSjG45XM4vRcm3w/3zYYyDbwdpk9x5Wb2MhenKW86vN5q6dRkCFRpk2Gxr5fsYfF/JxjWM4S6ZfVWk7o+PdulNuUK5+OFyZuIT0y2WgYOGA9Bha2WUDE68rIjZ/coyohIEyCfiIQ53J/oAOT3VIDKBcmJ1s24AqWg0xsZFlu3/wwjZ++ke/0yDGqR8f0LpXK7AnkDeLdPA/acOM+oBRHWxEJlrZZQ50/CxDsh6YLzlVxHnJ1RdMW6F1GBy+9PPAO85P7QlMuWj4ajm+HmkZCvSLpFzpxP4PHx6ylTOIgRt4UimYxup1Ru165WSfo1qcCYf/awbv8Za2K5MOj9BRxYCdOf0pZQtgwrCmPMD8aYG4EhxpibjDE32o9wY4yOAuIrTu2GRSOgbi/rkY7kFMMTE9ZzIvoCo+9oTOF8gR4OUinf9GqvEMoUCuKZiRuITUiyJtbvA+2Hwsbx8O8nXo3PV7hyj6KCiBQSy7cisk57avsIY2D6k+Cf1+qBnYEPZu9kScRJ3uxdj0YVi3guPqV8XKGgQD68vSH7Tsfy9oztl2a0fwHq9YF5r1v50q5zrlQU9xpjzgFdgOJYQ6OOcGtUyjXrfoTIJdBluHV9NR0zNh1hzD+7uaNFJfo30/sSSqXVslpx7m9bjV9W7mfhTvsmtp8f9P4SKt1g5YTat9y7QXqZKxVF6sXsHsCPxpitDtOUt0QdhDmvQuU2EHZ3ukV2Ho3muUkbCatUhNd6hXg4QKVyjv91qUWdMsE8P2kTp88nWBMDg6yWUEUqwYSBcDLCu0F6kSsVxVoRmYNVUcwWkWAgxb1hKaeMsQZfSUmCW0ZZv37SiIpL5MGf1pA/TwBj7mxC3gAdrU6pjOQN8Oej2xtxNjaBl/7YzMVx2vIXg0G/g/jDL30h5oR3A/USVyqK+4ChQDNjTCyQB7jHrVEp51Z/a4010eXNdMeZSE4xPDNxAwfPxPHlnY0pXUj7RyqVmZByhfhfl9rM2nqUP9YdujSjWDUYOAGij8KvA6wMCNcZVyoKA4QAT9ivC2ANYqS84dRumDsMqneEpvemW+S9WTuYv+M4w3qFWL1OlVIuub9tNZpXKcZr07ay9+T5SzMqNoPbvoVDa+GP+yEl2XtBeoErFcUXwA3AQPt1NPC52yJSGUtJhqkPg38g3DIa0ukL8euq/Xy9eA9331CZu1pW9kKQSuVc/n7CxwMa4e8nPDZ+ndVrO1XdXlZG5h1/wZxXvBekF7hSUbQwxjwKxAMYY85gXX66ZiLSTUR2isguERmazvy8IjLRnr9SRKpkx3ZzrCUfWR2BeoyEQuWumL004iSvTt1C+1olGdYzRDvVKXUVyhfJx4f9GrL18LnLm8wCtHwYWjwMK76AZaO9E6AXuFJRJIqIP9YlKESkJNlwM9te5+dAd6xLWwNFJG3TnPuAM8aYGsDHwHvXut0ca/8KK+lfg37WI41dx6N5+Je1VC9ZkNF3hBGg414rddU6hZTm/rZV+WnFPmZuPnL5zK5vQ8gtMOdl2PCrdwL0MFe+TT4DpgClRORtYCnwTjZsuzmwyxizxxiTAEwAbklT5hbgB/v5JKCjXI8/k+POwuT/g8IV4OaPrrjkdDQqnru/W0XeAH++G9KU4CDtea3UtXq+Wx0aVSzCC5M2Eel4v8LPH/p8A1XbW60P/5vtvSA9xJUR7n4BngfeBY4AvY0xv2fDtssDBxxeH7SnpVvGGJMERGF1+rt+GAPTn4DoI9B3LARdnvE1KjaRwWNXcS4+iXH3NKNCUc3XqFR2CPT3Y/QdYfj7Cw/8tIbzF5IuzQzICwN+sdKR/zbYOuPPxVy6PmGM2WGM+dwYM9oYsz3zJTxLRB4QkTUisubEiVzWznntONj2J9z0ClRoetms+MRk/u/H1ew5GcPXdzWhfvnC3olRqVyqQtH8jB7YmF3HY3hu0sZL/SsA8gbDnZOhcHkYfzsc2+q9QN3MmxeyDwEVHV5XsKelW0ZEAoDCwKm0KzLGfG2MaWqMaVqyZEk3hesFh9bB3y9AtRuh1ZOXzUpMTuHxX9ezZt8ZPu7fiFY1SngpSKVytzY1SzC0ex1mbj7Kl//svnxmgRJw1xQILAA/9bEGP8qFvFlRrAZqikhVEckDDACmpSkzDRhsP+8LLDDmOsn7e/4U/HY3FCwFt313We/rZHuUurnbjvF6r3r0DL2yBZRSKvvc37Ya4Q3L8cHsnSzamWZQoyKV4K4/IPkC/BgOZ/d7J0g38lpFYd9zeAyYDWwHfjPGbBWR4SISbhf7DiguIruwxsG4ogltrpSSDJPvtUbZuv1HKHDptkxKiuGFyZuYvvEwQ7vXYXCrKt6LU6nrhIjw3m2h1C1TiMfHr2fn0ejLC5Sqa51ZxEXBD70gKu3FkZxNctsP9KZNm5o1a9Z4O4xrM+91WPoxhI+CxpcS/hljePXPLfy8Yj9PdarJU51qeS9Gpa5DR6Li6P35v/iLMPXR1pRKmx7n4Fr4qbd1SWrIzAyzOvsiEVlrjGma3jxtbO9rNv1mVRKNB19WSaSkXKokHmxfjSc71vRikEpdn8oWzsd3g5txNi6R+35Yc2mwo1QVmlg3uGOOW2cW0ce8E2g204rCl+xbZrXLrtwGelwaiCg5xTD0j00XK4mh3epor2ulvKR++cKMviOMrYejeOLX9SQlp+l/XLG5lXH23CHrnkUuyDirFYWvOLUbJgyyboz1/8lqpw0kJafwv9828NuagzzZsaZWEkr5gJvqlOaN8HrM236cFyZvJiUlzSX8yq3gjt/gzD4YdzOcO+ydQLOJVhS+IPY0/GKn5Rj0u5UDH6ufxKPj1zF1w2Ge61qbpzvX0kpCKR9x1w1VeKpTTSavO8jwv7Zxxf3eqm2ty1DnDsPYbjm66axWFN4Wfw5+vg2iDsDAXy+OLxEVm8hd361kzrZjvN4rhEdvrOHlQJVSaT3ZsSb/16Yq45ZF8tHc/64sUKU1DP4TLpyD77vD8R2eDzIbaEXhTQmxML4/HN0E/X6ASi0BOHw2jr5jlrHxQBSjBoYxpHVVLweqlEqPiPDyzXUZ0KwioxbsYvSCdIZLLd/EagFlUqzKYv9Kzwd6jbSi8JakCzBxEBxYAX2+hjo9ANhyKIo+XyzjaFQ84+5tpp3plPJxIsLbtzbg1rDyjJzzHyNn77zyMlTpELh3FuQrarWG2jrVK7FeLa0ovCEx3up1vXsBhI+G+rcBMH3jYfqOWYafwG8P3UCr6pqWQ6mcwN9PGNmvIQOaVWT0wl28PWP7lZVFsWpw31wo1wh+H2KNZ5FD+rEFeDuA6058FPx6B+xbaqUMDxtESorh43n/MWrBLppWLsqYu5pQomBeb0eqlMoCfz/h3T4NCAr059ule4lNTGZ4eL3Lx4YpUBzu/hOmPGiNZ3FypzUQWYBvf961ovCkmOPWjevj26DPtxDaj9PnE/jfbxtYuPMEtzetwJu965M3wN/bkSqlroKI8FqvEPLn8eeLRbs5cjaOUXc0pmBeh6/awHzQdxwsfAuWfGhlnb39JysLrY/SS0+ecmo3jO0KJyNg4AQI7cfqyNP0+HQJ/+46xZu31OO920K1klAqhxMRnu9Wh7d612dxxEn6jVnOkai4ywv5+UHHYdD/ZzixE75uD3uXeCdgF2hF4Qk7ZsLXHayR6u7+k6RqHfl84S4GfL2CvIF+/PFIK+66oYr2kVAqF7mzZWXGDmnGgdOx9P78X9btP3Nlobq94P4FEFTEusk973VISvB0qJnSisKdUpJhwVswYaB1I+vBf9gVVI++Y5bzweyddK9fhr8eb6MDDimVS7WvVZJJD99AoL8ft49ZzrdL9lx5k7tkbXhgETS+y8rz9m1H6yzDh2j2WHc5vQemPQGRS6DRnSR1/4CxK48wcs5/5M/jz/Bb6tMrtKyeRSh1HYiKTeTZSdYYMp1DSjOyb0MK509nbPvtf1lDHyech7b/g1ZPQGDQleXcwFn2WK0osltKMqz40jqT8AuAbu+wqsjNDJu2lR1Ho+kcUpq3b61PqWDP/POVUr7BGMN3S/cy4u8dFC+Yh7d7N6BTSOkrC0Yfg7+fh21TrSsR3T+Amp3cHp9WFJ6ydzHMfQ0Or4OaXTnefgTvLI1i6obDlCscxCs9Q+hev4yeRSh1Hdt08CzPT9rEjqPRhDcsx2u9QiieXnP43Qtg5nNwahfU6ATtX7Ay07qJVhTutm85LHzbuswUXJbodsP45GhDfl65HwM82K4aj3SoQb482qJJKQUJSSmM+Wc3oxZEUCBvAI/fVJM7W1a6stVj0gVYOQaWfgJxp6HajdYlqSptIJt/cGpF4Q4Xoq3riWu/hwMroUApzjV9nDGx7fh+xVEuJCXTp3EFnuxYk4rF8rs/HqVUjvPfsWje/GsbSyJOUqFoPp7tUpvwhuXw80tTCVyIgTXfwb+fQexJ65JUozug4UAoXCFbYtGKIjskxsGxbValsGeR9Ui+gCleg4PVB/LR6VZM23aWFGPoFVqOJzvVpHrJgtkfh1Iq11kScYJ3Z+5g25FzVC1RgCGtqnBbkwqXd9QDK5Ho1imwYbyV3QGBMvWhSlvrUfkGK5/UVdCKwhXx52BUEyhQ0hoPwj/QujF9IRqij0L0EcDeV8WqcbbCjczmBr7eU4LdJ2MJDgpgQLOK3NWyCpWK6xmEUiprUlIMM7cc4dsle9lw4CzBeQO4rUkFeoaWpXGloleeZZzeC1smWfdGD6yCpHgoFQKPLL+q7WtF4YrY01Znl/MnrWuByYng5w95CkJwGeILlGe7qcTCc+WZdcCf/47FIAItqhYjvGF5bmlUjgJpa3+llLoK6/af4ft/I5m99SgJSSmULpSX7vXL0rJacZpULkrJ4DQ3v5MuwKG1VrPamp2vaptaUbggISmFrYejOBuXSFRsImdjEzh0No6I4zFEHIvh0FmrC35QoB/NqhSjQ+1S9AwtS+lC2sxVKeUe0fGJLNhxnBmbjvDPfye4kGSNz125eH7qlAmmYtH8VCiajzKF81EoKIDiBfNSu0zwVW1LKwoXnIy5QNO35l02LW+AH9VKFqRmqYLUKl2Q5lWL07BiYc3HpJTyuAtJyWw5dI51+86wdt8Zdp2I4eCZWOITUy6WaVixCH8+2vqq1u+sotBrJbYi+QL5fkgzCucPpEi+QIrkz0PhfIH4p70uqJRSXpA3wJ8mlYvSpHJR7renGWM4dT6Bo1HxxFxIItDfPVmZtKKwBfj7cWOdUt4OQymlXCYilCiY1+3j12hSQKWUUk5pRaGUUsoprSiUUko55ZWKQkSKichcEYmw/17RlVBEGonIchHZKiKbRKS/N2JVSqnrnbfOKIYC840xNYH59uu0YoG7jTH1gG7AJyJSxHMhKqWUAu9VFLcAP9jPfwB6py1gjPnPGBNhPz8MHAdKeipApZRSFm81jy1tjDliPz8KpDN6xyUi0hzIA+zOYP4DwAP2yxgR8a1xBK9UAjjp7SBclFNizSlxQs6JNafECTknVl+Os3JGM9zWM1tE5gFl0pn1MvCDMaaIQ9kzxph0Ux6KSFlgETDYGLPCDaF6nIisyagHpK/JKbHmlDgh58SaU+KEnBNrTokzLbedURhjMhy7T0SOiUhZY8wRuyI4nkG5QsAM4OXcUkkopVRO4617FNOAwfbzwcCfaQuISB5gCvCjMWaSB2NTSinlwFsVxQigs4hEAJ3s14hIUxH51i5zO9AOGCIiG+xHI69Em/2+9nYAWZBTYs0pcULOiTWnxAk5J9acEudlcl32WKWUUtlLe2YrpZRySisKpZRSTmlF4UEiMtHhfkukiGywp1cRkTiHeWO8HOfrInLIIZ4eDvNeFJFdIrJTRLp6M047ng9EZIed5mVKau99X9undkzd7P22S0TSy0bgNSJSUUQWisg2O23Ok/b0DI8FL8YaKSKb7XjW2NMyTQvkhThrO+y3DSJyTkSe8sV9mhm9R+ElIvIhEGWMGS4iVYC/jDH1vRwWYH05ADHGmJFppocAvwLNgXLAPKCWMSbZ40FeiqkLsMAYkyQi7wEYY17wwX3qD/wHdAYOAquBgcaYbV4NzGY3Uy9rjFknIsHAWqyMCbeTzrHgTSISCTQ1xpx0mPY+cNoYM8KuhIsaY17wVoxp2f//Q0AL4B58bJ9mRs8ovEBEBOsD+Ku3Y8miW4AJxpgLxpi9wC6sSsNrjDFzjDFJ9ssVQAVvxuNEc2CXMWaPMSYBmIC1P32CMeaIMWad/Twa2A6U925UWZJpWiAv6wjsNsbs83YgV0MrCu9oCxxLzWVlqyoi60XkHxFp663AHDxmX84Z63AaXx444FDmIL71ZXIv8LfDa1/ap76+7y6yz8bCgJX2pPSOBW8ywBwRWWun74EspgXyggFc/sPQ1/apU1pRZDMRmSciW9J5OP56HMjlB80RoJIxJgx4Bhhv90r3VpxfAtWBRnZsH7ozlmuMNbXMy0AS8Is9yeP7NDcQkYLAZOApY8w5fOxYsLUxxjQGugOPikg7x5nGup7uM9fUxeo8HA78bk/yxX3qlI6Znc2cpS4BEJEAoA/QxGGZC8AF+/laEdkN1ALWeCvOVCLyDfCX/fIQUNFhdgV7mlu5sE+HAD2BjvaXhFf2aSa8su+yQkQCsSqJX4wxfwAYY445zHc8FrzGGHPI/ntcRKZgXdZzKS2Ql3QH1qXuS1/cp5nRMwrP6wTsMMYcTJ0gIiXtm12ISDWgJrDHS/Gl3thMdSuwxX4+DRggInlFpCpWnKs8HZ8jEekGPA+EG2NiHab71D7FunldU0Sq2r8wB2DtT59g3zf7DthujPnIYXpGx4JXiEgB+2Y7IlIA6GLHlGlaIC+67AqCr+1TV+gZheelvVYJVqqS4SKSCKQADxljTns8skveFytdigEigQcBjDFbReQ3YBvWZZ5HvdniyTYayAvMtb7rWGGMeQgf26d2q6zHgNmAPzDWGLPVW/GkozVwF7BZ7GbbwEvAwPSOBS8qDUyx/9cBwHhjzCwRWQ38JiL3AfuwGot4nV2Zdeby/Zbu58uXafNYpZRSTumlJ6WUUk5pRaGUUsoprSiUUko5pRWFUkopp7SiUEop5ZRWFCpddobLZ+3nw0XE2Rjove2EgR5n9+mYZ2fh7O+NGDxJrKy4d1zFcuNEpO81bPchEbn7Kpd1Kea05cQa8fKzq9mmyl5aUahMGWOGGWPmOSnSG/BKRYGVkwhjTCNjzETHGakd7jzJA9usAmS5orgWIhJgjBljjPnxKldRBddivqycMWaNMeaJq9ymykZaUaiLRORlEflPRJYCtR2mX/w1KiIjxBqzYJOIjBSRVlh5bD6wf9VXF5H7RWS1iGwUkckikt9hPZ+JyDIR2eP4C1dEXhBrjIGNIpI6hnp1EZklVvK3JSJSJ028pYCfgWYO244UkfdEZB3QT0QG2uvdInYacnvZGLHGsthqn5E0F5FFdlzh6eybDiKyWERmiDWmxBgR8XNY14cishG4QUTuFJFVdkxfiYi//Rhnx7FZRJ529h6d7KsRQFt73U/b6/3A3t+bRORBe3kRkdF2rPOAUhn8zxuJyAq5NJ5HUXv6IhH5RKzxHp5Mc4Z5rTFXsZdbZz9aZVCug4j8Za+7mIhMteNcISKh9vTXxUqsl/q/04rFHYwx+tAHWLmnNgP5gUJYKcSfteeNA/oCxYGdXOqoWcRxvsO6ijs8fwt43KHc71g/UEKw0m6DlQtnGZDffl3M/jsfqGk/b4E17kTauDtgjTuR+joSeN5+Xg7YD5TE6sW7AOhtzzNAd/v5FGAOEAg0BDZksJ14oBpWz+q5qe/ZXtft9vO6wHQg0H79BXC3vX/nOqyviLP36GRfpX2/DwCv2M/zYuWyqoqVT2yuHWs54Kzj/8hh+U1Ae/v5cOAT+/ki4AuHcq87HA/XGnN+IMh+XhNYk0G5i6+BUcBr9vObUv9HdlzL7PdeAjiVuu/1kX0PTeGhUrUFphg7X5KIpJeHKArry/I7+5deRsnM6ovIW0ARoCBW2opUU40xKcA2EUlNBd0J+D5128aY02JlMW0F/C5WugawvgxckXoJqhmwyBhzwn5Pv2Cl9pgKJACz7HKbgQvGmEQR2Yx1CSQ9q4wxe+x1/Qq0ASYByVjJ9MAad6AJsNqOOx9WgrrpQDURGQXMwEqTndl7TG9fpdUFCHX49V4Y68u3HfCrsVKsHBaRBWkXFJHCWBXWP/akH7iU4RQu7UfHZbIj5kBgtFhpLJKxkjVmpg1wG4AxZoGIFJdL2YBnGDsJpIgcx0rzcTCD9airoBWFcpmx8hU1x/oy7As8hvXrLq1xWL/cN4qV2bWDw7wLDs+FjPkBZ40xja4i1PMulEk09k9SrFxQqZlmU8TK8JuetPluUl/Hm0s5rwT4wRjzYtqFRaQh0BV4CCsX0VM4f4+u7CvBOmObfdnE7BleM739mNn/xZWYnwaOYZ29+WH9+LgWjttMRr/Xsp3eo1CpFgO9RSSfWNk5e6UtYP+aLGyMmYn1YW9oz4oGgh2KBgNHxEpbPciFbc8F7pFL9zKKGWsshL0i0s+eJvYXbVasAtqLSAmxbjIPBP7JZBlnmouV/dUP6A8sTafMfKCvWPdPUq+tVxaREoCfMWYy8ArQ+CrfY9p9PRt42N7XiEgtsRLRLQb62/cwygI3pl2RMSYKOCOXBnW6i0z2TzbFXBg4Yp953IV1eSy9co6WYB9LItIBOGnHojxAa14FgLHGSp4IbMS6VLI6nWLBwJ8iEoT1a/EZe/oE4Bv7RmJf4FWs0dFO2H8z+vCnbnuWfRlijYgkADOxMpcOAr4UkVewLldMsONz9T0dEWv85IV2vDOMMdeSfno1VrbaGvY6p6SzzW12vHPsCiUReBSIA763pwGknnFk9T1uApLFunE+DvgU61LZOrGuBZ3AaoU2BetsbxvWfZrlGaxvMDDGrqT3YI3nnJlrjfkLYLJYzW1ncenMJW259Q7reB0YKyKbgFgupRRXHqDZY5Vygf0r9lljTE8vh6KUx+mlJ6WUUk7pGYVSSimn9IxCKaWUU1pRKKWUckorCqWUUk5pRaGUUsoprSiUUko59f/oiAFD7Ko7hgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Test the model on the viewed orientation (WM distractor)\n", + "tst_dist_tc = wm_data['tst_d']\n", + "n_tst_dist, _ = tst_dist_tc.shape\n", + "pred_features = iem_obj0._predict_feature_responses(wm_data['tst_d'])\n", + "# Re-center all the reconstructions to a common point\n", + "pred_features_centered = np.ones((feature_resolution, n_tst_dist)) * np.nan\n", + "for trial in range(n_tst_dist):\n", + " pred_features_centered[:, trial] = np.roll(pred_features[:, trial],\n", + " shift_to - int(wm_data['tst_d_conds'][trial]))\n", + "\n", + "dist_avg_feats = pred_features_centered.mean(axis=1)\n", + "\n", + "plt.plot(iem_obj0.channel_domain - shift_to, avg_feats)\n", + "plt.plot(iem_obj0.channel_domain - shift_to, dist_avg_feats)\n", + "plt.ylim([-0.2, 1.0])\n", + "plt.xlabel('distance from presented orientation')\n", + "plt.ylabel('estimated channel response')\n", + "plt.legend(['remembered orientation', 'distractor orientation'])\n", + "plt.title('Reconstruction of WM and distractor orientations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the distractor orientation is simultaneously represented in the same data!\n", + "\n", + "Read more about these data in the [full paper](https://www.nature.com/articles/s41593-019-0428-x).\n", + "\n", + "Rademaker, R., Chunharas, C., Serences, J.T. 2019. Coexisting representations of sensory and mnemonic information in human visual cortex. Nature Neuroscience 22:8." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: Reconstructing 2D spatial representations with attention and contrast changes " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Itthipuripat et al. 2019](https://www.jneurosci.org/content/39/31/6162) collected data from participants as they viewed flickering checkerboard stimuli presented at a range of contrasts (0-70%, logarithmically spaced) on either the left or right of the screen. They either attended to an occasional change in contrast at the stimulus position (\"attend stimulus\") or at the central fixation point (\"attend fixation\"). These contrast change trials are excluded from the data, so the sensory input is equated across conditions.\n", + "\n", + "The IEM will be trained on an independent dataset, in which participants viewed checkerboards as they appeared at many locations across the screen. Then we will test the IEM, i.e. reconstruct the stimulus, under the different contrast and attention conditions." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the fMRI data\n", + "data = scipy.io.loadmat('AL61_Bilat-V1_attnContrast.mat')\n", + "trn_conds = data['trn_conds'] # position in space for 128 trials\n", + "# flip to cartesian coordinates to make life easier\n", + "trn_conds[:,1] = trn_conds[:,1]*-1\n", + "trn = data['trn'] # matrix of (trials, voxels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The test data have different conditions than the training data. There are four independent variables in these data based on the values in the following columns: \n", + "- In column 1, whether the stimulus was on the left (1) or right (2) side of the screen. \n", + "- In column 2, the logarithmically spaced stimulus contrast from lowest (1) to highest (6). \n", + "- In column 3, the task instruction to attend to fixation (1) or the stimulus (2).\n", + "- In column 4, whether the target was present (1) or not (0)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Note there are several different conditions in the test data.\n", + "tst_conds = data['tst_conds']\n", + "tst = data['tst']\n", + "attn_conds = np.unique(tst_conds[:, 2])\n", + "stim_contrasts = np.unique(tst_conds[:, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up parameters\n", + "n_channels = [9, 5] # channels in the x, y directions\n", + "cos_exponent = 5\n", + "stimx, stimy = [-17/2, 17/2], [-5, 5]\n", + "stim_res = [171, 101]\n", + "npixels = stim_res[0] * stim_res[1]\n", + "stim_size = 1.449\n", + "chanx, chany = [-6, 6], [-3, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "iem_obj = IEM.InvertedEncoding2D(stim_xlim=stimx, stim_ylim=stimy,\n", + " stimulus_resolution=stim_res,\n", + " stim_radius=stim_size,\n", + " chan_xlim=chanx, chan_ylim=chany,\n", + " channel_exp=7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region. You also will likely want to ensure some overlap between the basis functions.\n", + "\n", + "There are two pre-built functions to create a 2D grid of basis functions, to use a rectangular grid or a triangular grid. A triangular grid is more space-efficient, so let's use that.\n", + "\n", + "Note you will need to define these basis functions before you can fit the model. Otherwise it will throw an error." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "basis_fcns, basis_centers = iem_obj.define_basis_functions_sqgrid(n_channels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize these, you will need to reshape the second dimension into the 2D pixel space where the stimuli are represented." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(n_channels[1], n_channels[0], figsize=[18, 8])\n", + "i = 0\n", + "for ii in range(n_channels[1]):\n", + " for jj in range(n_channels[0]):\n", + " ax[ii, jj].imshow(basis_fcns[i, :].reshape(stim_res[1], \n", + " stim_res[0]),\n", + " extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n", + " i += 1\n", + "plt.suptitle('Images of each basis function', fontsize=25)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check how well the basis functions cover the stimulus domain, we can sum across all the basis functions." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Spatial coverage of basis functions')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sum_fcns = basis_fcns.sum(axis=0).reshape(stim_res[1], stim_res[0])\n", + "plt.imshow(sum_fcns, extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n", + "plt.title('Spatial coverage of basis functions')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we want to map channel responses for each voxel. To do this, we fit a standard general linear model (GLM), where the design matrix is the channel activations for each trial. Below, you can see the design matrix of these trial activations in the channel domain (x-axis: trials, y-axis: channels, color: activations)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(128, 45)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "C = iem_obj._define_trial_activations(trn_conds)\n", + "plt.imshow(C)\n", + "print(C.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whenever you run the fit() function, the trial-wise channel activations will be created automatically, and the GLM will be fit on the training data and feature labels. Using this, we can then predict the feature responses on a set of test data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "iem_obj = iem_obj.fit(trn, trn_conds)\n", + "stim_reconstructions = iem_obj.predict_feature_responses(tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Average feature reconstructions across trials\n", + "\n", + "In this experiment, we are not specifically interested in separating trials by whether stimuli were on the left or the right. Instead, we're interested in how the activation in the model-based reconstruction varies with the experimental manipulation of contrast and attended location. For the sake of visualization and quantification, we can simply average across the trials of interest. Below we separated the trials by contrast and attention location, but averaged across trials where the stimulus appeared on the left side of the screen and the target was not present (to ensure that overall contrast is identical across averaged trials)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "vmin, vmax = 0, 0\n", + "mean_recons = np.zeros((stim_contrasts.size, attn_conds.size, npixels))\n", + "\n", + "for aa, attn_cond in enumerate(attn_conds):\n", + " for ss, contrast in enumerate(stim_contrasts):\n", + " thisidx = np.argwhere((tst_conds[:, 0] == 1) &\n", + " (tst_conds[:, 1] == contrast) &\n", + " (tst_conds[:, 2] == attn_cond) &\n", + " (tst_conds[:, 3] == 0))\n", + " rs = np.mean(stim_reconstructions[:, thisidx], axis=1)\n", + " if rs.min() < vmin:\n", + " vmin = rs.min()\n", + " if rs.max() > vmax:\n", + " vmax = rs.max()\n", + " mean_recons[ss, aa, :] = rs.squeeze()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we plot the data as a function of:\n", + " \n", + "1) whether subjects were attending to the stimulus or fixation, and\n", + "2) the contrast of the stimulus (across six levels)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(6, 2, figsize=(10,16))\n", + "for aa, attn_cond in enumerate(attn_conds):\n", + " for ss, contrast in enumerate(stim_contrasts):\n", + " ax[ss, aa].imshow(mean_recons[ss, aa, :].\\\n", + " reshape(stim_res[1], stim_res[0]),\n", + " origin='lower', interpolation='none',\n", + " cmap='inferno',\n", + " extent=[stimx[0], stimx[1], stimy[0], stimy[1]],\n", + " vmin=vmin, vmax=vmax)\n", + " if contrast == stim_contrasts[0]:\n", + " if attn_cond == 1:\n", + " ax[ss, aa].set_title('Attend fixation')\n", + " elif attn_cond == 2:\n", + " ax[ss, aa].set_title('Attend stimulus')\n", + " if attn_cond == 1:\n", + " ax[ss, aa].set_ylabel('Contrast value {}'.format(contrast))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These data suggest that increasing the contrast leads to stronger activation of the stimulus. They also suggest that the effect of attention is greatest at low contrast levels -- e.g. at contrast level 3, we see a clear enhancement when the participant is attending to the stimulus compared to when they are attending fixation.\n", + "\n", + "However, since this is single-participant data, these effects should be quantified across a group of subjects.\n", + "\n", + "Read the full results in [the paper](https://www.jneurosci.org/content/39/31/6162).\n", + "\n", + "Itthipuripat, S., Sprague, T.,C., Serences, J.T. 2019. Functional MRI and EEG Index Complementary Attentional Modulations. J. Neurosci. 31:6162-6179." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3: Comparing SVM and IEM with simulated data and low trial numbers " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the assumptions of the forward encoding model are a good match to the data, it can outperform common decoding algorithms such as support vector machine (SVM) classifiers. Here, we simulate fMRI responses from a set of 1D receptive fields with Gaussian-like tuning along an orientation space.\n", + "\n", + "Then, we train an IEM and SVM on the same data: simulated responses from these voxel receptive fields to 7 orientation stimuli (`stim_vals`). We then score the accuracy of each model by calculating the coefficient of determination, R2. Note that although the IEM can provide a continuous stimulus reconstruction, we are simply taking the feature value with the maximal response to be the predicted orientation. The SVM is a 7-way classifier." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import brainiak.utils.fmrisim as fmrisim\n", + "\n", + "np.random.seed(100)\n", + "range_start = 0\n", + "range_stop = 180\n", + "feature_range = (range_start, range_stop)\n", + "n_stim_classes = 7\n", + "feature_resolution = 180\n", + "stim_vals = np.linspace(0, feature_resolution - (feature_resolution/n_stim_classes), n_stim_classes).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Define IEM\n", + "iem_sim = IEM.InvertedEncoding1D(6, 5, stimulus_mode='halfcircular', \n", + " range_start=range_start, range_stop=range_stop, \n", + " channel_density=180)\n", + "\n", + "# Define SVM\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# Create a classifier model for the training set\n", + "svc_model = LinearSVC(C=n_stim_classes, max_iter=5000) #, dual=True)\n", + "scaler = StandardScaler()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to define a function which can calculate R2 in a circular space. A version of this function is included with the 1D IEM module, but we need it here to score the SVM." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from brainiak.utils.utils import circ_dist\n", + "\n", + "def circ_score(true_features, pred_features):\n", + " # multiply features by 2 because it's 180 space. otherwise doesn't wrap properly\n", + " pred_features = pred_features * 2\n", + " true_features = true_features * 2\n", + "\n", + " ssres = (circ_dist(np.deg2rad(true_features),\n", + " np.deg2rad(pred_features)) ** 2).sum()\n", + " sstot = (circ_dist(np.deg2rad(true_features),\n", + " np.ones(true_features.size) * scipy.stats.circmean(\n", + " np.deg2rad(true_features))) ** 2).sum()\n", + " score_value = (1 - ssres / sstot)\n", + "\n", + " return score_value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We simulate two sources of uniform noise: consistent noise in the receptive field responses (`rf_noise`) and trial-wise noise. This relies on some simple functions packaged with BrainIAK that can provide the user ways to test how the IEM behaves with known inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def fit_models(n_train, n_tst, iem_sim=iem_sim, svc_model=svc_model, n_voxels=24,\n", + " rf_noise=0.1, trial_noise=0.5):\n", + " trn_stim = np.repeat(stim_vals, n_train / n_stim_classes).astype(int)\n", + " tst_stim = np.repeat(stim_vals, n_tst / n_stim_classes).astype(int)\n", + " voxel_RFs, voxel_tuning = fmrisim.generate_1d_gaussian_rfs(n_voxels,\n", + " feature_resolution,\n", + " feature_range,\n", + " rf_size=30,\n", + " random_tuning=True, \n", + " rf_noise=rf_noise)\n", + " trnd = fmrisim.generate_1d_rf_responses(voxel_RFs, trn_stim, \n", + " feature_resolution, feature_range,\n", + " trial_noise=trial_noise)\n", + " trn = scaler.fit_transform(trnd)\n", + " # IEM\n", + " iem_sim = iem_sim.fit(trnd.T, trn_stim)\n", + " tstd = fmrisim.generate_1d_rf_responses(voxel_RFs, tst_stim, \n", + " feature_resolution, feature_range,\n", + " trial_noise=trial_noise)\n", + " tst = scaler.fit_transform(tstd)\n", + " pred_feature = iem_sim.predict(tstd.T)\n", + " iem_r2 = iem_sim.score(tstd.T, tst_stim)\n", + " # Linear SVM\n", + " svc_model.fit(trn.T, trn_stim)\n", + " svc_pred = svc_model.predict(tst.T)\n", + " svc_score = circ_score(tst_stim, svc_pred)\n", + " \n", + " return iem_r2, svc_score, trn, tst" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data simulations are repeated 25 times, and the R2 values are averaged across these repeats to account for any random variability." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "nt_list = np.arange(n_stim_classes, n_stim_classes*15, n_stim_classes)\n", + "n_repeats = 25\n", + "iem_score = np.zeros((n_repeats, nt_list.size))\n", + "svm_score = np.zeros((n_repeats, nt_list.size))\n", + "for i, nt in enumerate(nt_list):\n", + " for j in range(n_repeats):\n", + " try:\n", + " iem_score[j, i], svm_score[j, i], trn, tst = fit_models(nt, n_stim_classes*3,\n", + " n_voxels=15,\n", + " rf_noise=1.5,\n", + " trial_noise=1.5)\n", + " except:\n", + " print(i, j)\n", + "# print('%i\\t%0.2f\\t%0.2f' % (nt, iem_score[:, i].mean(), svm_score[:, i].mean()))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(nt_list, iem_score.mean(axis=0))\n", + "plt.plot(nt_list, svm_score.mean(axis=0))\n", + "plt.xlabel('trial number')\n", + "plt.ylabel('R2')\n", + "plt.legend(['IEM', 'SVM'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that both models improve with more trials, but the IEM consistently outperforms the SVM in all cases.\n", + "\n", + "Next, we'll hold the number of trials constant and vary how much noise is added to the receptive fields." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "rfn_list = np.arange(1.5, 0.15, -0.05)\n", + "n_repeats = 25\n", + "iem_score2 = np.zeros((n_repeats, rfn_list.size))\n", + "svm_score2 = np.zeros((n_repeats, rfn_list.size))\n", + "for i, rfn in enumerate(rfn_list):\n", + " for j in range(n_repeats):\n", + " try:\n", + " iem_score2[j, i], svm_score2[j, i], trn, tst = fit_models(28, n_stim_classes*3,\n", + " n_voxels=15,\n", + " rf_noise=rfn,\n", + " trial_noise=1)\n", + " except:\n", + " print(i, j)\n", + "# print('%0.2f\\t%0.2f\\t%0.2f' % (rfn, iem_score[:, i].mean(), svm_score[:, i].mean()))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(rfn_list, iem_score2.mean(axis=0))\n", + "plt.plot(rfn_list, svm_score2.mean(axis=0))\n", + "plt.xlabel('RF noise')\n", + "plt.ylabel('R2')\n", + "plt.legend(['IEM', 'SVM'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we see that both models perform worse with higher noise, but the IEM consistently outperforms the SVM." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The IEM allows us to build a decoder that relies on a specific hypothesis about how a stimulus is encoded. In cases where this hypothesis is a better characterization of how the stimulus evokes fMRI responses, the IEM can outperform standard decoding approaches like the SVM. In addition, the specific form of the IEM allows for a natural way to visualize a decoded stimulus, i.e. to reconstruct the stimulus that must have been seen on any given trial." + ] + } + ], + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/iem_example_synthetic_RF_data.ipynb b/docs/examples/iem_synthetic_RF/iem_example_synthetic_RF_data.ipynb similarity index 100% rename from docs/examples/iem_example_synthetic_RF_data.ipynb rename to docs/examples/iem_synthetic_RF/iem_example_synthetic_RF_data.ipynb diff --git a/docs/examples/isc/ISC.ipynb b/docs/examples/isc/ISC.ipynb new file mode 100644 index 00000000..dcf73da4 --- /dev/null +++ b/docs/examples/isc/ISC.ipynb @@ -0,0 +1,649 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intersubject correlation\n", + "\n", + "Author: Samuel A. Nastase ([sam.nastase@gmail.com](mailto:sam.nastase@gmail.com))\n", + "\n", + "This notebook provides interactive examples of intersubject correlation (ISC) analysis using BrainIAK. When participants receive the same stimulus (e.g. an audiovisual movie or spoken story), part of their brain activity is driven by the stimulus and is thus shared across individuals. ISC analysis is a family of simple methods for measuring this shared, stimulus-driven response across subjects ([Hasson et al., 2004](https://doi.org/10.1126/science.1089506); [Nastase et al., 2019](https://doi.org/10.1093/scan/nsz037)). In the following, we compute ISC on an example story-listening dataset, then briefly touch on some extensions of ISC analysis. This notebook accompanies the manuscript \"BrainIAK: The Brain Imaging Analysis Kit\" by Kumar and colleagues (2020)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Annotated bibliography\n", + "1. Hasson, U., Nir, Y., Levy, I., Fuhrmann, G., & Malach, R. (2004). Intersubject synchronization of cortical activity during natural vision. *Science*, *303*(5664), 1634-1640. [`link`](https://doi.org/10.1126/science.1089506) *Original application of ISC analysis to naturalistic movie-watching fMRI data, demonstrating shared stimulus-evoked responses across subjects.*\n", + "\n", + "2. Nastase, S. A., Gazzola, V., Hasson, U., & Keysers, C. (2019). Measuring shared responses across subjects using intersubject correlation. *Social Cognitive and Affective Neuroscience*, *14*(6), 667-685. [`link`](https://doi.org/10.1093/scan/nsz037) *Recent tutorial article that reviews ISC analysis and related methods.*\n", + "\n", + "3. Hasson, U., Yang, E., Vallines, I., Heeger, D. J., & Rubin, N. (2008). A hierarchy of temporal receptive windows in human cortex. *Journal of Neuroscience*, *28*(10), 2539-2550. [`link`](https://doi.org/10.1523/JNEUROSCI.5487-07.2008) *ISC analysis is used to demonstrate that, under naturalistic conditions, high-level brain areas integrate stimulus-related information over long periods of time.*\n", + "\n", + "4. Chen, G., Shin, Y. W., Taylor, P. A., Glen, D. R., Reynolds, R. C., Israel, R. B., & Cox, R. W. (2016). Untangling the relatedness among correlations, part I: nonparametric approaches to inter-subject correlation analysis at the group level. *NeuroImage*, *142*, 248-259. [`link`](https://doi.org/10.1016/j.neuroimage.2016.05.023) *The first in a series of three papers that dissect the statistical assessment of pairwise ISC.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Table of contents\n", + "- [Example fMRI data and atlas](#Example-fMRI-data-and-atlas)\n", + "- [Computing intersubject correlation (ISC)](#Computing-intersubject-correlation-(ISC))\n", + "- [Temporal receptive windows](#Temporal-receptive-windows)\n", + "- [Intersubject network estimation (ISFC)](#Intersubject-network-estimation-(ISFC))\n", + "- [Intersubject pattern correlation (ISPC)](#Intersubject-pattern-correlation-(ISPC))\n", + "- [Summary](#Summary)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import necessary python modules\n", + "from glob import glob\n", + "import numpy as np\n", + "import nibabel as nib\n", + "from nilearn.plotting import (find_xyz_cut_coords,\n", + " plot_connectome,\n", + " plot_stat_map)\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from scipy.stats import pearsonr\n", + "from scipy.spatial.distance import squareform\n", + "from brainiak.isc import isc, isfc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example fMRI data and atlas\n", + "To explore ISC analysis, we use an fMRI dataset collected while participants listened to two versions of a spoken story called \"[It's Not the Fall that Gets You](https://themoth.org/stories/its-not-the-fall-that-gets-you)\" by Andy Christie. Participants either listened to the original version of the story (referred to as the *intact* condition) or a temporally scrambled version of the story (referred to as the *shortscram* condition). These data are available as part of the [Narratives](https://github.com/snastase/narratives) collection ([Nastase et al., 2019](https://openneuro.org/datasets/ds002345)) and were recently published in work by Chien and Honey ([2020](https://doi.org/10.1016/j.neuron.2020.02.013)). Here, we download a pre-packaged subset of the data from Zenodo. These data have been preprocessed using fMRIPrep and confound regression in AFNI. To reduce computational demands, we compute parcel-wise ISCs using a cortical parcellation containing 400 parcels from Schaefer and colleages ([2018](https://doi.org/10.1093/cercor/bhx179))." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File ‘brainiak-aperture-isc-data.tgz’ already there; not retrieving.\n", + "\n" + ] + } + ], + "source": [ + "# Download and extract example data from Zenodo\n", + "!wget -nc https://zenodo.org/record/4300904/files/brainiak-aperture-isc-data.tgz\n", + "!tar --skip-old-files -xzf brainiak-aperture-isc-data.tgz\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Get filenames for example data and atlas\n", + "intact_fns = sorted(glob('brainiak-aperture-isc-data/sub-*_task-notthefallintact_*bold.nii.gz'))\n", + "atlas_fn = 'brainiak-aperture-isc-data/Schaefer2018_400Parcels_17Networks_order_FSLMNI152_3mm.nii.gz'\n", + "\n", + "# Load in the Schaefer 400-parcel atlas\n", + "atlas_nii = nib.load(atlas_fn)\n", + "atlas_img = atlas_nii.get_fdata()\n", + "\n", + "# Load in intact functional data and compute parcel means\n", + "intact_parcels = []\n", + "for intact_fn in intact_fns:\n", + " intact_data = nib.load(intact_fn).get_fdata()\n", + " intact_means = [np.mean(intact_data[atlas_img == parcel, :], axis=0)\n", + " for parcel in np.unique(atlas_img)[1:]]\n", + " intact_parcels.append(np.column_stack(intact_means))\n", + "intact_parcels = np.dstack(intact_parcels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computing intersubject correlation (ISC)\n", + "Next we compute leave-one-out ISCs on data from the *intact* condition for each parcel using BrainIAK's `isc` function. We average ISC values across subjects for visualization. This reveals high ISCs in superior temporal auditory cortex, as well as strong ISCs extending into higher level cortical areas, such as the precuneus and other nodes of the default-mode network. Here, we simply want to visualize ISC rather than perform a statistical test, so we threshold the maps at ISC > .10. BrainIAK provides several nonparametric statistical tests (e.g. `bootstrap_isc`, `phaseshift_isc`); for a more thorough statistical treatment, we refer readers to a series of papers by Chen and colleagues ([2016](https://doi.org/10.1016/j.neuroimage.2016.05.023), [2017](https://doi.org/10.1016/j.neuroimage.2016.08.029), [2020](https://doi.org/10.1016/j.neuroimage.2019.116474))." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute parcel-wise ISC using the leave-one-out approach\n", + "intact_iscs = isc(intact_parcels, pairwise=False,\n", + " summary_statistic='mean')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhsAAADJCAYAAACKTvCwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dd3hUZfbHv9MSElKogVCkirqC2NYCgkgTQVdREEUprh0BV8W2lnVxd+0FRUEFRUWKoKhIE1GU1bX+dHFdXUE6kgQCCZA29ffHcO69c+a+mbmTmcxMcj7PM8/cueW9763zvuc953tsgUAgAEEQBEEQhARhT3YFBEEQBEFo2EhjQxAEQRCEhCKNDUEQBEEQEoo0NgRBEARBSCjS2BAEQRAEIaFIY0MQBEEQhIQijQ1BEARBEBKKNDYEQRAEQUgo0tgQBEEQBCGhSGNDEARBEISEIo0NQRAEQRASijQ2BEEQBEFIKNLYEARBEIQ0ZdmyZRgwYAD69u2LefPmhS3fvHkzRo0ahcGDB2Ps2LEoKyur/0pCGhuCIAiCkJbs2bMHjzzyCJYtW4a1a9di/vz5+OWXX7TlgUAAV111FW666SZ8+OGH6NmzJ5577rmk1NWZlL0KgiAIglAnNmzYgL59+6J58+YAgBEjRmDFihXo0aMHAOCHH35AdnY2zjnnHADAlClTcPDgwaTUVSwbgiAIgpCGFBcXo6CgQPvdpk0b7NmzR/u9detWFBQU4LbbbsO5556Lu+++G9nZ2Zb2UbM/PsMuYtkQBEEQhDTE7/fDZrNpvwOBQMhvn8+Hzz//HG+//TZ69+6NRx99FH/961/x9NNPR72PzBbN8GH/sajaVRS2LKtDWwz+dEFU5UhjQxAEQagTS5YsAQCMHj06yTVpXBQWFuKrr77SfpeUlKBt27ba79atW6NLly7o3bs3AOCiiy7CddddZ3k/7qIi1OzeHTbfYaEFIcMogiAI9cTOnTtx9NFHJ7sacWfx4sVYvHhxsqsRV9q3b49BgwZhyJAhGDp0KPr164fhw4fj3//+d7KrptGvXz/885//RGlpKaqqqrBy5UoMGDBAW37qqadi//79+PHHHwEAa9euRa9evSzvx24D7HaTjy3ytoRYNgRBEATBhCVLlqBFixba79mzZ+Pee+/F8uXLk1grncLCQtx5550YPXo03G43xo4di5NOOgnjxo3DtGnT0Lt3b8yZMwd33HEHKisrUVhYiGeeecbyfhwOwOkwnx8t0tgQBEEQhAh4vV7s3r0bzZo1S3ZVQhg5ciRGjhwZMu/111/Xpk8++WSsWLGiTvsgS4bZ/GiRxoYgCIIgmDB69GjYbDbs378fmZmZGDx4MJ566qlkV6vecToAp0lrwczaoSwjftURBEEQhIYDDaP88MMPGDduHPr06YNWrVolu1r1jk1h2bCJZUMQBEGIlVmzZgEAcnJyAACZmZkhyysrK0O+Sdth4cKF2jqHDx8GEAzHBKDpO2RkZAAAqqurAQAHDhwAANx8881xPor40atXLzzwwAO45ZZb0LNnT3Ts2DHZVapXnE6FZcNCC0IaG4IgCEIY4zcvM53vPCovbN6Hvv0odrQwWTvI1Xmf6T/8R74zAFumA8g9MnvZH7VV7CNftlzfRHPRRRdh0aJFeOCBBzB37txkV6descEWot9hnB8t0tgQBEGoRyorK8PCX9977z0cd9xxSapRMMoCgBZ50a1bN2CztTL8fr9mrTDSrl074LC1smbOnInJkydb26ge+Nvf/oYhQ4Zg/fr1ISGmDR2HwrJhRWdDGhuCUA8sWxbsJXo8HgBBz3bjt98f7O5R78HOBkjJFO3z+UK+ab4RKuv666+P3wEIcaFjx47YbSKOJKQeZtepe/fu2Lp1axJqk1wkGkUQBEGImhkzZgAAsrKyAOiN2pYtWwIAhn/xUsxl2+12rREMQHOkLCwsBDZZK6ugoABvvvkmAKC8vBwAcO2118ZcN6FuOBTRKKKzIQgpwoIFwbwBZG3g384jTzA5z7lcLgDhlg16ibvd7pBvWo/KMy57/vnnAejWFG4FoW2nTp0a6+EJgtAIEMuGIAiCEJH58+cDADp37gxAH76jiBGnlbACBbyBnJsb9PzkkSzR0K5dO61xnJ+fD0A/hiuvvLIu1RRiwOkA/KKzUb9IwqGGRbyu58svB73nyQJB4X1NmzYFoL/M6QVKFgweDug4Ypek9chiQeVSqCFZL6gco6c4LauoqAj5rqmpAaD/KdA+X3nllVr3yf1JbrjhhijPipCqjGz3jTZdtfTbuJTZ2rMP4ypWAwBcZ/QAsCW4oAII9yyqnT57TaJRgo8S/Ms+ApCaESsNFZvNPA+KSYCKkoQ2Nnbu3ImBAwdi0yaLA3YpDCUbakiNjfbt2+PYY4+F3W6HzWZDVVUVcnNz8dBDD2nZAhsqDfF6CsKzzz4LAFoGUPqmBmZD4MknnwQA3HrrrUmuScPH6QQCorMhxINUTziUClRNv8B0fubZPTCxW3B69o/BCcqfQN/0kifrAP3mPhrcukC/uY8GWUDI0c9oBieLBJmvad2qqqqQ+WR1oTrQdsN979R6HvzvXqNcZr9wTq3bCoKQfojPhpAQUjXhkCAItTNnTrCxV1hYCCDU8bhfxmrTbbJGnaJNx2tIhWPr0t58wW9FMZf5p27/BRBs/D63ozemTJkSc1lC7didNjhc4S0Lu1NEvUIgkyJJ71JvkL6pl0k9Oxrbpt7k5ZdfHvO+yalJFY1A0G/a56RJk2LeZyxIwiFz6Pp5vV6MiWJ9bnFo0qQJgHArA1kozFT5jMv5fUKRJQRZJegbQEj4IaDfUwRZNOh54FYVlCkOLgpmzZql7T8VRZkEQbCOzW6DzcRpw2yeikbR2BAiIwmHBCF9oRDrLl26ANA7UCHOwg3HXSOMpk2balada65RD/MJsWF32mE3tWxEP47SIBsbFBlAPbf27YMmPJfLheHVb+krutk3xwksd10UU8jVa6+9Ftym9RfRV9yAf9Uk2Hr+znSZrWPieoyNPeHQokWLcOEvb2i/L4lim5pPftGmx+PIdDHw8ak3apYMFdw3g+AWD7JokNVNZSkxlkV+HGT1oHBHsrbQciqDW0Ri4fp2uhne6Nvx/M4TtTrWt9WusXFO5WKg8siPVkGxLmRHt61xSAVH7hcAONz7viOzvKiBLrTV7r3bLdev8vg/AwAOHToEHAWUlpYCAH636cnIGxs9Eg1Wv/H2dcCRR8A772N99Yn6syzETjwsGxbcO4TGwkUXXYQTTzwRDzzwQLKrIghCLSxevBiLFy9Ghw4d0KFDh4T5WdntdtjtdgQCAVOJ/FjKcrlccLlcyMjISFiUDA2hC3XD7rTD4Qr/pJRloz6SDpElo6CgAAC0/VGPjh4Om80G7LRWdqtWrbQe34IFC1BcXIw2bdoo1yfNAnLMSgQLFy7E3r17ASRO/bGxJRwi61U88Xq9ypwm3OJBFg5uqSCLBmll0G8STOJCSqp5gG4toX1EsrrEk2bNmmnRMDNnzgQAsXQIQppgs5tbMWypEo0iSYfSA0k4JAjpBflo0BAxDRmHKYFWVurT0XSADEMnRrgDO3c6tkKTH/4W/EZwSIXqvuOk+wEEG6Edvn1A30Al5hBF3OWNuV/AOy84lC1DKrFjdzoQcIV3TuwWJETT2mdj6dKlAIJ/jIAua8uTDHX57m8x7+OUjx4J+b2kqgS+bSVYsmRJiAzv/v37AQTH0i9r/s+Y96fy0zBy2VmloBEw/7qbtfn2QTNi3m9jYdWqVQCAsrIyXLRpAXzbgj4Wl2ypibnMzLN7mM6vLq7W/CS4loVX8VIn6OVOiqEHDx4EoN/TdO+RtcJo2uYRTzyzLLe22O12nGGm2BhHxlS8r//QA2cwzz4IzzzzDAD9j1IsHYKQWtgcNtgcJpYNk3kq0rqxIQiC0Jh44YUXAEBz3KZGZ1j4cpyh4btDhw6FfNcVp9OpDTlTY7i6ujouZXMo4+3NN98cYU2BY3fYETDxz7A7UshnI57Mnj0bgC6927p1awD6+DWZ4+jmjUdyIRWVlZXaODqgP+xkVUkGr7zyipZYSQRuQnn//WDPml6SXK8iEVRVVWl+CtyPgkeXcIsFvXgPHDgAQLdwkMor1+Ew/smQJYNe2lQHvpyrkSaDwsJC7RgpwoEsHZKNtnaG+d4B9kZYqdJw7S0OR1Se9Bf9R41u+eu+8zltWvkUVVaplkTFll5/1ixvR//yRJ3KIm7K/woA4J13hQypWEQsG4IgCI2A559/HgA07Ru73Q7UPVK5Vux2u9aYpUYxdWbiRSAQCOsUUuPY2JkTkovdaQPMLBsNTUF07ty5uKrdt7iuE83ZGPyqBHCsHumyyT0cQHAsuvBf91rah/unUm0647iW2nRm79DIE/tH24Lfdrv2AAK6lSUnJwe+LQdM9+Ho0Fz/cZS5fG/gYLk2bcvLN1/nF/PEdmP+t1ibrrxrhTad/bC5THFj4P3338dw3zsYTjOMPnK922jX03ida/5dbFqWyjdDhd/v13wtzJQ+Ad3KQPcSz+pKvX2yPnBfDTNFWl4WWT1IX4P7efh8PthOOdn0GALf/l/0B8zJaapNOro3NV3l3M2GKCDDqfFsPoDK24P38MudgjlpRJFUEJKDza6wbIiCqCAIQvpDPhqkDEpS83a7HTDv0yQELptPuHoGO022pptCfkeLz+cLE5+jfZEV5dPcsQCCVp3fbX3GYs3N8c67QpuWIZXI2F12wExB1GSeipRubJD8LFkNIkFjvx6PB4UJq1UQp9MZElFAL4FE6mvEynvvvaeFt954441Jrk39QD4alZWVQGaElRNEdna25iNCokUkukQvWLI28MgRsmzQ/Ly8PADhWV5VuVUA3RrCo7SS6aMRC/RMkT6HWDgEoX6x2eywmfj22CwIbaR0Y0MQBKExQg2rrl27AtAdg0Nk6hNs2fD7/dpQG1kdcnJy4rpfo8WEJy2kBrVKpE6oP+wuG2wmVgybK02HUWbOnIk/7tLj8cfSxGYAZ3c13+hn3X/htGYlwYlDADqY2zYCu/Zo07tO+yuAYG8z4yc974ktI/JpGZO9Thv/95VUANHoXxn8NHyf/0ebdvTpaV5Xg/8Gikqi2IE5Q75/SZuumr5Sm866f3nMZaYinpe1OwbnGhdkWrM2cT+dWLn0DGP67Mihguu3nKC9fOnFS988woq/gI2/aZqXwRV16VtlIgeg9OUwEuLXkWPum6HC0d38XBvnX7Z6cciyytvD79vsx9ZY2m86Mcz3DhDr45+XG9e6pCr2lub3nb80spOpDKlExu60I2DW2EgluXJBEATBGiHKoOURVk4g1CClobd4DxMbk/9RY5hbOGhIMZIQnpA4bHYb0BASsc2ZMwdz5swJy6GSaKqrq1FdXd1ob+JXX3012VUQDDidTmRmZiIzMxO5ubnIzc1FixYt0KJFC2RlZSErKwsOh8PU58Lv92sfY3lOp1Pbxmaz1erjkc5QaKggCPHH5rTD5jL5iGVDEAQh/Vi4cCEAPalkffsrhAh5wVw0Lp643e6wcG76TU7Vp27U0zAYpUUc7fLiUgd7c12I8YUXXsD1118fl3IbFA578GM2P0qS1tioefxibXocTZQlXKcGNoMvR/eND2nT+298WbvJDxwJuaqqqkKX/zyEumBvpodCROOnUZ9cun0pqqYH88uku//Gm2++iZHJrgTD9+nXpvMd/X+vTb/9TQcApIJbFSY/TS9c7mfB/S2MibFomrblPhlco8Noyo4Fo19H4H//q1NZZjQZdqw2Xb36Z9N1Jm59F5W3vxs2vyH7cghCfWFz2kxDX20NTdRLEAShIfPSS0En7sLCUMf2ROUJUcEtGDxpX7yHnN1ut9bopeFB8tkgOYH6pHPnzvW+z7RA4bNhOk9BUhobzz77LK5Lxo5rweFwaA8W9QzjLc2bytCYd7pm3KwtoiKVIWlmbo0gCwc3MdM3RaXQy9+YGIv+oEhXg17ePJKF/kDqki5cSAznuN/Sf6hymij++HefeJ+mHnt00YuRd5amz47vt4PadDRDKsbhEhWD9rwG77zXAKRPZMqyZcswY8YMeDweXHvttZg4cWLI8lWrVuGJJ56Az+dD79698eijj2rvmWixOc1Fvaz4bKSEg6ggCEJjhhyCA4FAnf0jmjZtiubNm6N58+aRV1ZA9aAPOR8nwneD78vlcsHlciEnJ0dLrimYs2fPHjzyyCNYtmwZ1q5di/nz5+OXX37RlldWVuLee+/FwoUL8fHHH6OmpgZvvvmm9R2Rz4bZJ0qSYtno1KkTfJ9XJmPXIRj9N1wuV9g4eG0mQ1+pXn+jX0a0GP03Np91v5YFtKdD4TvRtkCfNmhuVK+Nzxj5VftWAQCqpq9KK/+Nl19+GYCe+dcM47Uy4mhpLYzPv8M8Z4pVvB98oU2PMcy3N8sEqJNZxb6PsNR/HgDdwkHWCWMWW7Jg8JBBnoactq2pqcEb6/O032QRyc/Px9Djf7V0bLZjjtGmE+G/4ehgfp19u8x1TGbNmtVoVHOFxseGDRvQt29frWE5YsQIrFixAj16BPM4ZWdn44svvoDL5UJVVRX27dunKQpbwmku6gXx2RAEQUh9KCVDXl4eRuWut7Ttp7ljtZ4/ZYNt3rw5HNA1K8p63QMgOCTcYesM03J+aXOtFv1CufB4x8ss4Z8lOrQznU3DhFaX1UbpGX8HEGyAF3xwu6VtjUMt/nev0edfOCemuiSa4uJi7doBQJs2bfD999+HrONyufDRRx9hypQpKCwsxNlnn219Rw5b8GM2P0rqtbExf34ww2MqOuH4/f6wCADq4SWa3Nxc3RGspvZ164PFixdjzJgxkVdMIq+88goAvffeUPUjOHRP1na8dP+Swx3/g+CWDXqpU7ZY+qaMtelMVlYWZs2aBaDx5AUSGg9+vz/kXRAIBEzfDQMHDsSPP/6Ihx56CHfffTeee+45S/tR+WyYpZ1XIT4bgiAISSIvL0/7WCUnJ0cTgbPb7aaaHF6vF16vt1YnYKNYHPfR8Pl88Pl8cLvdcLvdWkM0XtDwtXGfRKwidHQu0tVp3AqFhYUoKdGH1UtKStC2bVvt94EDB/DJJ59ovy+++GL89NNP1ndkt6s/UZJwy0blXcO06dGtjoyRF8VPT8N/wDBWa5i2d+kQcdu9Xf8ULMPvByortR4e9R4DgUDYeH/AE3vNt579V238nLJ/NmnSBNnQe5sbD48AAJSXl6Nfq3/qG5fs06cNF7jJucdp09VrYriJTPjD/+ajanrQCpVq/hvz58/H2F5bMCEsZUcJfN9aK8tXWqldT+N1Nh2brCOB6sj3jb/M/EXuOLGbNn0+vopYzieHBwHQfTQivbC5iZz+mKqrq/HuN+20e/aSMywm6GjVUp/eV2ptWwOe/+yOuI7Kl+Pycj3XUs2Mddp05s1LY65PqnDy3pe16V35d1nbuLoOjQbjdSWODNtoy7Kjswrn79OHJyoLzS1Pv579AIBgxNWJ//eE6Tr7z/yHFnUFQ4OoaPAj2v171L//FlWd0ol+/frhySefRGlpKbKzs7Fy5Uo8+uij2vJAIIApU6Zg1apVaN++Pd5//338/ve/r6VEc+Jh2RCfDUEQhHrm9ddfB6DrauTl5QGxt8fChtfMGo4qmjZtGtYg5TIAtH11dTUQrpafEKixTA7P5IdihjGKh4YPeRh5XZg/fz6uvPLKyCvWM4WFhbjzzjsxevRouN1ujB07FieddBLGjRuHadOmaaGuEyZMAAD06NEDDz/8sPUdOaDw2Yi+iEbd2KBYdHqgeIbNeCcdCgQC2jg5fXOJXnqwGoMJ0AoxhWs1Uvg9RC9hlaWDftNLmr7pntQjXWLPPJxqvPTSS7j22muTXQ1BqDMjR47EyJGh+snUmAWAYcOGYdiwYXwzS9icDsBl0rJwRt/aqLWxMWrUKMuV4vi2bNGmjebpgMfan6n9y9/MF3gV5ukmP0YsszpjY7Au7GVsfCk79m0K2ea/e4JCX2Pm6h6/tihjjatybtH+AOgPgV7sVAd6sbvdbszMMDjouT2IhP+AIpzYgsobx7Gx7vdAPKBxyUAggGVNq0zXCRyyHk5tej0T4Gwa8MeuT2DL+SXySgbK/V/UulzVi+VwafQXFOddiSEcN2TaIoGK+IuOFdl/w5o1oVLmY8aMwejRo+O+LzNoGHWg5+3gjBisGvt/P11X3TzyPuEh0YTD4VAOnWRkZCgl7EMsGgg6D9s6tgov5IjVwdYyuCxQFTm1O4f2Te9friham9+J0b+Dv1tp/qEBT2jH0Opff7ZUt7G56+F/d32wfikamZJQ0i0axWoDw4g3r0uYZK7P50OeV9EIUeBrepRWjv9IOX6/H9lFW8w3yFGb7jSi/CPJ3LMp4jrewmDmW5vNFlUDw4i9uW6JqcoMhpr5fD5kl26zVE4q0jrX+KI0tKYVeT0Ch/VzZ4vmGsaLDP2RClTH/gdbF/LtB6Jar9xfu+gTVy0tqwzeXzyapVVeFI0BlQk8ikaIramudhivhkdb/wH4dwXPk73D8XEpUxAaKgn32Vi6tO5OVEYH0ZAetvEPOoqed+Wtc1FREWwtl5eXAwAqKirw+63mqaVVDqIHj7tTkyEvKysDEGy1H/eauYNVxokFIb+pB7z46hO1edE6FLo37o24zs5rngIAFBUVoZ//najKNWNTuxsABIeKjl1+f8zlZN2fGo50/q1PmS84qDsF+77Vk3S5v9dN/vwaGqnL9TTDXtBMr8+OOgzCGzA6iMaTTysGAwhvVNA3t3hwATF6Hi/6/R7T8gOl+0znh2DRcTQaZ1Gr1Kez6MyZMwEAx5D4WR1SjRh9GLi1iofxRxoS5lYsusYkp09DzonM1cLrQMdAda9taJmsGGZwB+j6zqTbIEj13CjPP/88JsapLLMwqFhyOtTU1GgPDD1I9J0KhJgA6+C2QUmM6vpgvfrqqwCgORjVN+SrMcq6A7UQAdXLW9X4oBc6d9wDzBsbQnzw/KxQru0Te5nlpz0IoPY/aSN9O2+MfWdxxP3Lfm06o0cLS9vmrfmT/iOrHq2dDQCby27us2GhY9aoHUQFQRCSgaZXUYfIjpqaGq0hSFYOJ/PdoPm8oxapkWH0HasvuOWB6kzWmdpSEhiPh6eboGOo/xyyDQibQlPDliKNjRYtWgC7FGYWi06LxkgOo3nXfmaY4EKtVFZWhjg7mVatlR4j7mU5FwI1vrD5ri4xaM0rKJwdzLpaCODbS/+mmS+tDqmQ6dHpdCKzV2ttfs0PkYdyjFy6PWhirpq+tF41NxYtWoRLT98T2aKRp7+AHKccq01nGaar5n5quqm9VZbp9bRK5umdTOc7jjLRI0D8hldigrQIAAzAR6bzN+zvByDc/Gy0dPRvrp/TQF0Op4XBb2S/7muSiOESFTUzdCfohqC/IQhxx+kwjzyJVzSKIAiCED+ot71v3xF/ljaxl5X/hi6CVX5FUJKdR9QZLR4VfR7S1qeunioSiUelRMO+gxmYuzpohfjj2epolM+LzwSgd4goMiefhWprdTVEmfgfeEtbToPfdrs9RAqbzvGhQ4fQ4V+x+6sJBuw2c8uGBaNBQj1l6CaKBzabTZOzpU8sIYpGCV76pKrDUG5uriYjbBWn0wmn06mr6qUZqXpNGgN0z1Gqb7qXSAY6EWnGU4UFCxYkuwqCkHo4nIDT5OOI3l4hlg1BEIQE8+yzzwLQlT7j7QtBw63ks0F+DgSPMDIbGjMu5+tFgyo/C4eGr6kTReeC75trf9Bvbr3h4nVU/qFDsQ+N1gZFFE2ePDkh5ackqjwoyc6NUvnn8wAA/eNYpt1uDxOsibb3W5QZzGAafCB1349T33rQdH3/Pj06xei/UVcyTmgdeSUDeXl52oPz2cGLAQQFbk45HLn3ZTSDHuj/mHbummGa6fqebeXm5RzSX4ovvvgirrvuuugPIAYoxDWm6BOD/4YxJNZIPK9nInG0NRxLURyVOzsfpU8rrF598tdHLideArfGZ9jov4H689kwQn/aieSaVrroWsCwO++O2LPsFi67TZuumPBSzOUY6ZKxGl06xrbtvA0tNYfOnJwcAMYoprhULyr85YocMKr5Bhz9e5vOn9Qj+G7x//QQ7MfdHXPd0gqHw/zCWbC6i2VDEAQhwbRsGXQWzsvLA+KbODUMj8ejjELhFgvVEG0sQ2U2m80QDq3L3XMLBEW60Df5WHCLBq8Lz32iqrMVPxMhSlJdZyOeOByOsLAuZ5RNZNLRIBGiRJnX4k1mZiaaNw/29swicWqDLCIeptBYFy+a2kLPBKEhQH98giAYcDoAn8n/rUSjCIIgJJ8XXngBAHD00cE0BDk5OcBO83WdR+WZzrc6vBJNh0TlXG/0k9hcNQR79gQF26jzQtYKcjynfR2oWBqy3LgOdQrJN4OHVEfbkYq0nOtyNG3aFPZ884yvxuEV1XBJNDz//POYNGlSzNunCzbYFZoaKaKzUVfsubqTk81m00yD9O1wOLCx/JygngeADr63tPUPt7waBw8GH9KK/UHVuYMHD+LkJX+tl7rHC1ICpQezpqYGm3Ju0Oa32/SE6XZ07PQgR7ICuTpH1grJsiXG3yGw45n4F5oXfyuMUa8kBMU4v/+wuROgrYl5b8DeLPYsw78ee7s2TS9bLo7Ef6v+cIzpyY86NN98h9H4S9Uhc7Grf0/T+Z5P/xNzmdFwVc2HqJnxIQDR3BAEDacT8JtZNiQaRRAEIemQrwZ1DigaJZGYdSy43wNHpTBKHTuea4UsGDyqxrhvY6cQCG3EAnpHiEeTRKoboYqUof3Wx7mmYe4GT2Py2QB0s1xeXqi5kR5kGKyNXq9XM/2RYiglcEsXampqwo45WksFWTbogXSpsm5agIfTCamDUU9FFd7IHfB4CCH3hXK5XEB6uDelPKe11SNQrNp7jMMrqiGV3Rc+BiD83djY2TvgEa1xY/w/ON75flzKH3PiNvh/CoqlNejIFIlGEQRBSF30P//EhvKS8zbvVHBrgUpfg0MNTlL55J0c7ofBtwPCVUx5HXijWKWzweerolY4qv2KE3AMpKrOhtHXoi6EOHL9SYEAACAASURBVPH8fbSWs6jZXYsAhIdCHWrxRwBHWrBer/YgUDSKz+eDLbMOmY+i5Ieet4WFc/FwLVpO0SJkfaEeaps2bYCKCs2awB9yepArf/9gSDlFRUUAgIq9e7X55xx8Iy7HFYuSaSTmzZuHCQP13zbDPgJxCmHbcu1TmlWLIpGysrJw+qfm/i5K34w4sfWMv4RpD3BUL1i6b+iePnz4cPB7yxZtW1pG9wQPBaTrSPcaWQbpj5Hq1qRJE5S0vkZbn/9BUfkFe+eYH2gdfDZSgVdeeQUAcNVVVyW5JoKQZBwOICCWDUEQhJRixowZAICTTw4mivR/833MZamGToxO3ZGGVa3qZnAlUmrkqpyNCeNvbtlQqZVaTTsRyfLB98M7ahkZGfB9+G/TsusSmdKgaWw+GwTdNNwMx7/pAeFWg0Rz+PDhMCco3oPlUrxURzom+s0fcr49QfvhFpV45rFIRL6SYK86duXEaLDZbFpvnd8TySA/Pz/s+qssGfz+IMsM+eTQN1k4AF1Phmc33rBhQ631GjBgAADd6a1du3YAgMLCQgDQor7oD6ih+/CIuV0QjuB0wrS5INEogiAIyYOGnrioXqKoq9WAd0qoY0HzqfMUS4eDzoUq3woXa1R1kFQNcr6+qhNK9WjojeSEYFNkfbVglUpIYyPjVD3/gvubHRHXsQqpGvCbjG4mbuIji0ZWVhb+M/pBzemJbnKv14uur94GM74f8ueQMe/DG/4Kj8eDgCFnyJuO4VqIWyAQACoqtF4lbUuhYjx0jL8kVOPj/OGncvn6VC715N1ud1wjCsg8fPPNN9epHNLWGHW6ep14+W/8rulabfo7XzBjj9frxWd9bkb5+n8Eyz8Un8RYRm2NVc3GoEOHDgB064DD4YAN6hcqXVf6k6KXPP2me5YyKnOLDYCwKCyyepDF4sCBAwDCLR3r1683rdOgQYMAAEcdFXxmu3XrBgBo1apVsLx2wVTnXJa6rKwMAFBcXIwzsj4wLdsqIfobBudEzxe/xKV8I+Mr1wAAamasqbPmhv3UEyOuU9r0irA/yNo0Upp/qmur5H18qzZ9eNDTdaprY6Bo+GNhcukq3yZ65njiOLq/f/75ZwDAuOMSXOlkYnea+2zYxbIhCIKQNOiPiRp20eD1esME2Yh4DoealauygNAfMf3Bcv8HjrEc3lDiuVH4clXd+O9IFg2+f9OQbugdM5XOB7e0cKVT3iBs0DgcAEycQRuLgyhddH4z02+yYNB8urloPs8ia0aLFi205W63Gw6Hw3R9fgPSjU0habRPqgMPy+LjwxQhoLJ80Pr8mEnIhqdbjgc1NTUJ8duoT+hlThaBRGKz2bQID26ZMq4D6Pcg9ZZKS0sBhFs0+AvTLLyQLHlkyeB+H1R2fn7QwfD992vXHFi3bl3I78GDBwPQJbi7d+8eUh7VMUTQak+tuxAEIZWx2czlypM9jCIIgtCYad++PQB9uAvYFXGbgwcPap0S6jSohoZrs3QEAoGwTgHvvat8PIxlAHojOJKju+q32TzeQeLrRVISjWRJUA09qSJoeEeRW3O4TAEPO4+HYGKqM2NBiakoZn5+Pv70p+jKSHhjoy6+GUZKet2j9fYDivh9uhno5qH16WbgvUKjWax06pywsTuv1wsEAiEPXCAQgN/vx7r+k7WTf8VZ+wDsM63TtyV9AAR7m8fnfWS6zk+HB2svFW754FEm9MBwpyv6zV9S8YzA8fl8ddLasJoDxaqfxtclfcIy03JJZJsteL7IwkEvnnX9JwMI3jMDyhX5QBQY9WCMOJ1ObT+RBInoxfXDDz8AABYvXhyyfODAgVqZgH6f8G/jNP1xkRWH5rdt2xaA/nxccsklAIC33tJzC9XGhx9+GPJN2/fq1QuA/kdL93B2djYOd7tVu4ebba9DLhy3uW+N64wepvPj5csxY8aMOvspCUJjRiwbgiAIcWL27NkAgN69g3oNFC4cDYcPH9Ya8zxygvfqrfoJRJKoV4nH8Q4Y99VQKZSaLeP7VkWNqKJWIh17JGsNrxe33tAwI31z52wakqb51FinRvycOUFxu2uuucZ0v42dtGlsGHtuHJ6qmPs3cDMXV+3kNxc3oxkdmsi64fF4avX1IMiyUJuprbKyMswSQQ8kPyb65uWpjjmePhaZmZkpHTbmcrnC7gWud8Kh8xZP3xbCbreHvdBUkB8Ft2gQdE+SlYLM82TJMpOJpm+6v7n/B11Lipi56KKLAADvvPNOFEenQxYRss6cdNJJAPSoFdpPOpub6+qg+XPlUAD6dSbH0fNP0JVfT2ppiA5y69/7c640LfPgOU9q0yqfoPqkubMc5xd+BQB4f89pSauHkJqkTWNDEAQh1aHGoGrolg+DAVsQCbfbrfRv4MOpvNERKXJCtR41vrmvBg+1rw2VngZXJeVDxXSuIlkmrGqIqCwadKyVlUFRBRLOo29qpNM1I2sVdQxpO3KIFsyJW2Oj5LI+ltZv/cgYS+vbbDaleYw78BB0c3MzHa3HlRa54iLth8a+mzRpAofDAb/fj5GnRnb4AqD00zDi8XjCrCn0QKoURiOZJOkYvF4v0KFdVHWNRE5NTphPRL1hUPz8Hy4Ke0HZbDY4HOFOXDxRFMF9OYzKotX/Nk+alXF8K4tVrtaug6rnSb+pp3v66UHhkS+//BKArnFBJluyaNB1oPvE6EtjpslgPFb+R0Ivd/LlOO+88wAAq1atsnS8a9asCflNdevUqVPI78qjp2nH3nSzeX6aeOHqbu2ahdCurTZp+7QRhDcKQgIRy4YgCEKcoc4BNXq5wCD1gr/d2xdAcHhl6LE/m5ZVVVWltFhQh4oP16o6ZqrIEN5ZoYYol6bn36rhx/MzPwCof7AH2NhG92PgTuaqVAsqol0ebSoAPuRKjv/cYkGh5NTw51E1tQ31C2nU2AgEAsqbhXqzlCeCHnTSOODaFPSA0IuAvmk+rU/bG7UrEiHg4vP5wlI20zGQ9YW+W7cOZiRVvVS41UbVs4+FzMxM7VwkE6P/Ax0/HSe3StELgDu2cQVWepGUlJTErZ6HDx9GcXExAF1BlNeD7llaj6xoZF3gliz6U+FRS0YzuyrskctC077pXFDZerhmbJCFg8zN9LKmcq2Y4gVBaBikTWNDEAQh1aEePzXkuH8ADX9Rw44k34MNRHPLRklJSVivmRrX1HCjhh3vYHEiqXJysUCuaBopz4kKr9cbJg/OLQvUUeCWA5WfiSr6hHdCuWAiF4FUWVbatGkDQD+31LDn6QDItyOZyR3TgbRpbBgfEm4eo5uEzF80/s3zktADyqNOCHLuopudXgi0XlVVlaazEaglesGW1VSvd1WFPl9hZqupqQlzxKIHiG7kffv2hRwLqTXyB9JYV7NjrAun4F2gkH79wfL2tqOm4qOPgj4s1Nt1OBz4nWO5pXKM639dEdSf4L4RdO14L1plgjVGA6047Rrtz8KYP2cCIvvfGKmsrMTOnTsB6JYmurfoRbhnz56Q+tM9SNeP7gtuwuUOh0ZrRiTRIq42Sy9JOge0j/PPPx9AZIVRFXQMZI6me5aw2+2oPuYO7ff+/fsBANu2bUMf18qY9hlGK0Po6b791rb9rUib9Pvza1kxsZze0UJ6+hqgNHNU4ioDoPvGh7RpW+dgJFNzZzng9QL7y0y3Obl0njb9WbY1f710gfz4Ajuege2oqUmuTSjLli3DjBkz4PF4cO2112LixIn1Xoe0aWwIgiCkKq+++ioAoEuXLgD0Bh41tFS9eWrwtW3bFohTgliv16s1HK1qVVBHjNebR7/UBZ5kkA8h8w5UJL8Tvpwa7hSKTcfAE6rRdjxhITW2qYFP21GHgToi1BGkc4X2eh1mzZqFG2+8UXkO6pM9e/bgkUcewapVq5CZmYk//OEP6NOnD3r0MBfCSxRp09jw+/1KkRgeTkbz6SbgNyd3puIhWTSfRzZUVVXB7/dHpa9hBWO+Fe5wRTc4H7uPlEo6JLolBeQNZs6cCQA44YQTAEQnuxwNdL7omqlEkFSmVR7tQ1A59EKpqKgAWlurW0VFRZilieuncEc/euHRi5deeGRujyQvbZyOlLCKRzTRuSG/EXrpUi4UUgyNxDnnnAMAaNcuGAVFQwcqzReesTjd8+8IQiqxYcMG9O3bV3uXjBgxAitWrJDGhiAIQrpBzq98mIs6CzS0y53TycciniHlRpkAIlLKeoIax1RvqicdTzyE2VTRIlx3g1tnIimH0nrUySRnbzrn1IimY+AdAZpP11IL1T5SHiVJpGtJHRSzlBBWlGMTTXFxMQoKCrTfbdq0wfffWxiaixNJa2zsvdNcKdGq/kai6Zq5BiBXi+Ze5GUeQl4msODLQu2BBPQMmC1atMAJWGtemF0/3Z9tC/bw4+lT0Rg5q/VnpvNtTZuazuc0ywpewxEGJcelXxaarvvU3hPx2Wfm++NQ715IYww6G4hPipVa2YGLtD8u4zBMF+cHid+5EBMqvaXRbb+C/5Ogmqr97MRqyUTC7/eHNNQSFVUZibS0bPChA2qxktmWzEXcRM3NxqohiWgaAG63O2Q8lFq/0YYNUggrH8PlcPlxOjbeOieMya+A5MoXG+E6Abz3kkrU1NRowyc0PkvXqW/foC5CpEbHxx9/bDqfRLr4PcmdN+lPh+4TukepgUvLaTvjeVTl0eA9QLp3aOiGKyRSb5uu2dChQ0PW5/ume59SztM39d4jZQwNEdXLRkohYbpCulJYWIivvvpK+11SUqIJ+NUnadnYEARBSCW4/gkNp1CjkhrX1CmhBhv31SKHUdo+NzdXz5MSJS6XS9nQVGUfVoWykh8PNRTjkRuJd/JonzxKkMuW8zqrhoII3iCnhrox1xWgR4BRw546anzIizuw0napTr9+/fDkk0+itLQU2dnZWLlyJR599NF6r0faNDaM45D0za0BXOiIy5QTkbTyo7EGNG3aNCSUj14ilZWVQBTDr7QPnhKePzjcCmMMxTQeG21Py6k3mZGRARyIXJ9Ew7NIhlhkUsCB1UhZWZn2QqIXFp1X6hFQ8jIav/3gg+hM3evWrQv5ffbZZwPQ7wOeiI/uaS7AVduLVnUvccsdf3mSJYP+6MjSQM8Tzde8749AzwFZFukc0UtblVeD9kt/vCFhwilm2fjTn/4U1Xq/+/Vp0/mft5wY8773ZVyiXbvWnrdjLicaun7/9+A3X1B15Ns8sjWI0wm0OGLZVYTApisnttwAREh9Eti6vX4qY5HCwkLceeedGD16NNxuN8aOHaslS6xPktbYaHX3MNP5gbJy8w0S0Ihs61tmvoDe0VwWw+4E4mROPSbHXLNhdwz6FXFHIdTj/uS/2nST39dXZWonWt8MU4zX0258FKITKhLqTpOtT4Hc61o5jvhAtQaQo7iuhyvM56uwqq1hYMkvxwEAxoyJ7EcWaTiQBKJUGaa5Jgn1wmloimuU1IZZNI8qN4+q41af0L6pgc+joqKJwAL0Y+RWJd645jmBePI8nu2b59xKR0aOHImRI0cmtQ5pY9mw2+1hsd78QeEKcHxsmh5ounna1EGV2eFwhHhm08uhrKwMaBN7uQQfy1fFy/OXCH9AUiWMcOrUoMjNypVBsaaQZGDhztxJh3rn9MKi80kvf/rToBfiwIFBcTESLYsWuofIT4LKo/3Si5CuNzcB84RygNo3ie4RLonPzci8bkbBM0B/mXPTOpVPVhjaD78HjTkoetfdKp8wUsXfSRAaAmnT2BAEQUhF/O9eg4ER1qFhTa4Qyy0ZXGclrMGTfzGAcH8GlW8GwRt8fDtqxP5f55sABDtNA8veMD0WUg2NlbM2v6hNr20/Tmson/7Tc8GZPwHbBkzX96fwPyG4bgyXWFedC35OeEctmmH1VB06SUXSprFhs9nCevd0M1BPinrL3HeDx45rIat1sGyUlZWFWDbopRGv3hBPxMZ9CKiHzRN70Tkg6Xafz4fOcalRfKCXbIiaX/KUoE1p1aqVFvVD512VEI3m059JtJBQ1nHHBU31dD25xYKsCtwxj69nTLhHdeYRLlyun6tYcnEtOkaezI9HUPGEhqWlpSHrc8VI41BC75ORskhYuiDEj7RpbKho/p9/oHmklToEHdeQD9gyY89a+uIKB/aUhgvmcF7/vEAzww/pujFiuYFDup9KO7yuLzh4KHxlGj40WVR29DTT8r+zj9T+cHq7l0Ssj4pv+kzDrl3BuPLLYi4lnI9/O01ruNEfn9PpRO8mq+O4l3Be/ygHvwVTzuDVD4PDF2YCPUL0DGr3VeSVVKj8NKyus21n7HVIEDzJGDXUuHItd1anTgwfViVnXu5grhLMimT54Bmx68uHI5ph3kgh3Co/FN4RI3jnk/to0Dmg5cn0Z2lIpE1jwygTztOK12cdAoEAnE4ncnJyQjIx0o1P+gyaw1iYW3di4f4sYS+POoyR+/3+Op9zMhPzaAvyVeAm0ERSXl6u7Ycc+LhPBJ1PHlFB9SRVQTqOaJOXUeQGWTS4fxHtnzuxRfLDAHQLA//jomPj2i30TdYw+gOLFB6p+m4oxNNno/3n94X8JqOqUT7umy6T4ra/WDlzz5yI6/i+/zVsXuBwVcgyx1ERQjeOMGjnq6bzO6+/X5suH/lsVGXVFz+UDQAQfGd1xazkViaNSJvGhiAIQqrxzDPPYHKn+JTVpEkTrWEXInAGfaiYD6/S8B01Wnkqet5A5FEzvEGaikTS0yBUVhweYk3h6jyzMrds0Hbc2kkdDeogCdGRNo2NiooK5RhzfZGbmwun0wmHw4H8/PyQB5f3MOmGrm/oQaBzRA9OPKxAHo8nTGPBKmQJ4JEOkTI7JgKPx6OZWrmeBn9RcT8gntCNzNq0Xb9+/QAEkyAZGTUqmP6bchXwSCranq4jfXOTMLf8mIktRYpQ4k6G3D+IR+LwyBfuQNfQfBxS+Q9YENKNuDU2ChZ9rk2XXNYnXsXGnUBNlf5j12/apK1bN9P1X1zhMGTgtL6/RV8H8w63bt0agzorkt8oxhat0mzT49p0K74wdleVpPFf3wVh8wKBAHrmm0uBq1jyRVutR0jOixLWmBje/7WX1sC95Hf1kFCEiJOfxsrA+YbhoMgaHfEc7mvWrFlYUjBqRPJhNhryosY/vaMoOzAXh+PwoTGebToVUT2zXAaA4Mqh+/YFHbRoqJsLJdI3bWf0I/um+ExtKDM3N1SXQ4iOtLFs7N+/X+tpkMmwPuRijXoaJANs/BA8SoHfiAcOHEBKhYXEQFVVFW644YY6lXHzzTcDAObNmwcgvGfPIygiCflEQ01NjdIiw19UZBHifgjcEY9eYNzKRsvJcnHWWWcB0P80OnbsCCBcQIhbG1S+K6rwP55oCdDPKb1EyTrDj5lbLrguDVctVeXz4dcuHcnKygrT4xGExs5l110Nn8m712HBAp02jQ1BEIRUY/LkyfC/e01cysrPz9car1xhlL7JQkcNIh45QY1UarRSQ1PVSKcGYjpYNjiqHCk82oQ6GnSsdE7oXNM3wcPOqQNJ6xklF6JzgxWANGpsHDp0SLv49GDUh4NOu3btUFxcDCB409KNVl5eHuKzwUPYyHGLvhvC+C+94OIBOWuRdYrOnyrRU10iHtxut2ZephdRSUkJgHC/A3pJc58NbmKl5fQCIgc++k3WNzpnZLoln5WWLVuGlEf3Enfg4+F93MfFzF+Czi2dU6oL1wbhehvGtOaAbname5hvT/DtuZNiOmG327Vzfu2110a1zcHlmyztI3dwZ/P5q282nW876Xf6Dxf75viALY5LLNUnf92tcZe68f5aEvLb5kq97M7EsXvn6j9U6TIMuH/Qj83fKbK+Tvra+XR8AZepZUPP7RGZhDc28nq3jrySkSbmL6o+TUxSeke+L4IYfDO+yxmrtXgPHgr+QXi9XuAb/SVJ37wBUVfWbO6pvci5HDXF3xt7MANzrUlfNxa+KT5TO088iyb9gdL8hua0mE6s3h5M9sQbbEM7fht7oSmooZFqOBwOrQHIHYtV4czpCA8Dp2Gv/fuDvjbkpK8aDmsIHcD6IgAbAiYNCyt3T9pYNuJFaWlpWGQGRRJQI4PfxNRbPXDgQIiehnFsmit88mgCrm3Ax8Xpm+bHI5VzvKHeezyYPHkyAGDhwoUA1I0EOsdcKZOsW9QgVKlZkgWBco9wsSSuQssVQXkyKK5Sy1/WPCqFtqcXIGU2pfuBEmypok54vh+e3ZfruwBAUVFRyDweocRD/fgfD50LHlHFfTF4enSuncITYaWLqT5d6ikI9YXPD3jNGqbisyEIgpBe1HxfbL5AMb/JVeeYzs/KylI6FvPfDocDtu6dI9YtsHlbxHUQCCDgMbcWqOZbGV6JpCRKjWtq2NfU1KAf3lMXGGFU2Dhc0tjxBwLwmzQ2rAxqN7rGhsvl0qwP3LzGQ6HoJqbeaWVlpZZ9VqV7QJYL3rvj6zVlqdG5o1cqesJfffXVcS+TQlGp102WCvrmkQ88VwlBlgyejZVHB9E3z2VC14tbnMhSwUMEqRy6XrQfXg7Vg0eZcOcz7ufAo3MI7gRHx2u0bJDVhiwTu3fvBqBndeUqt0aJeGPZdKzku0HzVXVV+WpESr+eSrjd7rha8AShIeALBOD1hzc2bBYcUhLS2CDNjWXLluG8n+clYhcaPzQbH2Zi5xkUed6NdGF50elhf5qZmZk4NfBO7IVWR2EiNvjNLC86HQBw4YUXxr5PQTCwcmvvkN+RclsYfTw+bXqZ1njpe9A8K2ljx+12hw23qbK+pnOYMh0DNbhJe4Tm5+bmmuaQEqyjtGxYcNpIqGWjPsY+9+zZExbfTw8a9V5VY8iqFMKqPBj5+flwOp2w2Wxo1qxZSK+TepM89Iz36njUAY9G4GP+VFfqjZaXlwMWfW7rQjwjUMwg341XXnkFgC5KxKWD6Vpx3wY679wSoYoCou2oEUfnnYsicVS+EnTvcAVSrtZJjsDko0H7535CPNpFlUCLXrBkvTD2xnmW1R07dgAAfvst6Ch9yy23hBzb/PnzAeiWj/bt24ccM21H5mmyynH/JH4sXCo7JNNvLceo0hKhbRPp1Hj48GHLFrxmcz7BggULAAAXbXwt4vrK4RKLVL+ii9s1ufAkbbqDIV/H4ePvjljO4W63as9Zy13Pma4TMtTyzf/MC7LZtGER1bAJEN3QyU+n361lXo4i9V4Ip9PQSQ0Ale+bQlE54LXmNOrdrj93TkNkyqft/4iBAwdaKiuV8foD8JhZNiyU0eiGUQRBEOJNXWX8EwV3OFdZkVLNIb1FixaaJVqVG4UasdSobmiJAFMJr998GMWKXSyhjY36iLd3Op1heSsIHtHAe1TcH4DfrFx50el0avPy8/ND1qdenqoXx4Vi+IPDHyi+by5XXF9cdlk8k8mrueqqq6Ja79133wWgWzKoR0/njywaZOEgixC9kFSiR9z3gSwRdN34+lQezefXn19vioahenKFUJX6pkqCmcqnb6PPBpmTCXppkxWJc+WVVwIAZs6cCQDo1CmYWey4444DoGfE/d//gj1arklCVhqussqtP/ybUOXBMbNg+Hy+hFo2yHojCIKOP2A+ZJIywygAsOrYiWHiQQ6HA/hZHe7HnQH5C5/+gHk2vsbCp1VDtXPKs0Py+Ho+hMT/vKgc+oOixgz9YYw7PTHHIAjRsmFfUPKdNzI+yR4DIHzYRTWMw/0UaH1quNJwUywkw6HbOHSigp5rCgGPJHd/sMufAASPp/nq0OE2bd0m4cMgNrstZJmjR7uQ5d4fdX0U4xCLakglKytL6VjMhxTtdjva73oeHU3XNiewL3Kj0nWcrg/q+ak04vrGIRV367onvkwlfAG/qWUjZeTKR44cGfL77bffBsD8D6D/EfKxX7qpqJFBY3jU6+R/oNxiwbNa8vVofyprAY8woUgU4zKCN3y4EqWqN8Z9OLjGh6rXx3u45BRL0R3cL4VehrQdzwRK+6dzn6rOtOSo+sILLwDQG1t0T6iiTri2Cj/f5EtB5nC+nEeR0HXhfgq0H+7LwSNAVNluVdEnxnsQ0K8Pj3YBwhVEoxUvIsvHk08+CUD/EyYLxzHHHAMA2LRpU0hduW8TPzZuOYxk6eConjlVI4N+0375e4ErqJI1I1rFUEFobKSFZUMQBKGhc+ONNwIAKu96N8k1CYU6IdTo5r4bvDNDDdSKigrEkOQ6bthstrA68rpyobtUgs57Q8Hnh6llw5kqlg0O1xag3iRX8OR+DtRT4711smzwng3vlXJ4j4zK4T0hXp6x16mKYOHWEL5cZcHg36ocGbyXyiNqqKdLEQNUD57Rk14q5PNAy/l2qcZLL70EIFxplKeT5hYAOi7eC6drTfcgv9Y8ERa3wnHLFb939u7dC0CP6OCRHirLF097rfLdoHqQX4Wxrj/++CMAPdNutNx6660hv2fNCkY30Dmie4enN6ffZGWib+53FK3vhsqqF8n6x61D3JrHI3nGjRtnup9Y+GrYXQCCUU3dltylzQ/U6NZTW2bk125GTz0qqubbopjr87tDR8KDDwEHekyLuZy64jzeyiBH4rG1a6tNB34zP7/Vn++2VKajecMd1leHvkZv2hDLhiAIQpygoWFqmKUaqsYtb6wfOHAAneq3aiH4fL6wjLXcB4eG+SoqKtDWpIxkQh3khoIqGsVrS9HGBt3I5HvB80Lw3hvPN0K9b+qZUA+Oj9PzcXGjNC8Q3mskVKZFwuFwwG63IxAIhEXa8H1wHw6VfgKPRuDrq6IPeI4Qgnry/Jzw0DYeQUC9POqdUoRCqkBaEDyfB50/bvXiSqxkRqbjpV43tySRBYRfLx5lxHOj0D1JL5ldu3YB0KNnCDqv/N7jUUj8enGrAL8/jM8OOQNyldpYoSECq5B2CllduHVJ5YuhIlLUCrdC0bPB1Xkvv/xyC0chCIIfAdOsr34LqdjEsiEIcPX3cAAAHJBJREFUghAnSkqC+TSaNWsWMj+aoRMVxqiTwK49MZdjHJpVDVnxIScr7HO0wkuH+wIArsfmWKsJINhA5E72BHW0qINUXl6Ooy26bbjX/9d0vqtHC4s11fEd0LOET7h3QszlpCJKy4YFD9F6aWy8/vrrAHSLBvUuyQxGvVEeUcAfAO4PQT0WLupCvULug6HyxeC9fx46R9u53W7NstGkSZMQawS3mqjK4g8z75GrerCqqBIe2krnQtUDJ8sFj7qga0PRLKkGHTe32NB8Ol7uo0HwCAl+L6g0Yfh6fL+UN2T79u0AgHfeqV1KniwsKmVZHkGlMiGrolaMZaksAZw333wTgP4HSdEZ9D1p0qSoyuFw7RTS8SDNEbpGPDdLpEgsgj8T9D6he3vs2LEx1VsQhFDEZ0MQBCGFoPDZpUuXJrkm1qCGHXfet1pGPCNDVI6/vGPm8XiA1AtIaVD4FJYNX6pZNqiXT2PJPB8F75moeptcEZT8Dmi8XNVr5agiSVTmOqMKJfcJILhiJDmIUR15nbivgaqnqjJ38rwUvOfPzx319uhcUS+SK19y82+qQNeCzifPQcJ9ZriyJ8GtaXT+ybGPC8apRNDIhPvzzz8DANasWRPVcdBLnPvqRFK3JSL5FQHhuVFUzJkzBwDQp08fAPrzSRE0dM/QsZHoVax6FCoFU4JHvXC9HbpWPG8O3dORyk8n3P/Zp02rhMSNQyq2nGx9QTPrDYW0J9tcF8i98lvT+SoOnP2Y9my3+/ymOleroeD3Bz9m86NFLBuCIAhxJhV1FszE03hjmhp4sfhs2Gy2uIkBmg1rcl0N7swdD1wuV8pGEiUTnz8Ary/8PPvsKaazwZUFuT8B72VSj4zWpxuYqzNyCwj37VDlmeC9f5UCKe85VVRUaHWtqqoKMRlyiwFX5OS6DDxihku6q3QX+Dnkx8aPiVuLuF8M7Y+Olcp98cUXAQDXXXcdUoHrr78eALBw4UIA4VL3PFqHoPPIrWfcwkHQeeG+NXT+6DzRcsoS269fPwDAhg0bTOtParp0L6s0J7iJOJLFy8zSQX90qp7+s88+C0C/V8hyx6NGaDndM8bMsolAFfUyd+7ckPrwa92QLBqCkIr4/AHTIZOUG0YRBEFoTEyYMAFVf1mS0H2EDJ1EiWoYjhrT1HiPJeFjC08JLgcNJ7apdV2tPiXmDumu3i6lJgh1CEIsEHUwJAU8eoM+Y8aV2rCVVXtJ0yc+iL0SKY7P508PywaPg6ceCR8f5711lV8B7/1ztUd+c/Jx/EhOTDx1MZWbmZmp5UfJyckJeWB5nhU+bs6jU/jDzaMceNQJwa0zKg0R7sPBH1xVAjd+DlINOr9kIaB7iFuG+MuSlpMOBs/iSlEiBJ0frijKI59at24NQL8uKssGrUf74+eXWza4xUPlLGe2nGd95dC9SJaK008PZtuj3EU8WoR8N0aPHl1ruYni6quvTsp+BUEI4g8E4DexYliJRrGSjl4QBEFIUyhs38x3w2azwWazweVyweVyhXX86htj45nX2W63w263IyMjAxkZGcqw9YZOIBDA9OnT0b9/fwwYMABff/216XqPPfYYBgwYgHPOOUdLYGkVr9ev/ERLvdxR1Evk4+z8m/s1ENRL5b147msR6TtS1kku2Uvj+kYfE7JsZGZmhjwA3LJBPWAqi6wzPOqAZ6DlVhz+YlD95j1jgkv+qjJ1EnTMN9xwA1IR8i+gqBR+Pnk+HYIsPfRiIksG11zhOVfo/HAfCrqn6XqRSfeCCy4AACxfvhwAMGjQIADhKb5VmU5VirKqJFQ036gkS970nKeffjqkztOmhebKuPjii023E2Ij66/vawqywza9GnM5xtTlruOjEOYuq92yFS07+k5HUVEwb8hpvz5vaVvV8Eht7B/wGIDwd1I07G5xlWbR6778Hsvbm2HP1xsx/vIa03U2jvorNm8OCpjFL8NOdKxYsQKbNm3C+vXrsXXrVowfPx6ffPJJSEPxX//6Fz777DN8+OGH8Hg8OOecczBo0CB0797d0r4CCp2NSBmbjYjPhiAIQoKgcOFUwO/3hw1h80YsD92nxnd9oEpOyIdGrYq/JZLq6uq4JvKzwrp163DhhRfCbrejW7duaN++Pb755hucccYZ2jpnnnkmlixZAqfTiaKiIni9Xq2jZgWPLwCPiRXD44h+cKReGhuksti5c2cA4RlFyQqg0gWI5NSkijLh/goqzQqeb4R6z4TRp4RMkTabzVRBlCtAcl8B1YOi+s1VErkfiWqMX5VoSZW2mUdbpCqkZjlv3jwAul8BjzwiywNBDxhZNLj+Cb8HuZWN50ahbzpf/LzSA19QUBCyv0i+GARXnuWWKb6e0U+DK3cSVOf6/AMRBCExFBcXa+8XIBhNtmdPuJy9y+XC448/jtmzZ+P8889HYWGh5X35/QqfDYlGEQRBSD5TpkwBACxcGAyR7ty5M07+7LGk1CX/50e16UO/uytkGe+cUAfLishfqbM1XvcGhw3H4xPL9eMdBrNh7aN/mx22HUmYtaMZZ3TVlrm/2GK5HlagXDjJwO/3h/m2qIQsp02bhptuugkTJkzAG2+8YTnRpjIaxWSeinppbEydOhUA8P777wMI90tQeebz3jiP4OC+G/xEc3McL49bDajHxzUnjJoU5Kzk8XhC6s17vlzZkx4YKot6utwSwiNleM+aZ7bkJkZVNAa3ZHCTJfXoST0y1Zk4cSIAPbMot1TQeaB7jWtHEKpIJjo/PIMowa8bXV8eLcNVc4lolECN6/FnhMqj+8usR8Ohc3LrrbdGXFcQhNTjsccewwcfBENsDx06FNLYKSkp0bRyiM2bN6O6uho9e/ZEVlYWhg8fjp9++snyfiUaRRAEIQ24/PLLcfnllyudd+sbn88X0nny+/3w+/3weDwh6qE5OTmaqFsk7HY7mjZtGpYEMVqoLsYOncfjQXl5OcrLy1FWVhZTuYlkzJgx9bq/22+/HWvXrsXatWtxzz33YNmyZfD5fNi6dSu2bNmC3r17h6y/fft23HHHHaipqYHb7caaNWtw2mmnWd6v1xcI+m2wj9eXosMo27ZtA6D3Qnl+EG7B4BEakaJYuK8G77WqrAPcKsAjAoxqkvQg+Hy+kF4p953gmh7UMybfDXqgqe78m/t28GgW8knguUEIHhXDfRi4Lgf1zCdMSK/UyOSfQCqTXK+EnxeuPskVRrnVi/vIcGsZt4rRfPIN4blQuMWJ32OqqBNuOSMoWiAac+7NN98ccR0hNfDtM/er8X2iDws0Obur6TrR0Ox/+lBOde/7Iq5fdM7DAIL3eZd/PhC2PBAIoFlNEUYePpL1ODe6iJLdp0/XI8ui2aCglT5dsk+93hFUUSS2bJfpfBXGyJSPTw0q3Q4fPtxSGfHm/PPPx3fffYfBgwcDAJ544glkZWWhqKgI48aNw9q1azFo0CB8//33OPfcc+FwODB8+HBceOGFlvclPhuCIAhpxPbt25NdhTD8fr/WCKbQd2r0UgeOdxDjhcvl0vbJO1ym2V1TgC1bEusHEi02mw33338/7r///pD5bdu2xdq1a7Xft912G2677bY67UuZGyVVGxuUw+Ctt94CoOdioPFtlRomzyPCLRlclZFuXq4qqcorQXCLCnn4GyMDyCnH5/OFPHh8Hzwaha/H68bzwdA3WTSox86VL2k7spzwc0fnlkyh9MDyl0s0Y/6pDKlMzpw5M2Q+nR86fpXvBH+RkSVIlatGZSGh8ml/dC+p7jVuueAvc55NmO4v8q2h0EryixISy6hRo+q0/e7du7HWH3koxSihrcL+5W/Wdq4Q6vLn/Bxm0VNF8Pn9frj2/xpWxn/3BC22Y+Z+H9wuypBI92vXhVm0uZ8aPZs+nw95TsNQijty48N/QBF5ZUFmm1PkClpU1q9fH9P2S5cujXnfyUIsG4IgCGlE+/bt4duiC17ZXPqfcjQNjKjw+sznKxob9sO6tcWTEQyL5A0AlRN+XfH5fGFDhCrhw1RJodC+fftkV6He8Xj95jobqaYgyqHxZbpo3B+B9865yiPvFVKvnr651YCXFylKhatulpaWauWQRcPj8YT0knk2UJ4PhkRy+MOqyvbJ/Ul4plyes4NbPFTl8CgL2q8q42a6Qdazp556CoBuudm1axcA/XjJLMwz/KqidTgqfRRClQuH+wOp8vxwaDm3aPzxj380XV9IDPHolVbeNUybdrTSBZZUfhoqVD4b/gOHTOfbu3SIWOb2tsEsz/QOpXezcRgl790pYduRRWPx1ScG14vSZ2PzCXdr+6IwW26Fpf+LvXv34uyCz/WNo/DZqF5jHnlh1WfDSNb96WeZqCsBKBREIZYNQRAEwSJ8KJo7TtOwbLwoKysLc3rmDXnesRLqH1UelJTLjcKhXvSaNcF0xFw+lVssuCYB78VzLQRu0VBZRHgkAL+Z6cGilnVlZSVqampgt9uxc+fOEA1/Uh2lOlLdmjdvbloXVf4WQqUJwi0Z3DeE5z5R5Y+h8vbv34+GyC233AJAt3BQ2BxdJwrPI98MshhQFAlde25d46iuj0oOOpKlhO5lqhddV7pOFDrJVW6F9CH74dXatNHKYZVqQ2RKxgmtI67v37pLmzZaOQ70mKb7LFXoudqP/z9dBCxR9Fp6v3KZ9nb949PmKygiU1TWjLrwWZ+btaiPxojfb+6fYaX9J5YNQRCERsyhQ4fC5AdSiWTmPiFItqGx4vf64POE+wL5Vf5BJiS1sbFp0yYAuhYB18fgOU/IksDVE1VaCCqnJj5eznulfP/0AN5www348MMPAQDjx4+v9dhmz54dUtdIlg1CldWV143reVAPnHrE3CpE++VWo0svvbTW40h3yMKh4qOPPgKgWz541AqPXuH3Dp1H0tkgiwZZTlTJpfh1pvXIYvHjjz8CAK655pqIxygIgpBIJBpFEAQhjYnXkIpVSroEBd727t0LHDqkNZp7b3wy4fuu+cpamP1Rc4N1PQqAbeoF5ivl5evTcRpGeatrUB30yiuvRGNv8vt85j4bKZcbRQVFDixZsgQA0K1bNwC6BzT30SBLA1k06AHhFg3ur0Co8oiorAe0XixiMmRtMcaIG+vEj4mI5E/CLRsEt/5wCwbvkaeiuFAyoYRZ7777LoDIoX50PrkeB88qq9IOIFT6GWLREAQhVfD7AvCbSJObzVMhlg1BEIRGBhfMSsW8I8nGambUhozPF4DP1LKRZo2N0aNHA9CzwpL+BvfNoF4iV80kuLVApWXAv1UWDRo/53lFooEUHV9++WUACEtmpLLC8Pk82oH7l6icp7jaKp2z3bt3AxB9BhUq/x2Cv6Tp3iBLBmV5pfOu8tXg15l8PoqLi+N6PEL6UJchFfdGPVuzKjJl00l/1u5PGHL09Pr+cUv7igarQyXxJOum87XpqufeN11HpQPy3Zm3axo2DdubzRqUqM9sfrSkRGNDEARBSCyZmZla45Y6H6kQ6ZFK7Nixo8E7zceCz+OH10Th1mdB9TalGhvnnx9skdK4OVk4qJfILQ9c04IsGzSfC9KolEN5htSDBw8C0MfPybckFsiCMG/ePABAYWFhyHJu2eC6DlzYRlV3gus1kPWHLBpjx46N+VgaA5T9lvyG+L3Ds7zSdejQIahbQJFV/LpyyxT31di3L6gTcO2118b/oARBEOqAV+EgapacTUVKNTYEQRCExESpOJ3OsE6I2+2G45RjtXV83/4cc/lFgWZYnHEk7XpvoF27dgCCDerTVz5sqawmNwzVf7BklrHiaNPUdP6iFn8AAEyYMEGGTlT4gYBZmGu6i3pdeOGFAHR/h06dOgHQtQtUVgDuo8EtINz/gSR5yZJBKo2J8GeYOHFiyO+FCxcCAFq0aAFAV6ykuvFj42P8hMqXg45p586dABpO7pNEM27cOAD69eFRJeSjQQ51ZE0rKCgAEJ4TRWWmpuVkISHLkyAIQqrh9ZoPo6S8XLkgCIJQv9jtdm2omBq5NTU1QJP47cMoo//bb78B0IXuUpUJEyYkuwopT4N3EOUWhpkzZwLQswPS+DjPY0FQb5/G2Wk8nvJLJFPL4PLLLw/5PWvWLAB6LhWy4nDVVFWm28OHDwOQByde0PV54YUXAOjnnywbZBUjvyJ6oXJfGx6Fwu/RoqIiAHLdBDXGIZUFCxYACOq5DPznTNP1o4lMUWEcUrGC7c1fgIPq5U3+OMB8QVGJPt22QJ9WDJ0ENv+q77N7t4j1Mg6dfNrzBgD6u3LPnmDEzKSIpQhpL+olCIIgRI/RwbtS0dhQYbfbwxI58pD8umIcNqQGd25ublz3ESs09ElSC0L0NDq58rpEhaQ64lORmlx//fW1Lif1W5WPBld6pfXIuiZKroIgpDo+T8A0zNXnSaHGxk8//YT77rsPBw8ehMPhwCOPPIITTjgBADBs2DBUV1drreyLL75Y/nSFMF555RW89tprsNls6NSpEx577DG0atUq8oaCIGi43W5tGI+GaV0uF3A4PuU7nU5tSBvQhx6zs7NDh0uMGIdOVOsoiGZIZd0xV2vDJVeLRSNmAgFzy4aVLMEJbWxUVVVh7NixePzxxzFo0CCsWbMGkydPxqefforKykps374dGzdu1BobgsDZuHEjZs+ejbVr1yIvLw/Tp0/Ho48+ikcffTTZVQMQHh2kyuZLFg3ysaGU1dddd12CaygIglA3/B4f/GYp5k3mqai1sXH77bejZcuWuOuuuwAAb731Fu677z7NKc7IPffcgwEDBoTM++STT9CpUycMGjQIADB06FB07NgRAPDdd98hOzsbV1xxBUpLS3HWWWfhrrvuCmkZpyJjxoxJdhXSijfffBNPP/001q5dC5vNhvPOOw+TJ0/Giy++GLau2T10wgkn4J///CdcLheqq6tRVFSk3UPxQK6n0FjYt29fmON5PBVECwoKQhyd58+fD+BIGL65xEXCGT58eHJ23MAIBAKmOhtWLBu2QC1r/+c//8H48ePx1Vdfwel04uKLL8bUqVPD/hBUPP/88/juu++Ql5eH//73v8jLy8O9996LXr164YMPPsDy5csxffp0ZGVlYcqUKSgsLMT06dOjrryQHkyePBm5ublBASGHIyarxOrVqzFt2jRkZmZiyZIl6Nq1awJqap333nsPANC9e3cA4dEoPNsr6Z4MHjy4XuspNC5ef/11AEDbtm0BhEe5HVP2Wlz2Yz/zIQDAqFGjAABLly7VllFjg6IHaejztKrFcdm3kZUVg7RnjNR4Jf9T/Lj8vg9QvL8ybH6bFtlY+OBQky3CqdWy0bNnT3Ts2BHr1q1D165dUVxcDLvdjiFDhoSta9Yr9Xg8+Oijj7BkyRKcfPLJWLNmDcaNG4cvv/wSQ4cOxdCheiWnTJmCa665RhobDZCHH34YQ4YMQZMmTbBq1Sp8+umnePDBB8PWM7uHiGHDhmHYsGF44403cMUVV+Czzz5Tpn8XhMYOidMRc+fOBaCLzx1TDy5PZD0JyyibACsHpboQEoTfD5iFucZTZ2PixIlYtGgRunbtiiuuuAL9+/fH2rVrTdd97LHH8MEHHwAIDpkcddRROProo3HyyScDAM4991xMmzYNO3bswNatW5GXl4czzjgDQNAcI74bDZO9e/eipqYGbrcbxcXFlu6hUaNGYe/evTjttNMAAJdddhnuuusulJWVaeqryYTn4+GWDYJ0OciyIQiCkC4EPH74TaJRAvFMxDZixAj84x//wE8//YSVK1fWuu7tt9+O22+/XftdUlKC6dOnY+PGjTjhhBPwxRdfwGazoWPHjvj8888xY8YMLF26FBkZGXjxxRdxwQUXRF1xIT3weDy46aabMG3aNPj9fkyaNAnvvPOOsmHJ76Evv/wSkyZNwtq1a9GiRQu8/fbbOOaYY1KioSEI6cLVV1/N5gTftbNnz8Z1va2FXy/49XhceeWVEdfj2VNfffVVAMCSimAHk5Id8gY7Fy6k1AsifJc8An6Fz0Y8dTYyMjIwYsQI7Nu3z/ILvqCgAHPnzsWf//xnVFZWIiMjA3PmzEGTJk0wbtw47NixA8OGDYPX60Xfvn1xyy23WCpfSH0efvhhtGrVShMjWrNmDR555BHce++9UW1/+umnY+rUqRg1ahQcDgfatm2r5cxJBbgiKFcMpXFkyiB81VVX1WPtBEEQ6k7A60fAJPIkYCE3Sq0OokBQQ//iiy/G3//+d5xyyinWaykIDRgaDqIU83wYhRobO3bsAABTfydBSCb+f91taX1yCjVi5iAqNBxGT30PRfsqwua3bdUUS575Q1Rl1GrZWL9+PW666SaMHz9eGhqCYEK0jYdjjjkmwTURhNgwazwIghG/19xnwx+vrK8DBgzAjz/+aL1mgiAIgiA0DHyKaBRJxCYIgiAIQjxIuGVDEARBEIRGjl8ReRJ9W0MaG4IgCIIgqAl4fYpolOhzo4gEoyAIQj2xevVq9OjRI2Tes88+i/79+6Nv37544oknLOWbEBovgUAA06dPR//+/TFgwAB8/fXXput98MEHOO+883D22Wfj/vvvj21fvoDyEy1i2RAEQagHtmzZggcffDCkMbFu3TosX74cq1evht1uxxVXXIGjjz4af/hDdOGEqYIkNKx/VqxYgU2bNmH9+vXYunUrxo8fj08++SRE+2f79u24++67sXz5crRu3RqXXnopPvroIwwcONDSvsRnQxAEoZ6ZN28e3njjDe33pk2b0KtXL1RXV4etS/l+qqqqMHXqVPzlL3/BTTfdpC1fvXo1Ro4ciezsbABB1c2333477Robo0ePTnYVGh3r1q3DhRdeCLvdjm7duqF9+/b45ptvtBQgALBq1SpccMEFaNeuHQBg1qxZyMzMtLyvglbZgInPRkGr7KjLkMaGIAiCBSZOnIiJEycCCEpwL1q0CIsXL9YaDGbccccduPLKK3HccceFzP/tt99w1llnab8LCwuxZ8+ehNRbaFgUFxdrifUAoE2bNmH3zrZt25CRkYGJEydi9+7dGDx4MO644w7L+5r7/EV1rq80NgRBEGJg1apVeOGFF/DOO+/gm2++UWYy3rZtG5xOJy677LKwRHx+k6yZDocjYXUWGg5+v1/LJwMEfTh4Akifz4cNGzZg6dKlyM7OxlVXXYU333wzKcNe0tgQBEGwyNdff4177rkHixYtQkFBAQoKCpSZjEeMGIGqqioMGTIEHo8H1dXVGDJkCF5//XW0b98excXF2rpFRUUoLCysr8MQ0gxjVuxDhw6hpKREW1ZSUoI2bdqErN+6dWv069cPLVu2BAAMGzYM33//fXJ8bAKCIAhC1Pzyyy+Bk046KfDZZ59Z3nbHjh2B7t27a7/XrFkTGDZsWKCioiJQXV0duOSSSwKLFy+OZ3WFBsp7770XuOKKKwJerzewZcuWwCmnnBKorKwMWefbb78N9OvXL1BWVhbwer2B8ePHBxYsWJCU+oplQxAEwQJ/+ctf4Ha78eCDD8Lr9QIAevfujccff9xyWUOHDsXPP/+MESNGwO1249xzzxVnSyEqzj//fHz33XcYPHgwAOCJJ55AVlYWioqKMG7cOKxduxYnn3wyJk2ahJEjR8Lj8aB///5JixyKmPVVEARBEAShLoiolyAIgiAICUUaG4IgCIIgJBRpbAiCIAiCkFCksSEIgiAIQkKRxoYgCIIgCAlFGhuCIAiCICQUaWwIgiAIgpBQpLEhCIIgCEJCkcaGIAiCIAgJRRobgiAIgiAkFGlsCIIgCIKQUP4fIFpx1zEq2aUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For the intact story stimulus, high parcel-wise ISC extends from low-level\n", + "auditory areas into higher-level areas including posterior medial cortex.\n" + ] + } + ], + "source": [ + "# Project intact parcel-wise ISC values onto brain\n", + "sns.set(palette='colorblind')\n", + "vmax = .6\n", + "threshold = .1\n", + "\n", + "intact_img = np.zeros(atlas_img.shape)\n", + "for i, parcel in enumerate(np.unique(atlas_img)[1:]):\n", + " intact_img[atlas_img == parcel] = intact_iscs[i]\n", + "\n", + "# Convert to NIfTI image for visualization with Nilearn\n", + "intact_nii = nib.Nifti1Image(intact_img, atlas_nii.affine, atlas_nii.header)\n", + "\n", + "# Plot intact ISCs to visualize superior temporal cortex\n", + "plot_stat_map(intact_nii, cmap='RdYlBu_r', vmax=vmax, threshold=threshold,\n", + " title='mean ISC (intact condition)', cut_coords=(-57, -24, 9))\n", + "\n", + "# Plot intact ISCs to visualize posterior medial cortex\n", + "plot_stat_map(intact_nii, cmap='RdYlBu_r', vmax=vmax, threshold=threshold,\n", + " cut_coords=(-3, -65, 40));\n", + "plt.show()\n", + "\n", + "# Print short \"figure caption\" describing result\n", + "print(\"For the intact story stimulus, high parcel-wise ISC extends \"\n", + " \"from low-level\\nauditory areas into higher-level areas \"\n", + " \"including posterior medial cortex.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temporal receptive windows\n", + "Next, we'll load in fMRI data for a temporally scrambled version of the same stimulus. We compute parcel-wise leave-one-out ISC in the same manner as for the *intact* stimulus. Temporally scrambling the stimulus retains many low-level perceptual qualities of the stimulus, but abolishes the higher-level semantic meaning and narrative arc. Correspondingly, we see high ISC in early auditory cortex (similar to the *intact* condition), but markedly lower ISC in high-level cortices than observed with the *intact* stimulus." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Load in scrambled functional data and compute parcel means\n", + "scram_fns = sorted(glob('brainiak-aperture-isc-data/sub-*_task-notthefallshortscram_*bold.nii.gz'))\n", + "scram_parcels = []\n", + "for scram_fn in scram_fns:\n", + " scram_data = nib.load(scram_fn).get_fdata()\n", + " scram_means = [np.mean(scram_data[atlas_img == parcel, :], axis=0)\n", + " for parcel in np.unique(atlas_img)[1:]]\n", + " scram_parcels.append(np.column_stack(scram_means))\n", + "scram_parcels = np.dstack(scram_parcels)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute parcel-wise ISC using the leave-one-out approach\n", + "scram_iscs = isc(scram_parcels, pairwise=False,\n", + " summary_statistic='mean')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For the scrambled story stimulus, we observe high ISC in early auditory\n", + "areas, but reduced ISC in higher-level areas like posterior medial cortex.\n" + ] + } + ], + "source": [ + "# Project parcel-wise ISC values onto brain\n", + "vmax = .6\n", + "threshold = .1\n", + "\n", + "scram_img = np.zeros(atlas_img.shape)\n", + "for i, parcel in enumerate(np.unique(atlas_img)[1:]):\n", + " scram_img[atlas_img == parcel] = scram_iscs[i]\n", + "\n", + "# Convert to a NIfTI image for visualization with Nilearn\n", + "scram_nii = nib.Nifti1Image(scram_img, atlas_nii.affine, atlas_nii.header)\n", + "\n", + "# Plot scrambled ISCs to visualize superior temporal cortex\n", + "plot_stat_map(scram_nii, cmap='RdYlBu_r', vmax=vmax, threshold=threshold,\n", + " title='mean ISC (scrambled condition)',\n", + " cut_coords=(-57, -24, 9))\n", + "\n", + "# Plot scrambled ISCs to visualize posterior medial cortex\n", + "plot_stat_map(scram_nii, cmap='RdYlBu_r', vmax=vmax, threshold=threshold,\n", + " cut_coords=(-3, -65, 40));\n", + "plt.show()\n", + "\n", + "# Print short \"figure caption\" describing result\n", + "print(\"For the scrambled story stimulus, we observe high ISC \"\n", + " \"in early auditory\\nareas, but reduced ISC in higher-level \"\n", + " \"areas like posterior medial cortex.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intersubject network estimation (ISFC)\n", + "Instead of only computing ISC between homologous brain areas, we can also compute ISC across brain areas using intersubject functional correlation (ISFC) analysis ([Simony et al., 2016](https://doi.org/10.1038/ncomms12141)). Traditional functional connectivity (FC) analyses measure within-subject FC (WSFC), typically during resting-state paradigms. ISFC analysis, on the other hand measures shared stimulus-evoked functional connectivity. Traditional FC analyses are highly sensitive to artefacts such as head motion or physiological. Unlike within-subject FC, ISFC analysis filters out artefacts that are not synchronized across subjects." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute ISFC on intact data\n", + "intact_isfcs = isfc(intact_parcels, pairwise=False,\n", + " vectorize_isfcs=False,\n", + " summary_statistic='mean')\n", + "\n", + "# Compute ISFC on scrambled data\n", + "scram_isfcs = isfc(scram_parcels, pairwise=False,\n", + " vectorize_isfcs=False,\n", + " summary_statistic='mean')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/snastase/miniconda3/envs/brainiak/lib/python3.7/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in arctanh\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + } + ], + "source": [ + "# Compute mean with Fisher z-transformation\n", + "def fisher_mean(correlation, axis=None):\n", + " return np.tanh(np.mean(np.arctanh(correlation), axis=axis))\n", + "\n", + "# Compute within-subject functional connectivity for intact data\n", + "intact_fcs = fisher_mean([np.corrcoef(s) for s in intact_parcels.T],\n", + " axis=0)\n", + "\n", + "# Compute within-subject functional connectivity for scrambled data\n", + "scram_fcs = fisher_mean([np.corrcoef(s) for s in scram_parcels.T],\n", + " axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Load in network labels\n", + "label_fn = 'brainiak-aperture-isc-data/Schaefer2018_400Parcels_17Networks_order.txt'\n", + "with open(label_fn) as f:\n", + " networks = [' '.join((label.split('_')[1][0], label.split('_')[2]))\n", + " for label in f.readlines()]\n", + " \n", + "# Get sorted unique network labels\n", + "idxs = np.unique(networks, return_index=True)[1]\n", + "network_labels = [networks[idx] for idx in sorted(idxs)]\n", + "\n", + "# Get middle index for each network for plotting\n", + "network_idxs = [int(np.median([i for i, n in enumerate(networks)\n", + " if n == network]))\n", + " for network in network_labels]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ISFC networks have generally lower correlations than within-subject functional connectivity, but better\n", + "differentiate intact and scrambled stories.\n", + "\n", + "Correlation between intact and scrambled ISFC networks: 0.602\n", + "Correlation between intact and scrambled WSFC networks: 0.941\n" + ] + } + ], + "source": [ + "# Visualize ISFC/FC matrices for intact and scrambled conditions\n", + "vmin, vmax = 0, .5\n", + "sns.set_style('white')\n", + "\n", + "fig, axs = plt.subplots(2, 2, figsize=(18, 18))\n", + "fc_mats = [intact_isfcs, scram_isfcs, intact_fcs, scram_fcs]\n", + "fc_titles = ['ISFC (intact)', 'ISFC (scrambled)',\n", + " 'WSFC (intact)', 'WSFC (scrambled)']\n", + "for ax, fc, t in zip(axs.flatten(), fc_mats, fc_titles):\n", + " ax.matshow(fc, vmax=vmax, vmin=vmin, cmap='RdYlBu_r')\n", + " ax.set_xlabel(t)\n", + " ax.xaxis.set_label_position('top')\n", + " ax.set_xticks([])\n", + " ax.set_yticks(network_idxs)\n", + " ax.set_yticklabels(network_labels)\n", + " ax.tick_params(axis='y', which='both', length=0, labelsize=9)\n", + "plt.subplots_adjust(hspace=0)\n", + "plt.show()\n", + "\n", + "# High correlation between intact and scrambled\n", + "# for within-subject functional connectivity\n", + "fc_r = pearsonr(squareform(intact_fcs, checks=False),\n", + " squareform(scram_fcs, checks=False))[0]\n", + "\n", + "# ISFC is more distinct for intact and scrambed conditions\n", + "isfc_r = pearsonr(squareform(intact_isfcs, checks=False),\n", + " squareform(scram_isfcs, checks=False))[0]\n", + "\n", + "print(\"ISFC networks have generally lower correlations than \"\n", + " \"within-subject functional connectivity, but better\\n\"\n", + " \"differentiate intact and scrambled stories.\\n\")\n", + "print(f\"Correlation between intact and scrambled ISFC networks: {isfc_r:.3}\")\n", + "print(f\"Correlation between intact and scrambled WSFC networks: {fc_r:.3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Find center-of-mass for each parcel in MNI space for visualization\n", + "node_coords = []\n", + "for parcel in np.unique(atlas_img)[1:]:\n", + " parcel_img = atlas_img == parcel\n", + " parcel_nii = nib.Nifti1Image(parcel_img, atlas_nii.affine,\n", + " atlas_nii.header)\n", + " node_coords.append(find_xyz_cut_coords(parcel_nii))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ISFC connectome better differentiates intact and scrambled stories.\n" + ] + } + ], + "source": [ + "# Visualize WSFC and ISFC connectome on glass brain (takes a minute to render)\n", + "display_mode = 'ortho'\n", + "edge_threshold = .2\n", + "edge_vmin, edge_vmax = -.65, .65\n", + "edge_cmap='RdYlBu_r'\n", + "\n", + "fc_mats = [intact_isfcs, scram_isfcs, intact_fcs, scram_fcs]\n", + "fc_titles = ['ISFC (intact)', 'ISFC (scrambled)',\n", + " 'WSFC (intact)', 'WSFC (scrambled)']\n", + "\n", + "fig, axs = plt.subplots(2, 2, figsize = (16, 7))\n", + "for ax, fc, t in zip(axs.flatten(), fc_mats, fc_titles):\n", + " plot_connectome(fc, node_coords, node_size=0,\n", + " edge_threshold=edge_threshold, \n", + " edge_vmin=edge_vmin, edge_vmax=edge_vmax,\n", + " edge_cmap=edge_cmap, \n", + " display_mode=display_mode, \n", + " title=t, axes=ax, colorbar=True)\n", + "plt.show()\n", + "\n", + "print(\"The ISFC connectome better differentiates \"\n", + " \"intact and scrambled stories.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intersubject pattern correlation (ISPC)\n", + "Rather than computing parcel-wise ISC across time, we can compute the spatial ISC of distributed response patterns in a parcel (e.g. [Chen et al., 2017](https://doi.org/10.1038/nn.4450), [Zadbood et al., 2017](https://doi.org/10.1093/cercor/bhx202)). Computing intersubject pattern correlation across all time points can allow us to discover whether similar response patterns recur at different points in the stimulus ([Baldassano et al., 2017](https://doi.org/10.1016/j.neuron.2017.06.041)). Here, we compute ISPC for the left default-mode network (DMN) A network." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Get labels for parcels in left DMN A network\n", + "dmn_a = (np.array(networks) == 'L DefaultA').nonzero()[0] + 1\n", + "\n", + "# Re-load in intact functional data and extract DMN A\n", + "intact_dmns = []\n", + "for intact_fn in intact_fns:\n", + " intact_data = nib.load(intact_fn).get_fdata()\n", + " intact_dmns.append(np.column_stack([intact_data[atlas_img == parcel, :].T\n", + " for parcel in dmn_a]))\n", + "intact_dmns = np.dstack(intact_dmns)\n", + "\n", + "# Load in scrambled functional data and extract DMN A\n", + "scram_dmns = []\n", + "for scram_fn in scram_fns:\n", + " scram_data = nib.load(scram_fn).get_fdata()\n", + " scram_dmns.append(np.column_stack([scram_data[atlas_img == parcel, :].T\n", + " for parcel in dmn_a]))\n", + "scram_dmns = np.dstack(scram_dmns)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Transpose input data to compute intersubject pattern correlation\n", + "intact_ispcs = isfc(np.rollaxis(intact_dmns, 1, 0),\n", + " pairwise=False, vectorize_isfcs=False,\n", + " summary_statistic='mean')\n", + "\n", + "scram_ispcs = isfc(np.rollaxis(scram_dmns, 1, 0),\n", + " pairwise=False, vectorize_isfcs=False,\n", + " summary_statistic='mean')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Visualizing ISPC across all time points indicates that some\n", + "response patterns persist over time (diagonal blocks) while\n", + "some patterns recur at later times (off-diagonal blocks)\n" + ] + } + ], + "source": [ + "# Plot time-point-by-time-point intersubject pattern correlation\n", + "vmin, vmax = 0, .15\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 8))\n", + "ispcs = [intact_ispcs, scram_ispcs]\n", + "titles = ['DMN mean ISPC (intact)', 'DMN mean ISPC (scrambled)']\n", + "for ax, ispc, t in zip(axs, ispcs, titles):\n", + " ax.matshow(ispc, vmin=vmin, vmax=vmax, cmap='RdYlBu_r')\n", + " ax.set_title(t) \n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_xlabel('time')\n", + " ax.set_ylabel('time')\n", + "plt.show()\n", + "\n", + "print(\"Visualizing ISPC across all time points indicates that \"\n", + " \"some\\nresponse patterns persist over time (diagonal blocks) \"\n", + " \"while\\nsome patterns recur at later times (off-diagonal blocks)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "Using ISC analysis, we are able to measure shared responses to a complex story stimulus. By comparing ISC for brain responses to the intact and temporally-scrambled story stimulus, we can identify areas of the brain sensitive to temporally-evolving features of the stimulus (e.g. narrative context). ISFC analysis allows us examine functional network organization in a way that is more sensitive to the stimulus than traditional within-subject functional connectivity analysis. Finally, we can apply the logic of ISC analysis to distributed responses patterns to visualizing recurring response patterns over time." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### References\n", + "* Baldassano, C., Chen, J., Zadbood, A., Pillow, J. W., Hasson, U., & Norman, K. A. (2017). Discovering event structure in continuous narrative perception and memory. *Neuron*, *95(3), 709-721. https://doi.org/10.1016/j.neuron.2017.06.041\n", + "\n", + "* Chen, G., Shin, Y. W., Taylor, P. A., Glen, D. R., Reynolds, R. C., Israel, R. B., & Cox, R. W. (2016). Untangling the relatedness among correlations, part I: nonparametric approaches to inter-subject correlation analysis at the group level. *NeuroImage*, *142*, 248-259. https://doi.org/10.1016/j.neuroimage.2016.05.023\n", + "\n", + "* Chen, G., Taylor, P. A., Shin, Y. W., Reynolds, R. C., & Cox, R. W. (2017). Untangling the relatedness among correlations, part II: inter-subject correlation group analysis through linear mixed-effects modeling. *NeuroImage*, *147*, 825-840. https://doi.org/10.1016/j.neuroimage.2016.08.029\n", + "\n", + "* Chen, G., Taylor, P. A., Qu, X., Molfese, P. J., Bandettini, P. A., Cox, R. W., & Finn, E. S. (2020). Untangling the relatedness among correlations, part III: inter-subject correlation analysis through Bayesian multilevel modeling for naturalistic scanning. *NeuroImage*, *216*, 116474. https://doi.org/10.1016/j.neuroimage.2019.116474\n", + "\n", + "* Chen, J., Leong, Y. C., Honey, C. J., Yong, C. H., Norman, K. A., & Hasson, U. (2017). Shared memories reveal shared structure in neural activity across individuals. *Nature Neuroscience*, *20*(1), 115-125. https://doi.org/10.1038/nn.4450\n", + "\n", + "* Chien, H. Y. S., & Honey, C. J. (2020). Constructing and forgetting temporal context in the human cerebral cortex. *Neuron*, *106*(4), 675-686. https://doi.org/10.1016/j.neuron.2020.02.013\n", + "\n", + "* Hasson, U., Nir, Y., Levy, I., Fuhrmann, G., & Malach, R. (2004). Intersubject synchronization of cortical activity during natural vision. *Science*, *303*(5664), 1634–1640. https://doi.org/10.1126/science.1089506\n", + "\n", + "* Nastase, S. A., Gazzola, V., Hasson, U., & Keysers, C. (2019). Measuring shared responses across subjects using intersubject correlation. *Social Cognitive and Affective Neuroscience*, *14*(6), 667–685. https://doi.org/10.1093/scan/nsz037\n", + "\n", + "* Nastase, S. A., Liu, Y.-F., Hillman, H., Zadbood, A., Hasenfratz, L., Keshavarzian, N., Chen, J., Honey, C. J., Yeshurun, Y., Regev, M., Nguyen, M., Chang, C. H. C., Baldassano, C., Lositsky, O., Simony, E., Chow, M. A., Leong, Y. C., Brooks, P. P., Micciche, E., Choe, G., Goldstein, A., Halchenko, Y. O., Norman, K. A., & Hasson, U. (2019). Narratives: fMRI data for evaluating models of naturalistic language comprehension. *OpenNeuro*, ds002345. https://doi.org/10.18112/openneuro.ds002345.v1.1.2\n", + "\n", + "* Schaefer, A., Kong, R., Gordon, E. M., Laumann, T. O., Zuo, X. N., Holmes, A. J., Eickhoff, S. B., & Yeo, B. T. T. (2018). Local-global parcellation of the human cerebral cortex from intrinsic functional connectivity MRI. *Cerebral Cortex*, *28*(9), 3095-3114. https://doi.org/10.1093/cercor/bhx179\n", + "\n", + "* Simony, E., Honey, C. J., Chen, J., Lositsky, O., Yeshurun, Y., Wiesel, A., & Hasson, U. (2016). Dynamic reconfiguration of the default mode network during narrative comprehension. *Nature Communications*, *7*, 12141. https://doi.org/10.1038/ncomms12141\n", + "\n", + "* Zadbood, A., Chen, J., Leong, Y. C., Norman, K. A., & Hasson, U. (2017). How we transmit memories to other brains: constructing shared neural representations via communication. *Cerebral Cortex*, *27*(10), 4988-5000. https://doi.org/10.1093/cercor/bhx202" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "brainiak_pr_venv_ORLfW", + "language": "python", + "name": "brainiak_pr_venv_orlfw" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/isc/download_data.sh b/docs/examples/isc/download_data.sh new file mode 100644 index 00000000..96d9f77b --- /dev/null +++ b/docs/examples/isc/download_data.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# Download the data, the python notebook handles extraction and +wget -nc https://zenodo.org/record/4300904/files/brainiak-aperture-isc-data.tgz diff --git a/docs/examples/matnormal/Matrix-normal model prototyping.ipynb b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb new file mode 100644 index 00000000..68cdb138 --- /dev/null +++ b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb @@ -0,0 +1,1075 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rapid prototyping of fMRI models with `brainiak.matnormal`\n", + "\n", + "Michael Shvartsman [m.shvartsman.work@gmail.com](mailto://m.shvartsman.work@gmail.com)\n", + "\n", + "# Annotated Bibliography \n", + "\n", + "Shvartsman, M., Sundaram, N., Aoi, M., Charles, A., Willke, T. L., & Cohen, J. D. (2018). Matrix-normal models for fMRI analysis. *International Conference on Artificial Intelligence and Statistics, AISTATS 2018*, 1914–1923. Extended version available at [`link`](https://arxiv.org/abs/1711.03058) *Describes how to formulate a number of common fMRI analysis methods available in `BrainIAK` as matrix-normal models, and shows some benefits of this formulation.*\n", + "\n", + "Cai, M. B., Shvartsman, M., Wu, A., Zhang, H., & Zhu, X. (2020). Incorporating structured assumptions with probabilistic graphical models in fMRI data analysis. *Neuropsychologia*, 144, 1–23. [`link`](https://doi.org/10.1016/j.neuropsychologia.2020.107500) *Provides an alternate framing of the matrix normal model focusing on the modeling of structured residuals.*\n", + "\n", + "\n", + "Magnus, J. R., & Neudecker, H. (1988). Matrix differential calculus with applications in statistics and econometrics. *This is the standard reference for matrix calculus. A summary of some important identities may also be found on Wikipedia at [`link`](https://en.wikipedia.org/wiki/Matrix_calculus#Identities_in_differential_form).*\n", + "\n", + "\n", + "Katanoda, K., Matsuda, Y., & Sugishita, M. (2002). A spatio-temporal regression model for the analysis of functional MRI data. *NeuroImage*, 17(3), 1415–1428. [`link`](https://doi.org/10.1006/nimg.2002.1209) *Example of a regression model for fMRI with separable residuals.*\n", + "\n", + "Hartvig, N. V. (2002). A stochastic geometry model for functional magnetic resonance images. *Scandinavian Journal of Statistics*, 29(3), 333–353. [`link`](https://doi.org/10.1111/1467-9469.00294) *Example of a separable residual covariance to a spatial activation model for fMRI data.*\n", + "\n", + "Kia, S. M., Beckmann, C. F., & Marquand, A. F. (2018). Scalable multi-task gaussian process tensor regression for normative modeling of structured variation in neuroimaging data. Retrieved from [`link`](http://arxiv.org/abs/1808.00036) *Example of using tensor regression models for analyzing fMRI data.*\n", + "\n", + "\n", + "## Table of contents\n", + "- [Overview: understanding Kronecker-separability](#Overview)\n", + "- [Example 1: regression](#regression)\n", + "- [Example 2: marginalization and RSA](#MN-RSA)\n", + "- [Example 3: design matrices: PCA and FA](#latent-design)\n", + "- [Summary and future outlook](#Summary)" + ] + }, + { + "attachments": { + "schematic_kron.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Overview: Understanding kronecker-separability\n", + "\n", + "Unlike many of the other tools in `brainiak`, the `brainiak.matnormal` package is only a little bit about specific methods and a lot about letting you try new ideas and method variants quickly. If the variants are useful, they can be sped up and made neater for broader consumption. To understand the idea behind matrix-normal or kronecker-separable models, consider the following figure: \n", + "\n", + "![schematic_kron.png](attachment:schematic_kron.png)\n", + "\n", + "**Matrix normal models simultaneously model spatial and temporal residuals.** \\[A\\]: a schematic view of a vectorized data matrix, where each voxel's time series is vertically concatenated (in orange), and the covariance of every voxel at every timepoint with every other voxel at every other timepoint is modeled. Modeling all of these elements independently is intractable, and some structure needs to be imposed -- in this case, kronecker-separable structure. \\[B\\]: the un-vectorized data matrix (orange rectangle), and its spatial and temporal covariances on the right and bottom. \\[C\\]: A matrix-normal distribution with the mean M and row/column covariances R, C is equivalent to the large structure in \\[A\\], but can be much more tractable to estimate. Figure and caption reused under CC-BY-NC-ND from doi:[10.1016/j.neuropsychologia.2020.107500](https://doi.org/10.1016/j.neuropsychologia.2020.107500). \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Example 1: Matrix-normal (separable-covariance) regression\n", + "To understand how simple it is to prototype new matrix-normal models, consider first simple linear regression: \n", + "\n", + "$$\n", + "Y \\sim \\mathcal{MN}(XB, I, I), \n", + "$$\n", + "\n", + "where $Y$ is a centered TRs by voxels matrix of brain data, $X$ is a TRs by conditions design matrix, and $B$ is a conditions by voxels coefficients matrix. Notated this way, the model is the conventional massively-univariate GLM: the activation at every voxel and every timepoint is a linear combination (aka weighted sum) of the condition coding, weighted by the coefficients -- or equivalently a weighted sum of the coefficients, with the condition codes as weights. We can generate a simple dataset and show how simple it is to fit such a model by maximum likelihood using automatically computed gradients. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# General imports and setup\n", + "import numpy as np\n", + "import scipy.linalg\n", + "from numpy.linalg import cholesky\n", + "import seaborn as sns\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.special import expit as inv_logit\n", + "from scipy.stats import norm, pearsonr\n", + "\n", + "from sklearn.datasets import make_friedman1\n", + "from sklearn.base import BaseEstimator, TransformerMixin\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "np.random.seed(1)\n", + "tf.random.set_seed(1)\n", + "sns.set_theme()\n", + "\n", + "# brainiak.matnormal.covs provides implementations of various\n", + "# structured covariances. We will discuss this shortly.\n", + "from brainiak.matnormal.covs import (\n", + " CovAR1,\n", + " CovDiagonal,\n", + " CovDiagonalGammaPrior,\n", + " CovIdentity,\n", + " CovUnconstrainedCholesky,\n", + ")\n", + "\n", + "# brainiak.matnormal.matnormal_likelihoods provides efficient implementations\n", + "# of matrix-normal likelihoods, including marginals and conditionals\n", + "from brainiak.matnormal.matnormal_likelihoods import (\n", + " matnorm_logp,\n", + " matnorm_logp_marginal_row,\n", + " matnorm_logp_marginal_col,\n", + ")\n", + "\n", + "# brainiak.matnormal provides implementations of MN variants of some existing analyses\n", + "from brainiak.matnormal.mnrsa import MNRSA\n", + "from brainiak.matnormal.regression import MatnormalRegression\n", + "\n", + "# brainiak.matnormal.utils provides helpers that (mostly) make it easy\n", + "# to interface between tensorflow and scipy optimizers\n", + "from brainiak.matnormal.utils import (\n", + " make_val_and_grad,\n", + " pack_trainable_vars,\n", + " rmn,\n", + " unpack_trainable_vars,\n", + ")\n", + "\n", + "# this is used in the MNRSA example\n", + "from brainiak.utils.utils import cov2corr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate data\n", + "conditions = 5\n", + "voxels = 100\n", + "TRs = 50\n", + "\n", + "X, _ = make_friedman1(n_samples=TRs, n_features=conditions, random_state=None)\n", + "B = 2 * np.random.random(size=(conditions, voxels)) # pretty generous SNR of 2\n", + "Y = X @ B + np.random.normal(size=(TRs, voxels))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n", + "True and estimated B correlation: 0.78999786325132\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now we create the tensorflow objects we need. The covariances are independent\n", + "# since this is the univariate GLM.\n", + "space_cov = CovIdentity(size=voxels)\n", + "time_cov = CovIdentity(size=TRs)\n", + "\n", + "# this is our estimate of B, and the wrappers for X and Y.\n", + "B_hat = tf.Variable(np.random.normal(size=(conditions, voxels)), name=\"beta\")\n", + "Y_tf = tf.constant(Y)\n", + "X_tf = tf.constant(X)\n", + "# construct loss (negative log likelihood)\n", + "# note that params are ignored by this function but implicitly\n", + "# tracked by tensorflow to compute gradients\n", + "def loss(params):\n", + " return -matnorm_logp(Y_tf - X_tf @ B_hat, time_cov, space_cov)\n", + "\n", + "\n", + "val_and_grad = make_val_and_grad(lossfn=loss, train_vars=[B_hat])\n", + "initial_guess = pack_trainable_vars([B_hat])\n", + "opt_results = minimize(fun=val_and_grad, x0=initial_guess, jac=True, method=\"L-BFGS-B\")\n", + "print(opt_results.message) # check that we converged\n", + "\n", + "_ = B_hat.assign(unpack_trainable_vars(opt_results.x, trainable_vars=[B_hat])[0])\n", + "\n", + "plt.plot(B.flatten(), B_hat.numpy().flatten(), \"bo\")\n", + "plt.xlabel(\"True B\")\n", + "plt.ylabel(\"Estimated B\")\n", + "plt.title(\"True vs estimated B\")\n", + "print(\n", + " f\"True and estimated B correlation: {pearsonr(B_hat.numpy().flatten(), B.flatten())[0]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In practice, a simple model like this could just as easily be fit using more standard tools. More interesting is if we (reasonably) assume that the noise in our data is structured, and we want to model that structure rather than try to prewhiten it, for example:\n", + "\n", + "$$\n", + "\\sigma_v^{-1} \\sim \\mathcal{InvGamma}(\\alpha, \\beta)\\\\\n", + "Y \\sim \\mathcal{MN}(XB, \\Sigma_{AR1},\\mathrm{diag}(\\sigma_v)), \n", + "$$\n", + "\n", + "where $\\Sigma_{AR1}$ is a structured covariance matrix with AR(1) structure, and the spatial covariance is diagonal (independent) but with varying scales for each voxel and we use an inverse-gamma prior to regularize them. Estimating this model is very similar: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n", + "True and estimated B correlation: 0.7891954003335606\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# generate AR(1) temporal noise that is independent in space\n", + "true_time_cov = CovAR1(size=TRs)\n", + "true_space_cov = CovDiagonalGammaPrior(size=voxels)\n", + "noise = rmn(rowcov=true_time_cov._cov, colcov=true_space_cov._cov)\n", + "Y = X @ B + noise\n", + "\n", + "# This time space_cov is AR(1)\n", + "space_cov = CovDiagonalGammaPrior(size=voxels)\n", + "time_cov = CovAR1(size=TRs)\n", + "\n", + "# Reset B_hat\n", + "B_hat = tf.Variable(np.random.normal(size=(conditions, voxels)), name=\"beta\")\n", + "\n", + "# Now we estimate B_hat, but also the AR parameters and the\n", + "# voxelwise residual variances (which the relevant\n", + "# cov objects know about and expose to us)\n", + "train_vars = [B_hat] + time_cov.get_optimize_vars() + space_cov.get_optimize_vars()\n", + "\n", + "# now this loss incorporates the log-likelihood of our covariance parameters\n", + "def loss(params):\n", + " return (\n", + " -matnorm_logp(Y_tf - X_tf @ B_hat, time_cov, space_cov)\n", + " - space_cov.logp\n", + " - time_cov.logp\n", + " )\n", + "\n", + "\n", + "val_and_grad = make_val_and_grad(lossfn=loss, train_vars=train_vars)\n", + "initial_guess = pack_trainable_vars(train_vars)\n", + "opt_results = minimize(fun=val_and_grad, x0=initial_guess, jac=True, method=\"L-BFGS-B\")\n", + "print(opt_results.message) # check that we converged\n", + "\n", + "# assign the AR parameters as well as B\n", + "unpacked_theta = unpack_trainable_vars(opt_results.x, trainable_vars=train_vars)\n", + "for var, val in zip(train_vars, unpacked_theta):\n", + " var.assign(val)\n", + "\n", + "\n", + "plt.plot(B.flatten(), B_hat.numpy().flatten(), \"bo\")\n", + "plt.xlabel(\"True B\")\n", + "plt.ylabel(\"Estimated B\")\n", + "plt.title(\"True vs estimated B\")\n", + "print(\n", + " f\"True and estimated B correlation: {pearsonr(B_hat.numpy().flatten(), B.flatten())[0]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`brainiak.matnormal` provides a convenience wrapper for such regression models (as `MatnormalRegression`). " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True an estimated B correlation (MN): 0.6194865860962584\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = MatnormalRegression(time_cov=time_cov, space_cov=space_cov)\n", + "model.fit(X, Y, naive_init=False)\n", + "plt.plot(B.flatten(), model.beta_.flatten(), \"bo\")\n", + "plt.xlabel(\"True B\")\n", + "plt.ylabel(\"Estimated B\")\n", + "plt.title(\"True vs estimated B\")\n", + "print(\n", + " f\"True an estimated B correlation (MN): {pearsonr(model.beta_.flatten(), B.flatten())[0]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The covariance-modeling approach should work better than either ignoring covariance structure in the data, or pre-whitening by dividing out the correlations. So we now compare to both of those approaches on the same synthetic dataset. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True and estimated B correlation (MN): 0.6194865860962584\n", + "True and estimated B correlation (GLM, ignore cov): 0.38985685962097216\n", + "True and estimated B correlation (GLM, prewhiten cov): 0.5315137290009893\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "glm_ignore_cov = LinearRegression()\n", + "glm_ignore_cov.fit(X, Y)\n", + "\n", + "# prewhiten\n", + "W = np.linalg.cholesky(np.cov(Y))\n", + "Y_whitened = np.linalg.solve(W, Y)\n", + "X_whitened = np.linalg.solve(W, X)\n", + "coef_whitened = np.linalg.solve(X_whitened.T @ X_whitened, X_whitened.T @ Y_whitened)\n", + "glm_whitened = LinearRegression()\n", + "glm_whitened.fit(X_whitened, Y_whitened)\n", + "\n", + "fig, axes = plt.subplots(1, 3, sharex=False, sharey=True, figsize=(18, 6))\n", + "\n", + "axes[0].plot(B.flatten(), model.beta_.flatten(), \"bo\", label=\"MN\")\n", + "axes[0].set_title(\"True vs estimated B (MN)\")\n", + "axes[1].plot(\n", + " B.flatten(),\n", + " glm_ignore_cov.coef_.T.flatten(),\n", + " \"go\",\n", + " label=\"GLM (ignore cov)\",\n", + ")\n", + "axes[1].set_title(\"True vs estimated B (GLM, ignore cov)\")\n", + "axes[2].plot(\n", + " B.flatten(),\n", + " glm_whitened.coef_.T.flatten(),\n", + " \"ro\",\n", + " label=\"GLM (pre-whiten)\",\n", + ")\n", + "axes[2].set_title(\"True vs estimated B (GLM, prewhiten cov)\")\n", + "for ax in axes: \n", + " ax.set_xlabel(\"True B\")\n", + " ax.set_ylabel(\"Estimated B\") \n", + "plt.xlim(0, 2)\n", + "plt.ylim(-5, 5)\n", + "print(\n", + " f\"True and estimated B correlation (MN): {pearsonr(B.flatten(), model.beta_.flatten())[0]}\"\n", + ")\n", + "print(\n", + " f\"True and estimated B correlation (GLM, ignore cov): {pearsonr(B.flatten(),glm_ignore_cov.coef_.T.flatten())[0]}\"\n", + ")\n", + "print(\n", + " f\"True and estimated B correlation (GLM, prewhiten cov): {pearsonr(B.flatten(), glm_whitened.coef_.T.flatten())[0]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: Priors and marginalization, with MN-RSA\n", + "\n", + "We have already introduced the idea of priors in the previous example, though in that case we were using them purely as regularization. But we can sometimes set priors in a way that lets us integrate over some nuisance parameter entirely. This marginalization is used, for example, in deriving BRSA from beta-series RSA (also available in `brainiak`). We notate the same marginalization in the matrix-normal setting next. If: \n", + "\n", + "$$\n", + "B \\sim \\mathcal{MN}(0, U, I)\\\\\n", + "Y \\mid B \\sim \\mathcal{MN}(XB, \\Sigma_{AR1},I), \n", + "$$\n", + "then:\n", + "$$\n", + "Y \\sim \\mathcal{MN}(0, XUX^{T} + \\Sigma_{AR1},I), \n", + "$$\n", + "\n", + "and the RSA correlation is given by dividing the RSA covariance $U$ by the featurewise variances. BRSA relies on a number of linear algebra tricks to speed up estimation, and similar tricks for the matrix-normal setting are availble in generalized form to enable MN-RSA. A more extended example is available at the [MN-RSA example notebook](https://github.com/brainiak/brainiak/blob/master/examples/reprsimil/bayesian_rsa_example.ipynb) shipped with `brainiak`: " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARkAAAEACAYAAACHyQJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAApBklEQVR4nO3de1wU9f4/8NcuiIKkaIEuQmqWpBmCciLvCQh44aI+SAsvPxXIUtM6FtjXRFArtGNqmmhpnTxmZuh6A0VEM2+EipmKl0NiyPUImOYN3Z3fH8jEyl4+u7Mz7C7v53nM48jM7Hs/28rbz3w+M5+3jOM4DoQQIhJ5YzeAEGLbKMkQQkRFSYYQIipKMoQQUVGSIYSIipIMIURUlGREdO3aNXh5eeHhw4eSvu/48eOxZcsWSd/TUs2bNw+rVq1q7GY0aVafZHbv3o2oqCj4+PigT58+iIqKwsaNG2ENt/8EBATg6NGjgmJ8/vnnmD17tsmvz8nJwfPPPw9fX1/4+voiJCQEaWlpGudkZWUhIiICvXr1gr+/PyZMmICioiKNc4qKivD8888jMTFR7/vVJd7IyEiN/VVVVejRowcCAgKY2r1161a89tprBs9LTk7GtGnTmGIScVh1klm/fj0WLVqEKVOm4PDhwzh69CiSkpJw6tQpPHjwQOtrVCqVxK00nVQ9IDc3N+Tl5eHUqVP44IMP8OGHH+L3338HAFy9ehXx8fFISEjAyZMnsX//fkRHR8POzk4jxvbt29G6dWtkZGSgpqbG4HvevXsXly5d4n/etWsXOnToYNbPZU3ftS2z2iRz69YtrFixAomJiQgNDYWzszNkMhm6d++Of/3rX3BwcAAAJCQkIDExEbGxsfDx8UFOTg4KCgowfvx4+Pn5Yfjw4di/fz8f9/FLjcf/xfTy8sKmTZsQHBwMPz8/JCUl8b0mlUqFlJQU+Pv7IzAwED/99JPO9r/33nsoKSnB1KlT4evriy+//JL/V37Lli145ZVXMHHiROTk5GDgwIEar63rAR06dAhr1qxBRkYGfH19ER4ezp9TXFyMsWPHwtfXF5MnT0ZVVZXB/6YymQyDBg1C69atcfHiRQBAfn4+PDw80KdPH8hkMjg7OyMkJATu7u786ziOg1KpxMyZM2Fvb4/s7GyD7xUREYFt27bxPyuVyga9m7Vr1yIoKAi+vr4YNmwY9u3bBwAoKChAYmIiTp8+DV9fX/j5+QHQ/l0nJCTgs88+4+NFRUXxyfu7777D8OHDcf/+fYPtJaaz2iSTl5eHmpoaBAYGGjx3165dmDp1Kk6dOgVvb29MnToV/fr1w9GjRzF37lzMnj2b/5ebxcGDB/Hjjz9ix44dyMjIwM8//wwA+OGHH3DgwAEolUqkpaVhz549OmMsWbIE7u7uSE1NRV5eHmJjY/ljubm5SE9Px7p16/S2Y+DAgXjjjTcwdOhQ5OXlYceOHRqf+eOPP8axY8fw4MEDrF+/3uDnUqvV2L9/P6qrq9GxY0cAwAsvvIDff/8dH330EY4fP47bt283eN3JkydRVlaG4cOHY+jQoVAqlQbfKzw8HOnp6VCpVPjvf/+LO3fuoGfPnhrneHp6YuPGjTh58iSmT5+O9957DxUVFejSpQuSkpLg4+ODvLw8nDhxQuNz133XvXv31ogXExMDBwcHrF69GoWFhfjss8+wZMkSNG/e3GB7iemsNslUV1ejTZs2sLe35/eNHTsWfn5+8Pb2Rm5uLr8/MDAQvXv3hlwux4ULF3Dnzh3ExcXBwcEBffr0weDBg7F7927m946NjUWrVq3g7u4Of39/XLhwAQCQkZGBiRMnQqFQwMXFBW+88YZJn23GjBlwcnJCixYtTHo9AIwaNQqdO3dGixYtEBoaivz8fJ3nVlRU8P/dpk+fjoSEBHTv3h1A7S/6hg0bUF5ejlmzZuHll19GQkKCRrLZtm0bBg4ciNatW2PEiBH4+eefUVlZqbd97du3R+fOnXH06FEolUpEREQ0OGfo0KFo164d5HI5hg0bho4dO+LMmTN649b/rh9PHnK5HCkpKdiwYQPefPNNxMTE8J+TiMdqk4yLiwuqq6s1xi2+//57nDhxAi4uLlCr1fx+hULB/7miogLt27eHXP73R3d3d0d5eTnze7u6uvJ/dnR05H/hKioqNN6r/iWFMdq3b2/S6+p7vI137tzRea6bmxtOnDiBU6dOYfz48Th+/LjGcR8fHyxfvhzHjx/Hxo0bkZubi9TUVADAvXv3sGfPHoSFhQEAfH19oVAosHPnToNtjIyMxLZt27B7926tSaYu+fj5+cHPzw+XL19GdXW13pj1//tr4+HhAX9/fxQXFyM6OtpgG4lwVptkfH194eDgoDGewsLNzQ1lZWUaSai0tBTt2rUDUPsLeffuXf7Y9evXmWO7urqitLRUI64pZDIZ/2dHR0fcu3eP/1mlUmmMr9Q/VygHBwfMnj0bly5dQlZWltZzvL29ERwcjMuXLwMA9u3bh7/++gtJSUno168f+vXrh/LycqZLpuDgYBw8eBAeHh4NEnJxcTHmzp2LDz/8EDk5OThx4gSee+45/ripn/vgwYPIy8tDnz59sHjxYpNiEONYbZJp1aoVpk2bhqSkJOzZswd//fUX1Go18vPzNZLE47y9vdGiRQt89dVXePDgAXJycpCdnY1hw4YBALp164Z9+/bh7t27uHr1Kn788UfmNg0dOhQbNmxAWVkZ/vzzT6xdu1bv+U899VSDqeDHde7cGffv38fBgwfx4MEDrF69WmP25sknn0RxcbFG0hTCwcEBkydP5u8tOXHiBH744Qf+8qegoADZ2dn8+IlSqcTo0aOxc+dOKJVKKJVKbNq0CRcuXOAHj3VxcnLCv//9byxatKjBsbt370Imk6Ft27YAgLS0ND6x1X3u8vJyppmsOlVVVZg7dy4WLVqETz75BNnZ2XoH54l5WG2SAWrHRhISEvDVV1+hX79+6Nu3L+bNm4fZs2fD19dX62scHByQmpqKQ4cO4eWXX0ZSUhIWL16MLl26AAAmTpyIZs2aoW/fvoiPj+cvA1i8+uqr6N+/PyIiIjBy5EgEBwfrPT8uLg6rV6+Gn5+fzkHeJ554AomJiZg7dy4GDhwIR0dHjcup0NBQAIC/vz9GjhzJ3FZ9Ro8ejZKSEmRnZ6NVq1bIzs5GWFgYfH19ERsbi6CgIMTExKC8vBzHjh3DxIkT4erqym89evTAgAEDmHozL774Ip5++ukG+5999llMnjwZY8eORd++fXHp0iX06tWLP/7yyy/j2WefRf/+/eHv78/0uebNm4eAgAAMGjQIbdq0waJFi/B///d/Bi/BrEFKSgoCAgLg5eWlcWtAfSqVCklJSQgKCsKQIUM0ZlH1HROMI4RYvdzcXK6kpIQbPHgwd/HiRa3nbNu2jZs8eTKnUqm4yspKbsCAAVxRUZHBY0JZdU+GEFLLz8/P4KB3eno6oqKiIJfL0bZtWwQFBfG3Weg7JpS94VMIIY3l5s2buHnzZoP9rVq1QqtWrYyKVVpaqjHArlAoUFZWZvCYUJRkCJEQp1ZBJrczfOIjDg4OGDVqFP7880+N/dOnT8eMGTPM3TxRUJIhREIyuR0eVheBUxl+Lk1mZ48WbTyxffv2Bs9hGduLAWp7JyUlJfD29gag2XvRd0woGpMhRGLcwxpAZXjjHtZOzysUCnh4eGhspiSZ0NBQbNmyBWq1GlVVVcjKykJISIjBY0JZVJK5cuUKxowZg5CQEIwZMwaFhYWCY1ZXVyM2NhYhISEICwvD9OnTmR4WNMbKlSv1Th0a6/79+0hMTERwcDDCwsLw4YcfmiUuABw4cACRkZGIiIhAeHg4MjMzTYqja8pU6HeoLa65vkND07zm/h514jhArTa8GbFcycKFCzFw4ECUlZVh0qRJGD58OIDa2zx+++03ALUPpXp4eCA4OBivvvoqpk2bBk9PT4PHzPB5Lcf48eM5pVLJcRzHKZVKbvz48YJjVldXc8ePH+d//uSTT7g5c+YIjlvn7Nmz3JQpU/ROHRprwYIF3KJFizi1Ws1xHMf973//M0tctVrN+fn58e3Mz8/nfHx8OJVKZXQsXVOmQr9DbXHN9R3qm+YV43vU5X5JPne/6IzhrSRf1HZIxWJ6MpWVlTh//jxGjBgBABgxYgTOnz8vuNfh4uKicbOWj48PSkpKBMWsU1NTg+TkZMyfP98s8QDg9u3b/LIJdbfOP/XUU2aLL5fLcevWLQC1y2W4ublpPMfFStuUqTm+Q21xzfUd6prmFeN71ItTs282wGIGfuueH6pbDMnOzg5ubm4oLS3lby0XSq1WY9OmTcyrrxmyfPlyhIeHw8PDwyzxgNoV5lxcXLBy5Urk5OSgZcuWmDlzJr9mihAymQzLli3DW2+9BScnJ9y+fdvgow/GsMbvEBDne9RLrQbUDAtqydhnoSyZxfRkpLBgwQI4OTlh3LhxgmPl5eXh7NmzeP31183Qsr+pVCoUFRWhe/fu2Lp1K2bPno0ZM2bgr7/+Ehz74cOHWLNmDb744gscOHAAq1evxqxZs7SuEWOpzPkdAuJ9j/qx9mJsoydjMUlGoVCgvLycn6pTqVQNlk4QIiUlBVevXsWyZctMujx4XG5uLgoKChAYGIiAgACUlZXxy4AKoVAoYG9vz19y9OzZE23atMGVK1cEtzk/Px8VFRX8Yk69e/eGo6MjCgoKBMcGrO87BMT7HvViGfSt22yAxSSZJ598Et26dcOuXbsA1K5w1q1bN7N0s5cuXYqzZ89i1apV/LKcQsXFxeHw4cPIzs5GdnY22rdvj3Xr1qF///6C4rZt2xb+/v44cuQIgNrZmsrKSn6lOiHat2+PsrIyfhXAgoICVFZWan1A0RTW9h0C4n2P+nAcB45TM2yWvxg+CxlnQZ+koKAACQkJuHnzJlq1aoWUlBQ888wzgmJevnwZI0aMQKdOnfiV5jw8PMxeJiMgIACpqano2rWr4FhFRUX44IMPcOPGDdjb22PWrFkYNGiQGVoJ7NixA19++SU/qPz2228jKCjI6DgLFy5EZmYmrl+/jjZt2sDFxQW7d+8W/B1qi7ts2TKzfIe62lyfOb9HXe5fOQk8ZFhX2L45mnfubfg8C2dRSYaQpuB+wXHgAUOSadYczbu8LH6DRGYxs0uENBkcxzY9bSP//lOSIURqrIO6NjLwS0mGEKmx3mhHN+MRQkzSxHoyFjOFDdQu0PP5559rXaTHUmNbW1wxY1tbXLFj68SpwXEqg5ut9GQsLsmsXLlStL9MYsS2trhixra2uGLH1q1p3fFLl0uESE2lAhgWrYKK4fkmK0BJhhCpqVVsD0iynGMFKMkQIjWaXWo8dnZ26NChA79UgDXEtra4Ysa2trhix9aJY5xdspEkQ48VECKx+6d2gLtveHkNWfOWaN4rXIIWiavRezIPqq9pXHs2e7IjHlRebXBe/rCG9ZKN5Z2zFmf84wTHsfa4Ysa2trhCYzdTPIluyo+Ne1ETu09GcJK5cuUKEhIScOPGDbi4uCAlJQWdOnViD6BWAerHRtof/xlAzbUKYQ01cxxrjytmbGuLK3bsBkRKMiy/i++//z4uXrzI/3zx4kWsWrUKgYGB+Pzzz/Hdd9/Bzc0NANCrVy8kJiYa1QZtBCeZxMREvP7664iIiMD27dsxb948fPvtt4IbRoit4tQPwakeGD5Ryz+2+rD8Li5evJj/84ULFzBx4kQMGDCA3xcZGYn4+Hij3tcQQTfjibX4NyE2zciFxEtLS3Ht2jWN7fGbB035Xfzxxx8RFhZm1kXAtBHUk5Fi4WhCbI6Rl0vR0dEoLi7WOPR4mVpjfxdramqwc+dOfPPNNxr7d+/ejcOHD8PV1RUzZsyAr6+vkR+uoUYf+G32ZMNlJZu5dmmwz69YaZb3M1cca48rZmxriyt27AaMXE9m48aNZilTW19WVhbc3d3RrVs3ft/YsWMxdepUNGvWDEeOHMFbb72F9PR0tGnTRtB7CUoy9ReOtrOzM2nh6AeVVzWuPZu5dsGD/zVc2PpXn38KaSqA2r9IJzpECo5j7XHFjG1tcYXGdvBwg3eOkWVljOzJsPw+Gfu7mJaWhtGjR2vsc3V15f/cr18/KBQKXL58GS+99JLhtuohaExGzIWjCbFZIhR3M+Z3saysDCdPnkRYWJjG/vLycv7P+fn5KC4uRufOnU38kH8TfLk0f/58JCQk4IsvvuAXjiaE6KFSAQ/N/4Ckrt/F2NhYvP3223jxxRcBANu2bcPgwYPRunVrjdcvXboU586dg1wuR7NmzbB48WKN3o2pBCeZLl26YMuWLSa/Pn/YIo17FPyKlVovjXqe/hdzTHNcWhEiGpGeXdL1u/jll19q/Pzmm29qfb1YHYRGH/glpMmhO34JIaKip7AJIaLiOMansG3j2WVKMoRIjXoyhBBR0ZgMIURUKhXb9DSt8UsIMQmNyRBCREWXS4QQUdHALyFEVNSTsUzGPCqg7xEEbcfoMQQiKQ5s4y22MSRjPUmGEJvRxEqiUJIhRGqqh4xlao1b49dSUZIhRGKcmgOnZrgWYjnHCghKMtXV1Xj//ffxxx9/wMHBAR07dkRycjItWkWIPk3sPhlBK+PJZDLExMRg79692LlzJzw9PfHpp5+aq22E2CYRVsazZIKSjIuLC/z9/fmffXx8UFJSIrhRhNg0Nce+2QCz1cJWq9WYPHkyAgICMGHCBHOEJMQm3f1mLrhbhmuTyZ5oC8f/t1CCFonLbAO/CxYsgJOTE8aNG2fU6874xzVYflPoqvS67pMRqxJCU1uh35biCo1tWrUCxjEZG+nJmCXJpKSk4OrVq0hNTYVcLugKjBDbp2Z8Cltt3FPYLLWw9dW7vnv3LubMmYNz587Bzs4O8fHxGDx4sFFt0EZwklm6dCnOnj2LtWvXil7ukhCbwDreYmRPhrUuva561+vWrYOzszP27duHwsJCREdHIzMzEy1btjSqHY8T1O24fPky1qxZg4qKCowdOxYRERGYNm2aoAYRYvMspBb24zIyMjBmzBgAQKdOndCjRw8cOnRI8McV1JN57rnncPHiRcGNMDddYyxUboVYBCN7Muauha2r3nVJSQk6dOjAn6dQKFBWVmbSR6yP7vglRGIcx4Ez4mY8c9bCFqvetT6UZAiRmpE9GXPWwtZX79rd3R3FxcV8z6e0tFTjPjhT0VQQIVJrxFrY+updh4aGYvPmzQCAwsJC/PbbbxgwYIDQT0s9GUIkp1IBD82/kDhLLWx99a6nTJmChIQEDBkyBHK5HMnJyXB2djb64z2OkgwhUlOD8XLJuLAstbD11bt2cnLCihUrjHtTBpRkCJEarfFLCBGVSDfjWSpKMoRIjFOr2aawaSFxQohJOMaejI0sWkVJhhCpqdSMZWqpJ2MzzFFuhUqtEGY0JkMIEVPtYwV0uUQIEUsT68mY7bGClStXwsvLC5cuXTJXSEJsU12ZWpbNBpilJ3Pu3DmcPn1a4zFxQogO1JMxTk1NDZKTkzF//nwzNIeQJoADW6UC28gxwqsVLFmyBO7u7oiOjkZAQABSU1PRtWtXc7WPEJtzK2E8uMpyg+fJnmyHJz7ZIEGLxCXocikvLw9nz57F7NmzTY4hRrUCXcSqhGBtVRDEjG1tcYXGNr1aAV0uMcnNzUVBQQECAwMREBCAsrIyTJkyBYcPHzZX+wixOXW1sFk2WyCoJxMXF4e4uDj+Z7pcIoQBPVZACBGVGmxrxdjGDLZ5k0x2drY5w1kkbeMsVAWBGIXxUkhGl0uEEJM0sYFfSjKESIxTAdxDwwmEM26JX4tFSYYQqYk0JsNSC3vVqlVIT0/nFxJ/5513+IoECQkJOHr0KF+DKTQ0FG+++aZxjdCCkgwhEmOdnjZ2CpulFra3tzcmT54MR0dHXLhwAePGjcPhw4fRokULALUzxuPGjTPqfQ2hukuESI3D370ZfdujHGPOWtgDBgyAo6MjAMDLywscx+HGjRsifdBa1JMhRGLGFiswdy3sOkqlEk8//TTat2/P7/v666+xefNmeHp64p///Ce6dOli5KdriJIMIVIzckzGnLWw6/zyyy9Yvnw51q9fz+9755134OrqCrlcDqVSiZiYGGRlZfGJy1R0uUSIxIytUqtQKODh4aGxPZ5k6tfCBqCzFjZQ+8zhe++9h1WrVuGZZ57h97dr1w5yeW1KiIyMxJ07d1BWVib481KSIURitVPYDJsRU9istbDPnDmDd955BytWrMALL7ygcax+neyff/4Zcrkc7dq1M/2DPkKXS4RITKwCkiy1sJOSknDv3j3MmzePf93ixYvh5eWF+Ph4VFZWQiaTwdnZGatXr4a9vfAUQUlGRFQFgWgjVpJhqYWdlpam8/XffPONcW/IiJIMIZKTAZyM7TwbQEmGEKkx9mToKexH7t+/j48++gjHjh1D8+bN4ePjgwULFpijbYTYpNrLJcO9FGMvlyyV4CSzZMkSNG/eHHv37oVMJsP169fN0S5CbJZYYzKWSlCSuX37NpRKJX766SfIZLWZ+amnnjJLwwixVWq1DGqV4Z6MjKG3Yw0EVSu4cOECpk+fjiFDhiAnJwctW7bEzJkz4efnZ842EmJTSsJfh6rUcLUCO0U7uO/4ToIWiUtQT0alUqGoqAjdu3dHfHw8fv31V0ydOhX79u2Ds7MzUwxrq1YgVlwpqyAAlv3fQsq4QmObUq2A49iW77WRJX6F3fGrUChgb2/PP/nZs2dPtGnTBleuXDFL4wixRZxaxrzZAkFJpm3btvD398eRI0cA1C6aU1lZiY4dO5qlcYTYJI4xwTDdS2P5BM8uJSUl4YMPPkBKSgrs7e2xePFiwU+IEmLLmtrlkuAk4+npiQ0brL+UZmOjKghNh1olh1pl+CKC5RxrQHf8EiIxuk+GECIqNSeDmmG8heUca0BJhhCJcQA4hgRiI0MylGQIkRzr9LSNTGFTkiFEYjS7RAgRFeuNdrZyMx4lGUIkplLLoVIbnp6WM5xjDSjJECKx2oFftvNsgW2kSkKsCPdoCtvQxjIDVd+VK1cwZswYhISEYMyYMSgsLGxwjkqlQlJSEoKCgjBkyBCNNYH1HROCejKESIxjTCDGJhmWWtg7d+7EH3/8gczMTNy4cQORkZHo06cPPDw89B4TgpKMFTJHFQRdxx5ezjGpTfW9sOVVQa8/F/WD4DZYMmNnl0pLS7VWkKz/jGBdLeyvv/4aQG0t7AULFqCqqkqj9lJ6ejqioqIgl8vRtm1bBAUFYc+ePYiJidF7TAhKMoRIzNg7fs1ZC7u0tBTu7u78zwqFgq8Sqe+YEJRkCJFYbU+G5XKp9v/FqIUtJUoyhEhMzcmgMqIno62e9ePq18K2s7PTWQtboVCgpKQE3t7eADR7L/qOCSF4dunAgQOIjIxEREQEwsPDkZmZKbhRhNgylpkl1kuqOqy1sENDQ7Flyxao1WpUVVUhKysLISEhBo8JIagnw3Ec3n//fWzcuBFdu3bFhQsX8NprryEoKAhyOc2OE6INB8bZJSMrSLLUwo6IiMCvv/6K4OBgAMC0adPg6ekJAHqPCSH4ckkul+PWrVsAgFu3bsHNzY0SDCF6qMFWHNLY5WRYamHb2dkhKSlJ6+v1HRNCUEkUADh27BhmzZoFJycn3L59G2vXroWPj4+ZmkeI7cn5x1u4X/Q/g+c193SFf+4XErRIXIJ6Mg8fPsSaNWvwxRdfoHfv3jh58iRmzZqF3bt3o2XLlkwxqCSKuHF13Sejq9yK0PtkHPu+jrtHhdUK0nafjKX+vTC1JIq6CT2FLei6Jj8/HxUVFejduzcAoHfv3nB0dERBQcO/vISQWmrImDdbICjJtG/fHmVlZfj9998BAAUFBaisrMTTTz9tlsYRYotUkDFvtkDQ5ZKrqyvmz5+PmTNn8rWwP/roI7i4uJijbYTYJA4yppkjY2eXLJXg2aXw8HCEh4eboy1EBLrGWJq5dtF6zP45f8GxiX4c2GaObGRIhu74JURqYk1hWypKMoRIjAPbpRD1ZAghJlHL2AoR2MgSv5RkCJEa6/S0rUxhU5IhRGJqACqDZ9GYDCHERGrIoJZRT4YQIhIObIO6NPBLCDEJTWETQkTFMc4uGVmswGJRkiFEYjS7RJo0Yx4V0PUIgrb99AjC31Sy2o3lPFtASYYQidGzS4QQUTW12SWD68mkpKQgICAAXl5euHTpEr+fpe4uIaShuscKWDZzuXv3LmbNmoUhQ4YgNDQUBw4c0HpeVlYWRo0ahREjRmD48OFYv349f2zr1q3w8/NDREQEIiIiMG3aNKb3NtiTCQwMxIQJExAdHa2xn6XuLiGkocaYwl63bh2cnZ2xb98+FBYWIjo6GpmZmQ2WyXV1dcXq1avRrl073Lp1C6NGjYK3tzf8/PwAAH379sWKFSuMem+DPRk/P78GBaLq6u6OGDECQG3d3fPnz6OqqsqoNyekKVIbsQG1RdauXbumsd28edOo98zIyMCYMWMAAJ06dUKPHj1w6NChBuf17NkT7dq1AwA88cQT6NKlS4MSucYyaUyGte4uC22LMPsVK01pFhOxYltbXKB20W8xNHPtwrRPF79i7e2yxr8XWskY74F5dA5LLWxDSkpK0KFDB/5nljrXBQUFOH36tEaZlF9++QURERFwdnZGbGwsXnnlFYPv3egDv1StQNy4L2x5Vet+c1QV0DZVbY4qCLZereDho43lPICtFvbIkSNRUlKiNc7Ro0eNah8AVFRU4K233kJiYiLfs3nllVcwbNgwtGjRAufPn0dsbCy+/fZbdOmi/x8Qk5IMa91dQkhDxs4usfxebdu2Te9xd3d3FBcX81capaWl8PfXfp9TZWUlJk2ahJiYGAwdOpTfX/8qpXv37ujVqxfOnDljMMmYVK2Ate4uIaShxphdCg0NxebNmwEAhYWF+O233zBgwIAG51VXV2PSpEmIjo5GVFSUxrHy8nL+z8XFxTh9+jS8vLwMvrfBnszChQuRmZmJ69evY9KkSXBxccHu3bt11t0lhOjXGDfjTZkyBQkJCRgyZAjkcjmSk5Ph7OwMAFi+fDnc3Nzw2muvYe3atSgsLMTmzZv5pDRhwgSMHj0aGzduxP79+/mx2HfffRfdu3c3+N4Gk8zcuXMxd+7cBvt11d0lTYe2cRZzVEEAGo7J2JLGmMJ2cnLSOfU8c+ZM/s/x8fGIj4/Xet67776Ld9991+j3bvSBX0KamqZ2xy8lGUIkRguJE0JERWv8EkJEpQYHNcPFEMs51oCSDCESo+U3CSGiooFfQoioaNEqQoioaHaJECIqGvglhIhKBbYpbJZzrAElGRunbdkEoHbNFl3HhNAdl/29ep7+F/P+X33+yRzXUnCMPRmOejKEEFPQ7BIhRFRN7T4ZpvVktFUsqK6uRmxsLEJCQhAWFobp06fTGr+EMKhNMhzDZhuYkkxgYCA2btyosUaoTCZDTEwM9u7di507d8LT0xOffvqpaA0lxFZwRmy2gCnJaKtY4OLiorF8n4+Pj841Rgkhf6u7Gc/QZitJxixjMmq1Gps2bUJAQIDRr6VqBY0TV8zYYsXVVvHAXO8lZbUCFTioGFIIyznWwCxJZsGCBXBycsK4ceOMfi1VK5A+rpixzRFX21S1rioI5pjClrpaAd2MZ6SUlBRcvXoVqampkMtNWpeckCaFprCNsHTpUpw9exZr166Fg4ODudpEiE1rjJvx7t69izlz5uDcuXOws7NDfHw8Bg8e3OC8nJwcxMXFoVOnTgAABwcHjbW8V61axZdfGTlyJFM9bKYko61iwbJly7BmzRp06tQJY8eOBQB4eHhg1apVLCEJabIsuRY2UFskYOvWrQ325+bmYs+ePXwppKioKLz00kv4xz/+ofe9mZKMrooFFy9eZHk5IUbRNs7iV6zUul/XIwjGxJYa9+h/LOcBtYXYtFWQfLyKpD4ZGRn45JNPAGjWwq5fvM2Q9PR0REZGokWLFgCAyMhIpKenmyfJEELMx9jZJalrYRcWFmLkyJGwt7fH66+/jpEjRwKoTXYvvfSSRozc3FyD701JhhCJGbtolZS1sF944QX89NNPeOKJJ1BUVIRJkyahXbt26Nu3L3OMx1GSIURiao6DmmOYwn50jpS1sOuqSgKAp6cngoKCcOrUKfTt2xcKhUIjkZWWljK1jeacCZFYYzxWwFoLu6KiAtyj5Hbjxg0cOXIEzz//PB9DqVTi3r17uHfvHpRKJdOYDvVkCJFYY9yMx1oLOzMzE5s2bYK9vT1UKhUiIyMRFBQEAPD390dwcDCGDx8OoHbgt/4YjS6UZAiRWG0vhWV2yXxYa2GPGzdO7537M2bMMGrAGaAkQ4jkqFoBIURUKqihYkgzLOdYA0oyhEisqa2MR0mGEIlxHMfP4Bg6zxZQkiFEYlStgBArYuyzSJZQboUulwghojL2AUlrR0mGEIk1tZXxTC6JUt/KlSt1HiOEaFJzHFQMG8vzTdbA5JIodc6dO4fTp09rPUYIaajujl/D/7MNJpdEAYCamhokJydj/vz55m4XITaLrbAb2yWVNRA0JrN8+XKEh4fDw8PD5BhUEqVx4ooZ29riAuKWW3kc3SfDKC8vD2fPnsXs2bMFNYBKokgfV8zYlh7X3OVWqCSKYSavJ5Obm4uCggIEBgYiICAAZWVlmDJlCg4fPmzO9hFig1hHZGwjyZjck4mLi0NcXBz/c0BAAFJTU9G1a1ezNIwQW2XsynjWjqkns3DhQgwcOBBlZWWYNGkSv2gNIcR4dQuJs2y2QFBJlPqys7PN0iBCxGT2city4y8GmtqYDN3xS4jUOMaZI9vIMZRkCJEa9WQIIaJqjAckWWthf/vtt0hLS+N/LioqQlRUFObMmWOwTrYulGQIkVhj3IzHWgt7woQJmDBhAgDgwYMHGDhwIEaMGMEf11UnWx+qu0SIxIx9rKC0tBTXrl3T2G7evGnUe2ZkZGDMmDEANGth63PgwAG4urrixRdfNO2DPkI9GUIkpoYaKs7wklTqR8tWSV0Lu05aWhpGjRqlsU9XnWx9KMkQIjFjx2SkrIVdp6KiAsePH8fHH3/M7zO1TjYlGUIkpubY7uZVPzpFylrYdZRKJQYNGsSfD+ivk60PjckQIjG2J5fMu6IMay3sOmlpaRg9erTGPn11svVp9J5MM8WTDfY5eLiJ9n5ixba2uGLGtra4OmOz3M0rtzP6vRrj2SXWWtgAcPLkSdy5cwf9+/fXiKGvTrY+Ms5WFq0gxEoE9g5HcVGpwfM6eCqw/+QOCVokLou6XCotLUVAQABKSw1/AZYS29riihnb2uKKHVuXup4My2YLGv1yqT6VSoXi4uIGI+mWHNva4ooZ29riih1b53tybFPYLOdYA4tKMoQ0BVR3iRAiqtrHCgz3UmxluJSSDCESo1rYjahVq1aYPn16g7sZLTm2tcUVM7a1xRU7ti5NrVoBTWETIrGXewbjWpH2RwDq8/B0x/FfMyVokbgsqidDSFOg4tRQqWl2iRAiGtZHBmzjIoOSDCES4xjX+LWVgQxKMoRIjNb4JYSIqqnNLlGSIURiTa2CJCUZQiRGPRlCiKjUjA9IqmkKmxBiCrpcIoSIigPbc0m2kWIoyRAiOerJEEJExjbwayt9GYtafpOQpqAxqhVs374dYWFh6N69O/7zn//oPfeHH37AkCFDEBQUhOTkZKjrPWel75gulGQIkVjdFDbLZi7dunXDZ599plHXWpuioiKsXLkSmzdvRmZmJq5evYodO3YYPKYPXS4RIjF39/ZM4y3u7u0B1C52rq2CpDFr4HTt2hUAIJfr71fs3bsXQUFBfFG3qKgobN26FZGRkXqP6UNJhhCJ/XRQyXzuvXv3EBERgT///FNjv7G1sFmVlpbC3d2d/9nd3Z2v5KDvmD6UZAixYDU1Ndi6dWuD/cbWwrazM74InblQkiHEgrFeFhmqhc1KoVBoJKuSkhK+Fre+Y/rQwC8hhBcSEoKsrCxUVVVBrVZjy5YtGDp0qMFj+tAav4Q0Abt27cLixYtx8+ZNNGvWDI6Ojli/fj2effbZBrWwv//+e3z11VcAgH79+mHevHn85Za+Y7pQkiGEiIoulwghoqIkQwgRFSUZQoioKMkQQkRFSYYQIipKMoQQUVGSIYSI6v8DIcFlHezxkCMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# make a fake RSA matrix\n", + "conditions = 16\n", + "groundtruth_U = np.zeros([conditions, conditions])\n", + "groundtruth_U = np.eye(conditions) * 0.6\n", + "groundtruth_U[8:12, 8:12] = 0.8\n", + "for cond in range(8, 12):\n", + " groundtruth_U[cond, cond] = 1\n", + "groundtruth_C = cov2corr(groundtruth_U)\n", + "plt.matshow(groundtruth_C, vmin=-1, vmax=1)\n", + "plt.title(\"Ground truth RSA Matrix\")\n", + "plt.colorbar()\n", + "\n", + "# synthetic data\n", + "B = rmn(groundtruth_U, space_cov._cov) # now B is RSA-structured, rest is as above\n", + "X, _ = make_friedman1(n_samples=TRs, n_features=conditions, random_state=None)\n", + "noise = rmn(rowcov=true_time_cov._cov, colcov=true_space_cov._cov)\n", + "Y = X @ B + noise\n", + "\n", + "rsa_cov = CovUnconstrainedCholesky(size=conditions)\n", + "\n", + "params = (\n", + " rsa_cov.get_optimize_vars()\n", + " + time_cov.get_optimize_vars()\n", + " + space_cov.get_optimize_vars()\n", + ")\n", + "\n", + "# note the loss now includes a marginal logp term, plus the likelihoods of the various covariances in question\n", + "def loss(params):\n", + " return -(\n", + " time_cov.logp\n", + " + space_cov.logp\n", + " + rsa_cov.logp\n", + " + matnorm_logp_marginal_row(\n", + " Y, row_cov=time_cov, col_cov=space_cov, marg=X, marg_cov=rsa_cov\n", + " )\n", + " )\n", + "\n", + "val_and_grad = make_val_and_grad(lossfn=loss, train_vars=params)\n", + "\n", + "x0 = pack_trainable_vars(params)\n", + "\n", + "opt_results = minimize(fun=val_and_grad, x0=x0, jac=True, method=\"L-BFGS-B\")\n", + "\n", + "fit_params = unpack_trainable_vars(opt_results.x, params)\n", + "\n", + "for var, val in zip(params, fit_params):\n", + " var.assign(val)\n", + "\n", + "U = rsa_cov._cov.numpy()\n", + "C = cov2corr(U)\n", + "plt.matshow(C, vmin=-1, vmax=1)\n", + "plt.title(\"Estimated RSA Matrix\")\n", + "plt.colorbar()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, this model is available in `brainiak` directly as `MNRSA`, where it incorporates nuisance regressors as well: " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_matnorm = MNRSA(time_cov=time_cov, space_cov=space_cov, n_nureg=3)\n", + "\n", + "model_matnorm.fit(Y, X)\n", + "plt.matshow(model_matnorm.C_, vmin=-1, vmax=1)\n", + "plt.title(\"Estimated RSA Matrix\")\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Example 3: latent design matrices with PCA and FA\n", + "The true benefit of a shared framework comes when starting to see the commonalities among methods. For example, consider what happens if the known design matrix $X$ is replaced with an unknown latent time series $S$, yielding the following model: \n", + "\n", + "$$\n", + "Y \\sim \\mathcal{MN}(SB, I, I). \n", + "$$\n", + "\n", + "In this model, we no longer know the design matrix, and the brain volume is now a weighted sum of unknown time series, with unknown weights. It turns out that this is precisely the model for probabilistic PCA, and there is nothing stopping us from implementing it in our framework. However, note that PCA has uniquely many solutions, so while doing naive gradient descent on this problem might work in toy examples, it isn't a particularly realistic example. To find a unique solution, we can integrate over either $S$ or $B$ using a matrix-normal prior. We choose to integrate over $S$, since it is a larger matrix in this case and this lets us estimate fewer parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate data\n", + "components = 5\n", + "voxels = 100\n", + "TRs = 50\n", + "\n", + "S = np.sin(\n", + " np.arange(TRs)[:, None] @ np.random.randn(1, components)\n", + " + np.random.randn(1, components)\n", + ")\n", + "plt.plot(S) # random sinewaves with noise\n", + "plt.title(\"Simulated latent response\")\n", + "plt.xlabel(\"TRs\")\n", + "B = np.random.randn(components, voxels)\n", + "Y = S @ B + np.random.randn(TRs, voxels)\n", + "plt.figure()\n", + "\n", + "plt.plot(Y[:, :10])\n", + "plt.xlabel(\"TRs\")\n", + "_ = plt.title(\"Simulated voxel time series (first 10 voxels)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEdCAYAAADn46tbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABqJklEQVR4nO3dd3zV9b348dd3nZ1NAmEIgopYlSVuAVEUK2i1VWmveq1Upb9SrXpbbV1VK662zvYqvY46etvrQsWW1oGImyKKgyEzMQnZ4+zzHZ/fH9/kkJDBARIy+DwfDx8kJyff8/4m8fs+3894vxUhhECSJEmSWlF7OwBJkiSp75HJQZIkSWpHJgdJkiSpHZkcJEmSpHZkcpAkSZLakclBkiRJakcmB0mSJKmdjJJDXV0d0WgUANu2eeGFF3jppZdwHKdHg5MkSZJ6R0bJ4YorrmDbtm0A3HfffTz++OM8+eST3HXXXT0anCRJktQ7lEx2SE+ZMoWPP/4YRVGYOnUqf/3rXwkEAsyePZt33313X8QpSZIk7UN6Jk9SVRXTNNmyZQtZWVkMHToUx3HSQ02SJEnSwJJRcpg6dSpXXXUVDQ0NfPvb3wZg48aNDB48uEeDkyRJknpHRsNKqVSKl156CV3XOfvss9F1nY8++oiamhrOPPPMfRGnJEmStA9llBxaOI5DTU0NRUVFPRmTJEmS1MsyWq3U1NTEtddey5FHHslpp50GwJtvvsl9993Xo8FJkiRJvSOj5HDLLbcQCoV46623MAwDgIkTJ/KPf/yjR4OTJEmSekdGE9IffPABK1aswDAMFEUBID8/n9ra2h4NTpIkSeodGd05ZGVlUV9f3+ax8vJyCgsLeyQoSZIkqXdllBzOO+88rrzySj788EMcx2H16tVcd911zJ07t6fjkyRJknpBRquVhBA89dRT/O1vf6O8vJzi4mIuuOAC/vM//zM9zCRJkiQNHLu1lFWSJEnaP3Q6Ib1y5UqmTJkCuBPSnTnuuOO6PypJkiSpV3V65zB79myWLFkCwIwZMzr+ZkXhzTff7LnoJEmSpF6R0bCSbdtomrYv4pEkSZL6gF3uc7Btm4kTJ/Lvf/8bj8ezL2LaY/X1URynZ6dQCgpC1NZGevQ19gV5Hn2LPI++ZaCcB3R9LqqqkJcX7PBru0wOmqYxatQo6uvr+3wVVscRPZ4cWl5nIJDn0bfI8+hbBsp5wJ6dS0Y7pOfMmcP8+fO5+OKLGTJkSJuvdeeEdDKZZOHChXzwwQd4vV4mTJjA7bff3m3HlyRJkjKTUXL43//9XwAeeuihNo9394T0vffei9fr5Z///CeKolBTU9Ntx5YkSZIyl1FyeOutt3o6DqLRKIsXL2b58uXpjXWDBg3q8deVJEmS2st4E5xpmnz22WdUVVXx7W9/m1gsBkAgEOiWQNatW8eCBQuYOXMmH330EcFgkKuuuoqjjjqqW44vSZIkZS6jO4f169fz4x//GI/HQ2VlJd/+9rdZuXIlL730Evfff3+3BGLbNqWlpRx22GFcd911fPbZZ8yfP5/XX3+dUCiU0TFqayM9PolUWJhFdXW4R19jX5Dn0bfI8+hb+sp5lFaFWbW+mtqmBAXZPiaPLWREUdZuHaOrc1FVhYKCjq+vGRXe+/Wvf82VV17J0qVL0XU3n0yZMoVVq1btVpBdKS4uRtd1Zs+eDcD48ePJy8tjy5Yt3fYakiRJ/UVpVZilH5cQTZjkZ3mJJkyWflzCyrXbWbxiM4+99hWLV2ymtKpnklhGyWHjxo2cffbZAOn5gEAgQDKZ7LZA8vPzOeaYY3jvvfcA2LJlC7W1tYwcObLbXkOSJKm/WLW+moBXJ+hz++gEfQa27fDq+9vaJYyeSBAZDSsNGzaML774giOOOCL92Jo1azjggAO6NZhbb72VX/3qV9x9993ous4999xDdnZ2t76GJElSX9V6GKmkMsyBQ7JotBwq6mLEkzbRuImqCII+tyNny7+r1lfv9nDTrmSUHK666iquuOIK5s6di2maPProo/z1r3/t9j0II0aM4Omnn+7WY0qSJPUHLcNIAa9OfpaX8pooX26tR1MVgn4Dn0elttFGVaEpmiI76FasCHh1apsS3R5PRsnh5JNP5n/+53/4v//7P6ZMmUJZWRkPPfQQhx9+eLcHJEmStL9ofadQ3RAnL+RN3w2MHJzFynVVqIpCbsiLaTugCBwHPtlQzZCCAEMLgmiaQkG2r9tjyyg5ABx22GH8+te/7vYAJEmS9kc73ylsLm8iGjfxe3Wygx6ygx6Cfp1E0iaeslAVBZ+hkTRtHEeQMm3WldQzOC/A1GlDuz2+jCakn3jiCdauXQvAp59+yvTp05kxYwarV6/u9oAkSZL2BztPOGcF3H/La6Pp5wR9BgU5PiYeXIjXo5ET8uL36liOQ1VDgkjcpLI+xr9Wlnb7yqWMksOTTz7J8OHDAfjd737HJZdcwo9//GMWLlzYbYFIkiTtL0qrwqz+upoNJQ2sK6mnMZKkOD8AAsKxFEIIogmT7ICHrIBBNGESS5gkTZtYwiI/y0thjg/HETRGUmgK3b5yKaPkEA6HycrKIhKJsH79ei666CLOO+88uQdBkiRpN7UMJ+maiqYpmJbDpvImAIYWBsgKeKgLJwn6DM6dNprvThvTfHehEktY5IY8hAIewnETTVPxejS218cJ+gwCXp1V66u7Jc6M5hyKi4v55JNP2LhxI0cddRSaphGJRGQDIEmSpN207JMyttfGiCUtYgmLrICBV9coqYowpCDAf8w8pN2y1BFFWUweW8jDL36O19ARQhCPm9gCdF1he22M4vwA2UFPt61cyig5/OIXv+DKK6/E4/Hw4IMPuie4bFmbfQ+SJElS10qrwny5tY6gTycn4EFXFZpiJpbHxusxmHX0AZ3uVxhRlMVhI/MoqYrQFDWxAV1TMDQVFIVN5U0MHRRgSH7HzXt2V0bJYdq0abz77rttHps1axazZs3qliAkSZL6i72pd7RqfTUhv7tUFQWCfgOP4Y7AHDG6YJfHmTF5OEs/LmF7bQxNU2iMpLBsQUG2B0dAeU2MM48btTenl5bxUtadGYbRLQFIkiT1FzsvP40mTF5Yvon8LB+m7bRJFh0lkdqmBCMKg2yucCeNdU0BAZGEyeSxhbt8/RFFWcw6+gD+Z8laVAUG5bj7Gxwh8Hs1gn5Pt+2U3uPkIEmSNFDsfCE/9dhRhIz263VaLz8FsCyHqvo44ZjJ4Qfmp1cMTRhTwKebatskkaUfl+DVNTRNYczQ7HRJDF1TOGxkXsYX9RFFWUw8eBDRhJmOA2j3+d6SyUGSpP1aR3cDL729kenji9tdsLdVNhFP2DRGU8STJvGkDYDHUAkPzkqXtHjzkzJGFIWwLIf1VQ3pJJAf8uDx6gS8OmNH5LqT0kmLGZOH71bMk8cWsvTjEsAtn9FynKnju28zXEZLWSVJkgaqjqqfhvxGuyWhpVVhahuTNESTNEWTxJI2liOadys7rN1WT1M0RcCr0xBJYZo2m8qbMC0HBUFdU5IvttWTStlYlpNertrVJHRnWoaXgj5jr47TlYzvHN577z1ee+016urqeOSRR/j888+JRCIcd9xx3RaMJEnSvlbblCA/y9vmsYDfYP3WOhav2JweamqKphg2KMhX2+qxHbdRjuMIHAEBj1vWYktFE6bt0BBO8sFXlXgNjSy/QSRhAeAzNOrCSTweba8v5iOKsrq9EmtrGSWHp59+mqeeeorzzjuPf/7znwD4fD7uuOMOmRwkSepXdp5f0FWFWNJqM15fUROhpiGOR1doCKfYXN5EYyTFuJE5BHw6iaSFZQkEoACJlI3tWDRFUxi6SnZApyFiEk9aJFI2HkNFU1Vygh4sW6Q3q/XkxX1vZTSs9Oc//5knnniCyy+/HFV1v2X06NFyh7QkSf1KR93VGiIpqhviRBNmumxFyfYIOUGD8poYpu0Q8utoqsK6kkZUt98Zhq7g0RUEYNk72hMrQNDvwetREcL9WjJlE/TpaJqK36v1WJnt7pTRnUM0GqW4uBjY0QnOsiy5nFWSpD6vq7LYQZ8BuWDbbgOdlruJojw/DU0JDF3FcQS10RS245BI2SRSFo4DKCAEaKr7rxCguCtTqW6IAQqaqiBsgQKE4yaOIxg3Mo9Y0uqRMtvdKaPkMGXKFBYtWsSPf/zj9GNPPfUUxxxzTI8FJkmStLdWrt3Oq+9vw3YEWX734t+6LDa4q33qwkm+c9Lo9Pe9/kkZb68qxdAU6iNuITzTdnAEIMCjKzhCYNkACqoCAoGmKW5pi5Qg4NPxejQwbYQAVVHwezR0Xe32lUU9IaPkcOONNzJ//nyee+45otEop59+OsFgkEcffbSn45MkSdojpVVhXn1/GwAhv04kniIcM4kmLOKbazniwHxyQt4O38Ufd0Qxb368jdrGFI4Q6YlnXQWn+S5h6KAgjVGTRNLCY2goCtiWIGnaIMAyHXRdJS/LywFFIRqjKRqj7l6EqeOH9un5BsgwORQVFfHCCy+wZs0aysvLKS4u5sgjj0zPP0iSJPU1q9ZXYzsOWX4PCdMiHLfQm6ugJpIWa7fWoxsKpiX41qh8SqvC6Z3NH3xVRSJlk7KcNse0HDdBWLagKWqSEzCIxEw01WFQjg/LETSEk6RMG1sIhuT4OLA4m+ygh5yQmxha36H0ZRkvZVUUhfHjxzN+/PiejEeSJKlb1DYlCPkNTNshErdQVQVD0xC4ZSvC8RQeW2fCmAI0TWmzs7m2MUlBtg9HCCJxK31MBXcJq6JAPGFi2Q6qApqqkDRtckJeDhmeSzxpUVYT5aDhOQS8utuPoYuhpL2p19RTMkoO69atY+HChaxbt45YLAaAEAJFUfjiiy96NEBJkqQ9UZDtw7IcymqixJMWjiOwHdHck9mDz3A7qimKQmlVhHAsxVdb3IqpDRETu/lr4CYFQ1cwbdE8f+AOL4X8BmOH51BW614Xi/MDaJqCqinMOX4kZTWx9AW/s6GkjnZoL/24pNs3te2ujJLDNddcw2mnncaNN96Iz9e3Z9glSdo/7OrddkuJibyQh8r6GI4j0nsNGiMmSggMXWNjWSOGrmJoKpG4Scq000tTFaV5BZJwVzQZmorHUEkkLbfRjqFR1eguSY3ETVaur2Z4YZBTJg1jyrghTMngPHau19Tyb2/vg8goOdTU1HDVVVels6gkSVJvyuTddkuJiWdf30B2wEPKcsgKGAR9OomUTWPUZFCO5iYGXaUunETXVGxHgCJQlOY1qrjzDKqmkhfykBPyUl0fx7Qd1OalquGYu0ciK+BhRFGITzfVMqQgmNHFvcMd2n1gH0RGM8rf+c53ePXVV3s6FkmSpIx0VA+poxaZI4qyKMz1c/zhQ5h08CBCfoNEyiEvy4NhqKQsG111J6lN0yY35MF2BAoqXl1FUdxlqoahkuU3OHrcYHJDHqIJC9N2mlcgubuiNU3FtB2CPgPbdnj29Q089tpXLF6xucu+zgXZPmJJq81jfWEfREZ3DpdffjkXXHABjz76KAUFBW2+9tRTT3V7UA8//DAPPfQQr776Kocccki3H1+SpP5tV++2d974Zlo2Q/KD5ITc74kmTCzLoaIuRjhmkhUwGJTrQ1NV/AkLy3bnG9z9EAbF+UHqI0lKmovv+T0qjnCTSixh4vfoKKqCoSk0RpKUV8ewhcPYEbm7nEPYFxVW90RGyeHKK69k+PDhzJw5E6/Xu+tv2Atffvkln376KcOGDevR15Ekqf8qyPa161/Q8m679ZCTripE4ibbtof5JjvCQcNyMAyNWNJi1tEH8MXmGpZ+9A0NkaTbbhOB19AI+Q10TQUBQ/IDqJrCf8w8hFXrqxmUY1JaFSESS5EwHTTVvWMoCHoJBTxU1MVAgSy/J31XA53PIbQMf7WeP+kL+yAySg5r167lo48+wuPx9GgwqVSK2267jd/97ndcfPHFPfpakiT1Xzu/266qj1NWE6Ugx8u6knryQl5sW7CpvAmvoVGQ4yOWsPh8Sz1ZAR2vofHHxZ9T35RC1xRUIJY0cRzIzVIYlBukKZokmbKpqI0zZmg2sOOOZWhBkI0Ji5ygTtCrUdOYxBGQ5ddZX9qIbTtoaoCmaIrsoGeXcwg9XWF1T2SUHI466ig2bdrEuHHjejSYBx54gLPOOovhw3ev8UWLgoJQN0fUscLCvvVL3FPyPPoWeR679xp5eUE++LyCzWWNVDbEGT0sh+LCEO9/Vk7SjKHrGgGf26M54BMoShIABYWUJWgIpxDCQVF1EgkLTVdRFIglbBxHMDg/xJCCAAG/QSxu8vZnFWQFvaCqFBdl4fMbfFMZoSGSZGhhkCEFQTaVNeIxNILZPrwena2VYQ4dlY+hqRxQnNNrv+M9ed2MksPw4cO59NJLmTlzZrs5h6uuumq3X7Qjq1ev5osvvuC//uu/9vgYtbURHEfs+ol7obAwi+rqzieX+gt5Hn2LPI/dFzJUZk4axuJokpBPI+gziMdS+L0aDZEkDTUxfM21jHwejUTKJjtgUFUfx2NopCwHBYjGLXe5quUgBJjA2m31+AyVoHcIinAL56kIEgmTRssmFneb+gzO85EV0NPDQr5ReViW09zkxwYhWL+1jiEFAY46ZFCv/I67+p2oqtLpm+qMkkMikWD69OmYpsn27dv3PMourFy5kk2bNnHKKacAsH37dubNm8edd97JiSee2COvKUlS/7Jy7Xbe/KSMhkgKn0elKNdPSVWU3KCH4oIAOSEvWT6db6oiOI4DqOlyGT6PSiplkzQdLMdNBC1vJVt/3PJ5IuV2dxs3Mi89NFQXTnY6P/CvlaXkZ3lRfK16RCcsUESvb2jbE4oQomffau+hGTNm8Mgjj+zWaiV555A5eR59izyPXVu5djvPvb0JVVFIJC2iSRuBIDdoEPB5iMZTOAJiCQvbFrTaptDu4q8owE6P7UxRICfooSjPz6EH5LG9LkpDJEVhrr/DTXeLV2xuN0ne8nlv1lPq9juHb775Jj32X1pa2ukLjxgxYnfilCRpP7Y3NYTe/KQMVVGIp2ySloOmgu1AQ8SkIWzi3idAulSeQ/o5O8vkLbF792ARS5hsr4uyubyJMUNzOt1011eXpO6pTpPDnDlzWL16NQAzZ85EUdw65a0pisLatWt7JLC33nqrR44rSdK+0zoZGJpKXThBYa5/t2oItRxja0UY03bS7/hb6jUIdtwJ7JwHbGdHMx5F6ThRdMV2BKYlaIikGDM0h8H5AaDjEhd9dUnqnuo0ObQkBnAL70mSJO2OnUtcfLGljnjSIi/kjst3dIHd+c5i2KAAn26qxbYdnOZ5ghY7zxF0piUhKHsw4hzwaIwbmYdpO+RneWmKpiivdQv5+TwaQX/b5f19cUnqnsqofMZvfvObDh+/4447ujUYSZIGhtKqMM++voGtFWG+/qaBNZtqqayPk0jabNnelH7ezruaX1i+ic8311KyPcznm2t5YflmbNuhIZLCMPauf8yuSsPt/GVdBZ/HoD7iJqqq+jgbyxoxLQe/RyeetKlpiHdZGqM/y+in/eKLL3b4+CuvvNKtwUiS1P+13DGEYyl0FWqbktQ0JprH/x1qGhI0Rtw9B61rCL216huq6uMA+LwaAOFYipLtYcqqoyRTuzkmtJNdrVVRFDdBeA2VkF9nWGEIw1CJJ20mjy2krCZKyrTd8hi1URojKXKCRrt6TgNFl0tZn3/+eQBs205/3KK0tJTc3NweC0ySpP6ppSheVsBDeU2UZMpq7rXc3CxHgdUbqgkGDDRVZc7xIwHYXNGE36Nj6O57VkNX0FSVyvpEl6uKuoOigK6rIBz8Xp2CHB+OI7Bsh4DPYERRFn6vRmM0hXAEhqHi9+o0Rky2VTbt+gX6oS6Tw8svvwyAaZrpj8GdiB40aBB33313z0YnSVK/s62yiXjCprYp0aaLGrjzBLaAcMIiN8vLkIJAurw1KIid0oBp2T2eGMDtDKcpCh6PgaoqJFJutVYB1DbGWbxiMynTISfoIeDbcdmMJSziSXsfRLjvdZkcnn76aQDuu+8+rr766n0SkCRJ/de7n37D5rIwtiNwhLsDueXirrBj3F/XVXxenSH5QaIJk1XrqxkzNJt1JfUoioKhqUQTJklr32zDaoktZTkUBNyy3ZGkiaFrHDQ0m2jCpCmWwtDUdGMg03YQQhBota9hIMlozkEmBkmSdqW0Kszf3viagE9DVcHaad1oy3CREKCrSvodd8uk9MmThjE4z10qWtMYZ3tdbJ/ErQB+rzuc5QiBqrolNWwHxo7IJTfLR9BnkBvyojc3BoqnLAxdZXhhiAOK9k1Nt30to/IZkiRJu7JqfTWW7ZAT9OLz6FTWx7EdO33rkLJ2JAvLdmiMJFlXUk9uyIPf09yoRxE4jiAStzLaqNYddM2d23CEwOfR8Xl08nNUbMtJ938AGFEYZG1JAyOKQm02uU0eW7hvAt3HZHKQJKlb1DYlyAl6iCVMBAKvoZJMdTwen7IEIb8glrCoqo+TFdBxHAjHTCJxc5cri/ZWS19oBfeOxmy+y8kLeYgnbfxeHXOn7zEMjcNG5hH0GQNik9uuyOQgSVK3KMj2oekq1VtihOMmtrPz9HJbdWGLWNJBQSGetNzmOoieTwy4CUFrnmhQmidCsppXT6FATshLMmUSTZht7hL6YwG9PdVpcuiqnlJrsraSJEng1hZ6+7MKwF1l5HZOAFUFx3EvyjvvVEimnHQCsW1B16XwuoeuuyuTLNtB4OAzdA4Znk1dOEUkbnLYyDy+e+pY6uujA6YUxp7oNDl0Vk+ptZ6srSRJUt/VUZmLspoYsYRFQySFrioE/B4s2yGZskk6ToeX/daPWT19y9DMtgXCcdJDSyhQUhXlW6PyOXnSMEYUZVFYmEXIUPerZLCzTpODrKckSVJHdq6ZVFkX4/0vKhg9NJsDh+ex5utqt9NaUxKUXe9M3teEAKEIVEVBQaEg28dBw3MINm92k1y7NedQUVFBZWUlEyZM6KFwJEnq61p2QLcUzquPJFFVhY1lTZTVxEhZ9o7qp72UGFrvr2jN0BRM253X0BSFgEfDEeyyx/P+KKPkUF5ezjXXXMO6detQFIXVq1ezdOlSVqxYIYvvSdIA1lH/hdqmBLqqsK6knsZoitrGBI4jUFWFaDy122Wxu5vaqpZ369LeirKjfpKhKXgNjZBfx+/V2tR4klwZbYK7+eabmT59Op988gm67uaTE044gffff79Hg5Mkqfe0DB9FE2ab/gvJlMX60gaicZNwNIXV/E7csgVJs3fHkPJCHrL8Oj6v1ryT2Z0U11Tw6Apm845rVVHwezRURSU35BnQ+xX2VEZ3Dp9//jmLFi1CVdUdy76ysgiHB2apWkmS2g8ftfz7dXUEgKZoipTZd+oK+T0qWUGDvJAPn0ejvDZCTUMCRXV7Oaiqit8LAZ+G7bi7onOzPAzJD+5WR7r9RUbJoaCggG3btnHggQemH9u4cSPFxcU9FpgkSb2r9fBRPGmhNq9e3F4Xx2uohHcqqtebvB6VKYcWYQs4bcoIVq2vRtdVRhfnsHV7mJTlkBUwKM4PkBPy9onezn1dRsnh0ksvZf78+Vx++eVYlsWSJUt49NFHueyyy3o6PkmSekkyZbFqcx22cAfvLVukZ3pbl8LobYauMDjPj2Fo5DavOGp9F/DYa1+Rn+VNj3qAnIDOREbJ4Xvf+x65ubn87W9/o7i4mMWLF3PVVVdx6qmn9nR8kiTthY4mlHc1fFJaFWbZJ2Ws2VSLaQk0FaxeXn3UGXeTnUJxfpBY0mLq+KHtnlOQ7UvfKbSQE9C7llFyqK+v59RTT22XDEpKSjjggAN6JDBJkvbOzvsRWiaUuyoB0fI922tjzTuWWyWGPkRVwGOoOI5AwV1OG/Dt6MrW+vwmjy1k6cclAG1KYXSUSKQdMlqtNGfOHJYvX97msb/85S+cd955PRKUJEl7r/WEcjhmUloVYWtFE8++vqHTvser1lfj2IKy6gi26HM3CgAEvBo5IQ/FBUFyQ158Ho0RRSFGFAbTCbD1+Y0oymLW0QcQ9BnUhZMEfcZ+VSNpT2V053DHHXdw4403csopp/DDH/6Q22+/naqqKv785z/3dHySJO2h2qYE+VleymsirC9tRAjhbgKzRKd3ECVVETZ9U09qHzXZ2V0K4AhBynTc/RVCkB30tFtRtWp9dZtz23keQtq1jO4cpk2bxquvvsqqVauYNWsWubm5PP/88xx66KE9HZ8kSXuoINtHVX2c9aWNAHh0jaTp0BRN8XVpQ7s7iNKqMF+XNhCO953lqa2pChiGguMIdE3BEYJE0iaWSNEUTaWf1zLZXFoVZvGKzTz22lcsXrG507slqWMZJYdoNMrdd99NJBLhkksu4Z133uGll17q1kDq6+u57LLLOP3005kzZw4LFiygrq6uW19DkvYnk8cWUlYTxbYddNWtlJqyHDRNwbYdwrEdQzClVWFeWL6JWKLvLE/dmRBgqO6dT2PUJJqwAEE86bC5ojH9vFjSQleVDjfwyQSRuYyGlc466ywmTZrEK6+8QlZWFmeddRa/+MUveOutt3j00Ue7JRBFUfjRj37EMcccA8Ddd9/Nb3/7WxYuXNgtx5ek/cHOq5P8Xg2fRyfVnBhAYNuCiGWhqgprt9azekMNIBC76L/Q2wQQTbp9qb2G+77Wsh1My6G6Po4QIj3Z7NW1Djfw7TzcJHUuozuHa6+9lnvvvZesLPeHOm7cOJ5//nlGjRrVbYHk5uamEwPAhAkTKC8v77bjS9JA11G5i8ZIyl2KagtM02meYXYTRH04RSyeIpGySaQckn10nmFnAvfNpKIo6JqKooAtaDPZbNoOAW/b975yb8PuUURXDRtaaWxsZNmyZVRWVjJ48GCmT59Obm5ujwTlOA6XXnopM2bM4OKLL+6R15CkgeYv/1xHJJYiFPAAUN+U4JP1VcSTFrbtEEvumEtoacLT20Xy9pTPo6E2lwM3LZshBUEeuX7HUvudfxZA+vMfnC7nSjOR0bDS6tWrueKKKxg9ejRDhw5l2bJlLFy4kEcffZSJEyd2e1C33347gUCACy+8cLe+r7Y2gtPDxeMLC7Ooru7/45byPPqW7jiPkopG944hmgRgc1kDugIp0yZpts0Cgv6bGBTAtm1sFBQFPIbGQUOz2/z8Dh2ezdKPS4jFU232Nhx1yKCMfs4D5e8Kuj4XVVUoKAh1+LWMksPChQu55ZZbOPPMM9OP/f3vf+c3v/kNL7zwwh6E27m7776bbdu28cgjj6CqGY16SZJE253ATdEU31RFSKTsPtdsZ1cUBXRVwbJ3zIF4DXf4yDQdFNUtomfoKkLA0EEBZkwe3uYYLXsb9uc2n3sro+SwdetWzjjjjDaPnX766dxyyy3dGszvf/97vvjiCxYtWoTH49n1N0iSlJ6ELqmKUNMQx6urlNdFiSf7562BqoCuqfi8KsmUhaK4vRd0TQGfQsinU9OUJC/Lx5ih2enWnjuTexv2TkbJYeTIkbz22mvMmTMn/djSpUsZMWJEtwXy9ddf8+ijjzJq1Cjmzp0LwPDhw/nDH/7Qba8hSQNFS0JYX1JPeU0Mj6G6tYKEw+aKaJ9eddQZlZYd2QoCgd+jgYCsoEHIb2BaDoauMqIoxARZUbXHZZQcfvWrXzF//nyefvpphg4dSllZWXrop7scfPDBrF+/vtuOJ0kDVcuqJMcWlNVEEc1VUqsaojRGrX6ZGABUTQEBHkPB69HxGBpFuX4aIiliCQshBEW5flkXaR/JKDlMmjSJ119/nbfffpuqqipOPvlkpk2b1mOrlSRJ2qGlSurabfVE4imSKfcdtMdQsR2BR1eJxs0+WSBvdziOIODVsR3BkaMLmDF5OKvWV7Otsol40ibgMxicH5CNefaRjJLDG2+8wfTp0zn77LN7Oh5JkloprQrz4vLNfFMdJhq3sGwH2wEnZZOy3KWpKdPutyuPWritPBUUVUHF3ccg5wx6V0bJ4aGHHuJXv/oVM2fO5KyzzmqzWU2SpMxl2l+h5Xmrv66mKWZi2467+UtVduxk7ucJAdyVSc29hLCbl1UdekAOZn/PdgNARsnh5ZdfZuPGjbz66qvccMMNpFIpvv3tbzN79mwOP/zwno5RkgaErvorFBZmtXneM/9aT3VDgnDMTO/dadn0NVAEPBqW42A21wb3ezUmH1KIpiltGvNIvSPjjQQHHXQQV199NW+88QYPPvggGzZskP0cJGk3tO6voCgKti3YXhvjf5Z8xV/+uS5dFO6Vd7dQWhUhZdoI4d4lCOiz/RUyoQDZAZ38LA+5IQ+Dcrz4fDq6pqKrCn6vxtBBQTRNIZa0mDy2sLdD3u9ldOfQoqKigtdee40lS5ZQXl7Oueee21NxSdKA09JfAaApmmJjWaO7dl+4pR1a7iK+/sbtvZAwHTIrbtP3TTq4gNxsHzUNCWJJk3DMxO/RyQ4YNMVSGKpG0O/2ZZCb1fqGjJLDs88+y5IlS1i3bh3Tpk1jwYIFTJ06VW5Uk6TdUJDto7IuRn0kyfbaGKqqEPDphPwGoYCHWDzFqvXVpCyHlCnct9v9nAJkBXSGtVzsc8G2vQgh2FzRBCgcOXpQpxvZpN6TUXJ4++23ueCCC5g5cybBYLCnY5KkAWnYoADvf1GBz6PjCAdhqzSEkxTn+YEdVUM1VWkpntqvqQoMzvOTFdzxJjLg1akLJ5l35mG9GJmUiYySw5/+9KeejkOSBryymhijh2bTEEnRFFVRVYWsgIdwc4OdWNIikbRIpvpuw51MGJpbEK9lrmRowY43lLGk5e7klvq83ZpzkCRpz9U2JRicF2BIfpChBcH0nEM8YRGJpahuiPNNVQR3MKZ/3jaozUNhigJ5WV4G5wXQNKVNIx65u7l/kMlBknpAR/sZWldNzQ56OGhYDtsqw6AIQgEP+Vk+vi5p6PGy8z1FBQxDY1C2l4IcH9+dNgZAVkbtp2RykKRu1tl+hgljCvh0Uy2RmMnW7U3UNSVxBOSFPGzb3sjaLXXEzf61+cvQFXyGju04aJpb0iPoNzjh8CHpJCCTQf+0R8mhtLQURVEYPnz4rp8sSfuZlv0Mti1YX9rgdmJzBOXVUbwejS3ljZg7mrJR05SkZs323gt4LwghSJo2QZ/GwSNyOXB4HjV1UT7dVMuQgqBMDP1YRpvgrrnmGj755BMAXnjhBc4880xmz57Nc88916PBSVJ/VNuUwLIcNpY1YloOqqLQEE5SVR+npiHaJjH0ZwqQHfRyxIF5TBpbxJD8IKri7m4OeHVWra/u7RClvZBRcvjggw/SZTKefPJJnnjiCZ577jm5ikna75VWhVm8YjOPvfYVi1dsprQqTEG2j5KqCIau4jiCyvo4KcvGtG3qw/17JVILj65QlOvnqu8dia85GbTWsixX6r8yGlYyTROPx0NlZSUNDQ1MnjwZgJqamh4NTpL6qpYy2l9urcPQFXRVZXN5E59sqOa4bxURiZsYukpTNIVl2yDcukj9c6q5LY+hkBfyce7UAxlRlNVmor2FXLLa/2WUHMaNG8ejjz5KWVkZ06dPB6CyspJQqOPG1JI0UJVWhXlr1Td8ta2eRNLCtGxMW6AqCvnZXhwHln78DYbmlsjQVHfNvyPc5Zz91aBsD0lT4PVo5Gd7+Y+Zh6TnEyaPLWTpxyUA+AMeoglTLlkdADIaVrrjjjvYsGEDyWSSn/3sZwCsXr26TdtQSRroWlYhtQwZRRMWCVPgCLfcdE2jW0XVth1Cfg+qouDYDo7tfr2/pgavrpCf42fsATnkZXloiLhlPloKBY4oymLW0QcQ9BnUNMQJ+gxmHX2AnIzu5xTRn9/O7KS2NtLja8QLC7Oorg736GvsC/I8dt/iFZuJJkw2lDbSEEkQjVvpEtotfQlUBQzdfc/V0pinP1Ka9+F5DZVjDhuMoihsLGsE3PmEEYNDxJJWuyQg/676nq7ORVUVCgo6HgHK6M5hyZIlbNq0CYDNmzfzH//xH1x00UXpxyRpf1DblCDg1fF7NRJJ262o2qzlI0dAynRIWf03MQD4PRoBr8aIwSF0XaWsJpL+WnFBQK5I2g9klBzuv/9+cnJyALjnnns48sgjOfroo7n11lt7NDhJ6itKq8JUN8T59/oqEqkddwwt5SJa37Aq/bf6BeDGH/IbXDxrLBeeNpagz6AxahLw6owZmk1OyC07LlckDWwZTUjX1dUxaNAgkskkq1at4sEHH0TXdY499tiejk+Sel3LXENuyEMsbuE4oKtg2gIh3I+tVncJ/bT6BeAmu+ygh8NG5TNl3BBgxw5nuSJp/5LRnUN+fj7btm3jnXfe4YgjjsDj8ZBMJvv16gtJylTLjuch+UHGDMt2ezAEPGjNHcz8Xj19B9HfeQyNI0fnt+vhPHlsIbGkRTRhIoRIr0iSHdsGrozuHP7f//t/nHvuuWiaxn333QfA+++/z6GHHtqjwUlSX9C6g1tOyEtOyG1W88a/S7FtQSw5QLY8A5qikDBthuS37dvSsiJJFtHbf2S8WikejwPg97uNSWpra3Ech8LC7nvnsGXLFq6//noaGhrIzc3l7rvvZtSoURl/v1ytlDl5Hl1rXVW1uiFOXsiLz6NRURejMZKirik+YMpgtDBUhbxsLx5D47I5h+3RhV/+XfU9e7paKePCe4lEguXLl1NdXc1ll12GZVndPqx0yy238IMf/ICzzz6bl19+mZtvvpmnnnqqW19DkjrTkhC2VTZR25hk2KAgRXl+TMtmXUkduqbhNVTqw4kBlRg0hebGQzo5IQ9Bv0feEUiZJYePP/6Yn/70pxx++OF88sknXHbZZWzbto3HH3+cRx55pFsCqa2t5auvvuKJJ54AYPbs2dx+++3U1dWRn5/fLa8hSdBxrwUgXWY7nnCv/FsqmtheFyMcTxGOWThiYNRFAndjm2kLPIZGwKdzxIH55IS87Sadpf1XRslh4cKF3H///Rx33HFMmTIFgPHjx7NmzZpuC6SiooLBgwejaRoAmqZRVFRERUVFxsmhs9uj7lZYODDeVe2P57GlvJG3P6sg5DcYPiSbWNzk7c8q8Boag3ID1DbG2VYZxrYdHAGaBgilX69A2pmqQHbISyxhoWluFdUhRVnE4iYOCqceO2qv/jb2x7+rvm5PziWj5FBWVsZxxx0HgKK4yzIMw8C2+9a9tZxzyNz+eh5vfLgVFYEiBPFYCgVQEXy5uYbCHC9fbqnHtEU6GTgW9OtNCx1wBJiWg9fQUBWB36vxzfYmCrJ9TB9fTMhQ9/hvY3/9u+rLenTOYcyYMaxYsYKTTjop/dj777/PIYccsgehdqy4uJjKykps20bTNGzbpqqqiuLi4m57DUlqvfKohVtuWmHDN02Y9sBKBJ1JmTahgIFH19sU0ZOkFhklh+uvv54rrriC6dOnk0gkuPnmm3nrrbf44x//2G2BFBQUMG7cOJYsWcLZZ5/NkiVLGDdunJxvkHZLSyntTeVNgGB0cTYzJg9PX/x2Li/dGElSUhUhmkgRiQ+cOYVdEYBH15hz/EiZGKQOZbyUtbKykldeeYXy8nKKi4s566yzGDJkSLcGs2nTJq6//nqamprIzs7m7rvvZvTo0Rl/vxxWytxAPI/SqjAvLt9MZX0Mn0dDQSGesijK8/PdaWMYUZTVpr9zfVOc9aVNmJYNCFIDODdoCqiagmMLfF6d/GwvP5q9Z8tVuzIQ/676ux5fyjp48GAuu+yyPYsuQ2PGjJGtR6U9tmp9NU2xFH6vnq6MiqITjpnpAnGr1lcTS5iUVUfYXhdzm/A4bctfDASqAj6PRixpozfv5FY1FZ+uMbI4xJB82d9Z6lqnyeHnP/95evK5K/fcc0+3BiRJe6q2KYFp2QS8O5Zi6ppCImlTUhWhujFOwKtzQFEW1Q1xLEsQ8OkkU31rYcXeUACPoeI1NIYUBKhrTNAQTREKeMjyG+RmedA0VZa9kHap0+QwcuTIfRmHJO21gmwf5TVRIgmTRMommbIxbQdNgWjS4qBh2em5hkjMQlMVkqY9ICahWwrBaqrbT0JvvnPKCnjQdJUphxa12dch7xqkXek0OSxYsGBfxiFJHepow1pnF7bJYwtZt62e8toomuL2VRAoKCpYlk15dQy/R0+XnPYaKpHEwLhrEEDQq2E6jvuxT8O0HOIpi0NH5PKdkzKfu5Mk2I05h/fee4/XXnuNuro6HnnkET7//HMikUh6/4MkdafWvZpDfoMDikJEEyZLPy7ptAXliKIsigsCRBMm1Y0JFFUh4NEIBTwkUjYoUFEXIyfkxe/TqKoze+HMeoahKRx8QB7l1RG3CZFwh4SL8vzMmDy8l6OT+qOMksPTTz/NU089xXnnncc///lPAHw+H3fccYdMDlK3a1lRtL02Rqh5GGhTeRMHDctJdx/r7O7BcgSTDink0401+D06KCCEwHEEQgi210b5pioyYCqpqgp4dAVV07jyu0fu1p2WJHUlo+Tw5z//mSeffJLhw4fzpz/9CYDRo0ezZcuWHg1O2j+19E+wbIHPo6YXRpTXRhk7IrfL7mMt+xj8Xh3TcjB0lWjCImU5pEx7wOxl0DWl+T8V2xYU5rhNd0YUZclkIHWLjJr9RKPR9E7llv9RLcvCMGSBLqn7te7VbDVPFhuaSjxp7bL7WEtTmryQl5Rp0xBJ0hBOojdPPvfnnjw+j8aIogBZAcNdrqu5idPr0fj2sQf0dnjSAJNRcpgyZQqLFi1q89hTTz3FMccc0yNBSfun0qowi1dspqQyzBdb6sjyG5iWg2k5pCwbXVN32X2spSmN36sTT1nUNCRIpGzqw0lMS/TbKkleQ+WAwSF+NPtbXDjzYIoLAvh9BsUFAb5/ykHplp6S1F0yGla68cYbmT9/Ps899xzRaJTTTz+dYDDIo48+2tPxSfuJ1juXDxySxYZvGilLWgwrCFAXSRFNWHxrVD4nTxqWHjYprQrz+idllFQ0thtfrwsn8OgaXkMjkerfy1VVBQ49II9zp41ODxvJZCD1tIySQ1FRES+88AKff/45ZWVlFBcXc+SRR6KqGd14SFKnWiZQV39dg64pHFAUIjfLx9gRCiVVEaoak0w8eFC7idWWZGLoGtX1cTaXN/HJhmrmHD+Stdsa2Fze1LzPof8lBY+uuHc4AlAUPLrCudPcpaiLV2yWk83SPpHx1V1RFI488kjOOOMMEokE//73v3syLmk/0HKBd5vWOyDcVUmNkSQ5IS+HH5jPAYNDfOek0e0ugm+t+oZtFU2sWl9NZUMcQ1NIWTZPLV3Pu2vKiSYs7H6YGABQFAJeHY+hkR0wOGpsEUD6Z5Wf5U0v6y2tGhj1f6S+J6PkcOGFF7Jq1SoAFi1axDXXXMO1117bbV3gpP1Ty6qkoM8g4DNIWjbhuMnqr2tYV1JPZX2sw8nn0qowX22rJ5awURVIJC2+qY5SXZ8gmrSxHBAC+ku5JAV36EhVQFdBOAIhQFUUNFVhxuThbX5WiuI26GlZ1itJPSGjYaWvv/6aCRMmAPDcc8/x1FNPEQwG+f73v8/8+fN7Mj5pAGvdWyE7YLC1oik9nFJRE6OyLsrkQ3ZMPu8YgqomZTkkUjv6mPfHTm0tJS+8Hg0hBLkhD5qqkDAdgj4Dv0fD79MYUZTFv1aWdtiHoqtlvZK0NzJKDo7joCgKJSUlCCE46KCDAGhsbOzR4KSBrXVvhaqGOJqmYttu+QdVU9BVla+21jNl3JA2E9YICHg1miIpFKV/JgYAv9dtiXvc4UPYXhenMZIE4IgDc9v1c965DwWwy2W9krQ3MkoOkydP5rbbbqO6upqZM2cCUFJSQl5eXo8GJw1sk8cWsvTjEgDqm5LoqoquqeRnefF6NEzTYXNFE6VVYZ59fQPhmElWwEBRQRHupG1m3Uj6Hl2FvCwvIb9B0GcQCtg0RpIMHRQgO+ghmjCJJS2mjh8KtP1ZBbw6seY9Hy1fl6TullFyuPPOO3niiSfIz89n3rx5AGzevJmLL764R4OTBraWPQmr1ldjCzA0yA25iQFAIEiZDi8s30RpZRjbgZqGOCgC0c+rXwT9BsMLQwzOD/Cdk0ZTWJjFJ1+Wtyl9MXX80PREfOufVUdfl6TullFyyMvL45prrmnz2PTp03siHmk/07JuvymaYl1JPaqqgADTdkikbBQFyqqjxFP9ZXp517L8GocekIeqKW029O2q9IUsjSHtS50mh//+7//mxz/+MQAPPPBApwe46qqruj8qab9z8qRh1IeTNMVSxJImjiNImTZNUROrv04qdMDnURkzPI/B+QG5T0Hq0zpNDtu3b+/wY0nqCSOKsjh32mjeWvUN60rqaYyaKAjsfp4YVAWmjh+ankcI+ow97q0gK65K+1KnyeHWW29Nf3znnXfuk2CkgW3l2u38/cMSt9cCkBUw3AlmRSHgM8gJGFTUxkiYDpZlY7v74vo1IaCsJoKmZe3VBHLr1VqtN8F11ttCkvZWxs1+tm7dypIlS6iqqqKoqIjZs2czatSoHgxNGgha3u2uK6ln23Z3N6+uKSRSNrGkRU1jnPxsH9G4SXm1Q0MkiWWLfrs8tSO1TUnGjczfqwnk1pvggPS/XfW2kKS9kdEO6bfeeotzzz2XLVu2kJOTw5YtW/jud7/Lm2++2dPxSf1Y6/IYNQ1xHMdtumPZAl1TQYBlQ0M4RVM0RXVDgpTVvxKDsosa4IoKuqrs9RBQSxnz1uQmOKknZXTncN999/HHP/6RY489Nv3YRx99xO23384pp5zSY8FJ/UdpVZhln5SxqbwJEIwuzgZIv9tNmO5qI1VVMC0HXVPSQ0ZCCGJJq18OIamAqrlJbuf4FQU8moquK3v9Dl9ugpP2tYzuHLZv385RRx3V5rHJkyfLiWoJcBPDi8s3s66kHk0FXVVZX9rAZ5tqME13Q4LPo7m7mR33ziBl7biUmrbA7mcrVTUVcgI6AZ+BrmsY+o7/lRTF/S/g1SjK86Mp6l6/w29pYuQWKRTpTXJd9baQpL2RUXI49NBDefzxx9s89sQTTzBu3LhuCeLWW29l1qxZnHXWWcydO5fPP/+8W44r7Rur1lfTFEvhb64kahgqfq8OKJRWRwE4cEhW8/6F/nh/0J6mQnbQy6RDBjGiKERelhefR0VVICfo4YCiEMMKQ2iaiq6re/0Ov2UTXNBnUBdOEvQZcjJa6lEZDSv9+te/5sc//jFPPfUUxcXFVFRU4Pf7u60q69SpU/nVr36FYRgsW7aMq6++mjfeeKNbji31vNqmBKZlE/DuGPKwbbeDW3ltDIADikIEfBqpaP/v4awoIISCrqvkhLzkhNyCeNvromyriLjlPRQwTYd4yqIoz98t7/DlJjhpX8ooOYwZM4a///3vfPrpp+nVSuPHj++2HtInn3xy+uMJEyawfft2HMeRzYT6iYJsH+U1UUzbwdBVkimb2qYkqqIwJNe9cK7ZXEc00dzDWem/NZEU3DIfqqqSFTCIJsx0rSNNUzl32oGs3dbQPPfiMHZELjMmD5cXdanfUYTYvf9NHaft4HB3X8Affvhh1q1bx8MPP9ytx5V6zpbyRp7++1rKayLuCprGOEnLwWdo+H06jZEU8YSFLQSI/rl3QcFdeWSoCh6PzpEHDeKCmWP54PMKqupjFOUFOO6IYg4cmtPboUpSt8goOXz55ZfcdtttrF+/nmTSLSsshEBRFNauXbvLFznnnHMoLy/v8Gvvv/8+muYWWnvttdd48MEHefbZZxk0aNDunAcAtbURnB5eB1lYmEV1df/vvtXd59F6tVJtU4Isv45pOSRNh2TKwhH9r7S2roHfa5AbMtA1DdOyMXSN7IAn3c+5u8i/q75loJwHdH0uqqpQUBDq8GsZDStdf/31nHzyySxcuBCfb/cn1l566aVdPuf111/nvvvu48knn9yjxCDtO52Vcbh41qGA2+f488211IWTKArYwn3n3Z8ogM+jMyTfz6mTh1NWE5NlK6T9SkbJoaysjKuvvhplVzt+9tCyZcvSZcGHDx/eI68hdY+Va7fz6vvbsB2HkN/Aspx2ZRwmjy3kgy+3k0xamLaD6GdDSX6PymEj8xhWlEU0YVJWE9vjekiS1F9llBxmzpzJu+++y0knndQjQfzyl7/EMAyuvPLK9GNPPvmkbCbUx5RWhXn1/W0AZPk9mLbDloomDF3lf5asZeLBg9LvqgtzfNQ0JPp8UlBxe023vO8JenXyc7wMa050cheytL/KKDkkk0kWLFjA5MmT2w353HPPPXsdxIcffrjXx5A619EwUGHh7g+LrFpfje0IQn4dFLAdh2jSQjcVvIbK55tr+eDL7RxQGGR7XQyPRyVlOn1yZZKquOOt2QEjPeylqgo5AQ9Wq0UXcheytL/KKDkcdNBB6b7RUv/SWTXPvLwgIWP3Vpptq2wimbIJx1J4DA3LdtBVlZTpTjgH/RDyGaz/ppF40nJXJvWxxKDg3iWoioKqgGkJHARBr86IohBlNVH8Xj1d0kO24pT2VxklhwULFvR0HFIP6aya5wefVzBz0rCMj1NaFaa2MYmuK6QsMC2HeNJCU5p3PSsKjdEUinCIxvtenSSteWOaR9dwHAfTFmiqRsqyKcj2cvDwXHRdxbQd8rN81IWTshWntF/LuGS31D/VNiXIz/K2eSzg1amqj+3WcVatryYv5GFrZQTbFgiaK6wK8Boqfo9GyrSJxPvmDmhdUxG4O7c9Hp3B+V4OGp5DTUOC3JAHyxHk+AymTpPJQJJAJocBr7NqnkWdrG3eWct8xYo15SSSFoqiYDtuchACPJqCz6uTMm1iSbunTmOvJU0HXXUbDAX9HkYNyXJ/JrnsVXc2SRqoZH2KAa6zap7HHVG8y+9t3Y/BtgXJlEMiZSOEQFUUUEDXVQxNIZq0++wmN0VxS15YDoTjFlk+LV0PSa5GkqSOyTuH/YBX19hQ2khLn4VZRx/AgUNzOtw12XplU3VDHENTqG1MEI6Z7jyCABzhLv0UkLJsNFPF79WIJfrWnYOuAUIh6NdRVYVowsLQVCobkxzc/By5GkmSOtZpcnj++eczOsD3vve9bgtG6l6tVypNOKggvfpmV8+3bYeGcIqt25twHMjL8rR5nhCk+ztbNoRjJlof2wLtNVRsRxDw6Wia+7Hfo2Hb7kS6XI0kSV3rNDm8/PLLbT7/5JNPGDRoULpkd21tLRMnTpTJoQ/rqu/wpG+1vyCuWl+NbTuU18QwdBVVVXAch7qmZJvVRwLa1bDqK20aFOCAwUFyQl62VUawbQe7uT1pXpaHZMrGtIVcjSRJu9Bpcnj66afTH7e0A73kkkvSj/35z3+mtLS0R4OT9k5nK5U6G2OvbUrQEE5h6CqGrqKpKinHoaMmbX0kF7SjawqXnnkYAK++t4XPN9ehoJAbMnAcsB3BBSePYcq4Ib0cqST1bRnNObzyyivtdjFfeOGFHHvssdx44409Epi097rqO7ylvJE3PtzaZtd0QbaPzeVN7g5o3Attf+neqQCGoaBrWvpO4P+dcyQr127nzU/KaIikyA0ZzDl+pEwMkpSBjJLDoEGDeOutt5g5c2b6sWXLlpGfn99jgUl7b/LYQpZ+XAKQbkgTS1ocMjyHl97eiIpos2t6wpgCPlEV4kkb07IJx8xePoPMKM3/2bZAVwWLV2xO13iaMm6ITAaStAcySg433ngjP/3pT3nssccYMmQIFRUVbNy4kQceeKCn45P2Qkvf4dZ1laaOH8qq9dWE/AaKEDRGklTUxQjHTGobExz3rSKWf1pBTWOiz5W+6Iyqur0iHAf8Xp3PN9eydXsT3502Rs4nSNIeyig5nHDCCbzxxhu88847VFVVMX36dKZNmyarpvYDHfUd/tfKUoYPyWZ7VZhN5W5V1ZBPJxxL8U1NjAMGh6hrSuDQ92ojQUuvBQ2fV0PXNJqiSRxHkJvlITfkxbIFVfVx3lr1Df95xrjeDleS+qWM9znk5+dzzDHHUFlZyYQJE3owJKmnFWT7iMVNKupi6cnnSCxF0nTYWhGmKZrCdtx35Aq9lyAUIODVMB1Bytwx+6FpEPTpDCsMMe87R3Dv0yvRVRWjuZCgoSsgdDZXNPVO4JI0AGS0Q7q8vJy5c+dyxhln8MMf/hCApUuXcsMNN/RocFLPmDy2kEjcJBwz0VWFSCxFQySFz6MR8ukkU+5eCNvpncSgKjt6Npu2Q8hnEPLraKqbsAJeg8NHF3DutNHNPZsVxE7rp9zP+9jmC0nqRzK6c7j55puZPn06f/nLXzjmmGMAd6jp7rvv7tHgpPY6a9HZ1fN0VSGaMCmtihJPWvi9OmNG5ODRVSIJk6TpkJvlJeQ3iMZNHLfI6j5LDB5dwbJFuvxGy78+TSVlC1KmjWGoBH0+DF3jsjmHtTnnMUOzWVdSj6IoGJpbWTWRsjn0ADnsKUl7KqPk8Pnnn7No0SJUVU23Cs3KyiIcHhgNuPuLznoztG7RufPzNAW+2FJHYyzZfJuoEk1YNMVTDMr2UpQboKohjqZAVX2cSNxE0xQsq/syg6q4F3yPrjS/n1ewHQe7eaRo5w11AD5DQVEVDKAgx0fKctBUhTnHj2yXDE+eNIz6cJKmWIpY0sTQNQbnBTh5N0qSS5LUVkbJoaCggG3btnHggQemH9u4cSPFxbsu3iZ1n652PLe+YLZ+3rqqCJYjwAFTgKG7gzDJpM031TGqGxKoqoJlO3jcYkQ4zp5tcnO7qbmJQBHg9aoIoaA1Dw8pwh3+UVUFj+E21Ikn7XQpjtYcINA86ewImHJoUad3SSOKsjh32uiM7qgkScpMRsnh0ksvZf78+Vx++eVYlsWSJUt49NFHueyyy3o6PqmVXe14bhlK+vCrSnKDHrL8OttrY8SSFlbzu/TWE7vg9jdQULEtQdy29jgxgPt9ttM80q+Az9A4eEQuPkNj1dc1JBIWXo+K5bgVXr0ejdyQQVPUai4D7tI1BeGAx9CYfEgRdeHkLktqd7QqS5KkPZdRcvje975Hbm4uf/vb3yguLmbx4sVcddVVnHrqqT0dn9RKVzueWw8l5QQNGiJJvqmOoKnN5VM7YdrgOA62cFcn6JridnbbC15DwREQT9nYlkNufpBDR+Ty6cYa4ikHj+6uLLJsB9MCIQRZAZ2E6SAcgd+roSgKsYQlq6ZKUi/JKDl89tlnnHrqqe2SwZo1azjyyCN7JDCpvc52PLdsbGsZSho2KMT22moURXHniHZxrbdbTQQr3TDVkLIEHkPD0FS2VEYYVpTFsMIQ5TVRqhriGLqKR1dJWQ62LVAUBVVR8XkU4gmLpOngMzQcR8iqqZLUSzJaytqyfHVnP/rRj7o1GKlrLTuegz6DunCSoM9IT0bXNiUIeN1cnx30EPTr7iogR+D16KidrOrc+WG7Gzr2KIo7yewId9VQ6y8MGxRk6KAgQb+BqigMyvHi9WiYtoOqKPg8KkJAynIoyPG1m2yXJGnf6PLOwXEchBBt/mtRUlKCpmk9HqDUVuux9ZY5hn+tLKW6IY5p2QS8BuW1UWIJC8t2MHT3Yqso7juBna/9PbFa1XFAUQSxhEPQr6d7J2iqQnFBkMH5AQDWldQTS1gMyvHRFEsSS7hzD5qqMLwoyIWnjZWJQZJ6SZfJ4bDDDksvXT3ssMPafE1VVebPn99zkUld2nlZq2U5rC9tQLhXZuJJE9MGj+2Qn+WlaS+L6Cmtpi52lVAEzctXFTA0hZKqMCMHZzPn+JF8uqmWaMIk4NXJC3mpa0owOM9PImljGWBZNnnZPgJeYxevIklST+oyObz55psIIbjooot45pln0o8rikJ+fj4+X/dOFH700Udccskl3HDDDVx44YXdeuyBZudlrYPzA2wub6QhbuP1aGiaiiMcUpagsn5H/4aWYaSdL/AKzcNBov1jrcee3CGjzhNEy/coikJhnpfDDywg6DPSq42GFATTS04H5weYdMgg3vykDFWD4oIAQwuCZAc9RBNmuyW6kiTtO10mh2HD3E1ES5cuRVVVDGPHuznTNEmlUng8ns6+fbdEIhF++9vfMnXq1G453kDXsvN5XUl9etdzNGHh9WgMHRSkZHvYHd7BvZBrqntRN3SFvCwvVfWJ9OPpfQY7JQa1+Xtgx+SUgoKqivQGtp35PBp5WR5UVeWgYTntmgt1tOR0zeY6xo7ITd+lQtdNiSRJ6nkZTUhfeumlfPnll20e+/LLL5k3b163BXLXXXcxb948Wek1Q4amsr60AdNy8Ht0TMshadrpC7zZfPVWm3/Dhu5+kLIE1Q1uYlCB3JAHo3m2uiU3aAp4DHc3vKa5Q0OKqqBqCgcPz8ZraOmbCaXVa4A7TxUKeDhoWA7ZQU9GS1ELsn3telvLJayS1LsyWsq6fv16xo8f3+axI488knXr1nVLEMuXLyccDjNr1izefvvtPT5OQUGoW+LZlcLC3h/q8PkMdF3F0DUsx6ExkkIIiCQsNpU1pt/Z2x1sftNUBRWBZUNdUwpdU9A1sGzc3cu6iqq6ZSuicQtf8zBVbsjDmOG5qJrG+pJ6bFtg6Cq6pqLrSvOiBYWxI/MJ+A1icRMHhVOPHdXlz+zUY0fx0tsbEYqyW9/Xoi/8PrqDPI++ZaCcB+zZuWSUHLKzs6mpqaGwsDD9WE1NDX6/P6MXOeeccygvL+/wa0uXLuV3v/sdTzzxREbH6kptbaTDOj3dqbAwi+rq3q8pFY4mGT0ki22VkeYSGDtqGHU05NPyY3ErmyoIoaAqDo4gvelNV8HrUd27EEtAJEnI72HcyLx0naJV66vduxABfo+Gz6vjCIHtCLICHnfHtRB8s72Jgmwf08cXEzLULn9mIUNl+vhiVq2v3q3vg77z+9hb8jz6loFyHtD1uaiq0umb6oySw2mnnca1117LjTfeyIgRIygpKeGuu+7ijDPOyCi4l156qdOv/fvf/6a6uprzzjsPgPr6epYtW0ZDQwMLFizI6Pj7o5bd0l6PxuB8P43RFCnTRnF2Ll7dlqGreA2NlGljtt6CAOkxf8dx6zYV5wcYMTiUHvJpPV/whxfXsK60wX1NFRBQ35SkMG/P6hrJ8heS1LdklByuvvpq7rrrLs477zxSqRRer5dzzz2Xa665Zq8DOOqoo/jggw/Sn19//fUcfvjhcrXSLrTslg7HUoR8BqlUxwXsWlMVyM/yEgp4qGpIkDSTreoZue8iYkl33iKWMNlS0UTCtCjOD7ZbOXTWiQdiLt9ETWOchrCJpiqE/BrF+cEOK8VKktS/ZJQcvF4vt9xyCzfffDP19fXk5eW1WVki7Tut+zR4NBWPrlEfSWLaTqe7m7Xmjm6GrtIYNfEYGsmUlR5qaun2ZtkOornGkqa6pTdqm5JuSQur7VjViKIsvjttDM++vgEhICvgkctQJWkAySg5lJaWtvk8Go2mPx4xYkS3BnTXXXd16/EGktKqMC8s30Q4ZmJZDrru7mWwbLcMtqbsqJPUmhDuEtNDD8ilrDZGOGaSSNpoijvHkDIdLMdNIuDuU7AcgaaAZTlEbEEs0X4T3YiiLApz/XIZqiQNQBklh5kzZ6IoSpvyGS0Xg7Vr1/ZMZFIbpVVhHn9tLVX1cbwejayA+6ura0oR8Go4joqjOdgdNOnxGCqHjswjN8vLsKIs1pXU4zVUwnELVVXweiCesEhZDrrqJhhNcZeoCiFI2W1Lp7TWVaVYSZL6r4ySw85LVqurq3n44Yc56qijeiSo/d3OLT4jcZNN5Y00RU1UVcFJCpKmTWGuD0WBRMqmeFCQqvo4PtwSFNGEne6rEPTp1IWTlFRFOGxkHtUNcYoHBdH1FJG4hWU5BHw6IuFupkuZNo5wi+cpiluCu7NhxK4qxUqS1H9llBx2VlhYyA033MDpp5/OnDlzujum/drOLT7XlzbQEE6iqErzvIBAVcCyBA3hJOAmh8ZoikjcxNDcfsweXU0PE9WHU/g8OuMOyEXXVSxb0NCUIBTw4PO4fwKxhEUoYBCOuSuTvIaKgoJpOwR8GgFfx7WOWirFtu7CNnX8UDnfIEn93B4lB4DNmzcTj8e7MxaJ9i0+/S3j95aD2lzqwrQEugaxhA2qwNA1Ah6dqEcjGrdQVAj53MJ2DdEUuiYI+g1ys9yhnlGDQ2yuCKOqKn6PRjxlk0hZnDd9DGu3NbDhmwYiMROBYFCOjyH5gXQl1Y7IZaiSNPBklBx+8IMftBlWiMfjbNy4kZ/85Cc9Ftj+qqUVaFM0xTdVkeZuac2b1DQFtwuz28FNUQT5AS+jBocIJyyCPoN40sbv0Ric58eyBaZpU5DtJd6qPMWo4mxQVZIpi4ZIityQhznHj2TKuCEMKQiStGwCXr3NMNHksYWdRCxJ0kCUUXJo2aDWwu/3c+ihhzJq1KieiGlAaj2PUJDd+UaxgmwflXUxtlQ0YVoOrYf6LVu0qWmkKQrfGpWXviMAWP11FfXhFE1RM11fqSFikpe9o0BiLGlx+JhBzGze9dyaHCaSJAkySA62bfPhhx9y++23d1sF1v1JaVWYt1Z9w2ebagAFr6FR7ouydXsT3502pt1Fd/LYQv706lfEkzZeQ223v0AAhub20wj6dAyjbcOloQUhIrF6mqJJLMcthOc4Npqq0BBOYBgasaTFcUcUdxqzHCaSJGmXVVk1TeO9996Tm972QMvk8tffNGBabv2haMIkadpU1cd5a9U3bZ6/cu12nn19A1X1caIJ06246tXbVD3VNYWsoJecoIesgFv1NJowEcI9drx5c5tpOQjhoGkKHkMlkbJY/01jurXogUNz9vFPQ5Kk/iSjkt3/+Z//yUMPPYRp7l03sf1Ny+RyJG6ha0q6bHZdU5JIzGT11zWUVrkFsVau3c5zb28ilrAI+jQ0VcFy3OWhfo+OroFHV8kOGOQEPRi6Sl62r11P6fwsH7btTkBnB72E/B58Xh2vR8Oja3znpNHyrkCSpF3KaM7hmWeeoaamhieeeIL8/Pw2dxF7U2J7oGuZXG5h2Q6JlI3jCCwFFFXlxeWbOXfaaN78pAyfRyfg09Ga9zbYDmyvi6OqoAgwPCqGoWHoKkW5fgbnB9oNAT322lc4QmCmHISwm0twK82lMnq2Yq0kSQNHRsnh3nvv7ek4BqSW3cN5WV5qGhOkLBvbFs1tNMFnqJRWuzufK+vjBLwaqur2XnDEjqbNinA/Ki7wM25UfpcriAxNTZfQ1lR3V3ssYWPoKqOLs/ftD0CSpH4ro+RQW1vbYXnupUuXdntAA0nL7uHB+X7iSYtYg9U8oaxgaCoBv04kZpJKJfB7NZKmgxlOkUi5VU41VUVVFQ4YHKIhkqQukqIunOxyBZEQgqDPIJowcRyBW/VCwefRmDF5+L7+EUiS1E9lNOdwww03dPj4zTff3K3BDEReXaOiNo6iuIXt/F6NUMBDQa4P0xKoipsAxgzNxhHCHXKy3Yu8IwR5IXeFWE7Ag66pzDvzsC7nDSxH8K1ReQzOC+Dz6Pi9OkMHBThgiFyBJElS5rq8c2ipxiqEaFeZtbS0VC5t7ULrMhgTDioglrT4YlMdpmOTE/Sgawp1TUkcR1CY62foILcb06byJmJJt7DhoGwfWUH3ZxxP2eSGdv3zbhnKGn/QoPRjrQvjtey3iKZsgh5tjxrzSJI08HWZHFpXY505c2abrw0aNIif/vSnPRpcf9a6DAa4ndVGFWexpaIJgETSLYznCEEiZbGupJ6hBUEmHVJIYyTJ1u1hNE1FOCJd3mLO8SN3+bpdFcJrnbAG5QepqYvKxjySJHWoy+TQUo31wgsv5JlnntknAQ0UO69UAijK85O0HA4oClFSFSFp2ngcQcBrkDJt1pXUMzgvwLnTRrO9Nsqbn5S1K2+xK13tcF68YnM6YamKkk5csjGPJEk7y3gpa2ulpaUoisLw4XKCszOd9Tk4oCjEd04azeIVm/HoCtvrYunGOKGATm7Ik16e2lEyyKQMR2c7nDtKWLIxjyRJHcloQvqaa67hk08+AeCFF17gzDPPZPbs2Tz33HM9Glx/NnlsYbvdy62Xn26rbKK8OoamqgzO91OQ40NFpSGa7PSYLcNC0YRJfpaXaMJk6ccl6Y10u1KQ7SPWqgAfyMY8kiR1LKPk8MEHH3D44YcD8OSTT/LEE0/w3HPP8ac//alHg+vPWoZ3Wu9ebj22H0/aoLh9nRWlefe00vx4J1rPYyjNw0IBr86q9dUZxdQ6YTkdJCxJkqQWGQ0rmaaJx+OhsrKShoYGJk+eDEBNTU2PBtffdVXALuAziMbd+kmGpmLaDkKITpvqwN4PC7Wej6hpiBP0GbLiqiRJHcooOYwbN45HH32UsrIypk+fDkBlZSWhUKgnYxvQDigK4dVV6iNJ4km3PWdLSYzOdEe/5paEVViYRXV1ZsNRkiTtfzJKDnfccQcPPPAAuq7zi1/8AoDVq1f3+xahmfZY6Injtyw5HVEUyripjuzXLEnSvqIIIQZMNbba2giOk9nptF7z3/pCu6s1/5m+487k+HuSnLoroQ2UOwd5Hn2LPI++p6tzUVWFgoKOR4Ay7iH97rvvsnbtWmKxWJvHr7rqqt0Is+/oaJNay+PdcfeQyfH3pKmObMQjSdK+kFFyuO222/jHP/7BMcccg9/v75FAnn76aZ599lkMw0BVVV5++eUeeZ0WPb3mX+4pkCSpP8soOSxZsoSXX36Z4uLOW0vujX/9618sXbqU559/nlAotE9WQXXH5G5vHl+SJKknZbTPIS8vj6ysnhvKePzxx1mwYEF69dOgQYN28R17b1eb1Pr68SVJknpSRhPSf/3rX3n77be54oor2l24R4wYsddBTJkyhXnz5vH222+TSqWYO3cu559//l4fd1e2lDfywecVVNXHKMoLcNwRxd3aW7nl+Ju+aXDbf/oNRg/L6fbXkSRJ6m4ZJYdDDz20429WFNauXbvLFznnnHMoLy/v8Gvvv/8+U6ZMYc6cOdxyyy3U19fz/e9/nzvuuIMpU6bs8tit7c5qpT21u6sY9nRVVE8bKKsx5Hn0LfI8+p4eXa3UUp11T7300ktdfn3o0KHMnj0bVVUpKCjg+OOPZ82aNbudHPqinl4VJUmS1BMymnNoUV5ezurVq6moqOjWIGbPns2KFSsAiMVirFq1qtO7lf6mtilBwNs2B8tVS5Ik9XUZ3TlUVVVxzTXX8Omnn5Kbm0tDQwPjx4/n97//PYMHD97rIC655BJuuukmzjzzTADOPvtsTjjhhL0+bl8gVy1JktQfZZQcfv3rX3PooYeyaNEiAoEAsViM3//+99xyyy088sgjex2Ez+fj3nvv3evj9EWy5IUkSf1RRsNKq1at4rrrriMQcIvCBQIBfvGLX7B69eoeDW4g2FXpbkmSpL4oozuHnJwcNm3a1GYeYPPmzWRnZ/dYYAOJLHkhSVJ/k1Fy+NGPfsQll1zC9773PYYOHUp5eTkvvvhiv62rJEmSJHUto+Rw/vnnM2LECJYsWcL69espKirid7/7Hccdd1xPxydJkiT1goyrsh533HEyGUiSJO0nMpqQXrBgAf/+97/bPPbvf/+bK6+8skeCkiRJknpXRncOK1eu5IEHHmjz2IQJE/jJT37SI0HtKVVVBtTr9DR5Hn2LPI++ZaCcB3R+Ll2dY0bJwePxEI/H2/SMjsVi6HrGo1L7RF5ecJ+8Tme1SPobeR59izyPvmWgnAfs2blkNKx04okncvPNNxOJRACIRCLcdtttnHTSSbv9gpIkSVLfl1FV1sbGRn7+85+zYsUKcnNzaWxsZOrUqdxzzz1yr4MkSdIAlFFyaFFdXU1FRQXFxcUUFsqmNZIkSQNVxlVZ6+vree+99/joo48oLCyksrKS7du392RskiRJUi/JKDl8/PHHzJo1i1dffZU//vGPAGzbto1f//rXPRmbJEmS1EsySg4LFy7k/vvv57HHHkuvUBo/fjxr1qzp0eAkSZKk3pFRcigrK0vvjlYUd12sYRjYtt1zkUmSJEm9JqPkMGbMmHSnthbvv/8+hxxySI8EJUmSJPWujFYrffrpp1xxxRVMnz6df/zjH3znO9/hrbfe4o9//CNHHnnkvohTkiRJ2ocyunOYMGECr7zyCgcddBDf/e53GT58OM8///x+nRiefvppZs2axZw5czj77LN7O5y98tFHHzFu3DieeeaZ3g5lj9x6663MmjWLs846i7lz5/L555/3dkgZ27JlCxdccAGnn346F1xwAVu3bu3tkPZIfX09l112Gaeffjpz5sxhwYIF1NXV9XZYe+zhhx9m7NixbNiwobdD2WPJZJJbbrmF0047jTlz5nDTTTft3gHEHlq3bp346U9/uqff3q/985//FD/4wQ9EOBwWQghRXV3dyxHtuXA4LL73ve+Jyy+/XDz99NO9Hc4eeeutt0QqlUp/fMopp/RyRJm76KKLxOLFi4UQQixevFhcdNFFvRzRnqmvrxcffvhh+vO77rpL/PKXv+zFiPbcF198IebNmydOPvlksX79+t4OZ4/dfvvt4o477hCO4wghdv861eWdQzwe5/7772f+/PnceeedRCIRSktL+clPfsLcuXMpKCjYm8TWbz3++OMsWLAgXWtq0KBBvRzRnrvrrruYN28eeXl5vR3KHjv55JMxDANw73K3b9+O4zi9HNWu1dbW8tVXXzF79mwAZs+ezVdffdUv33Hn5uZyzDHHpD+fMGEC5eXlvRjRnkmlUtx22239fpl+NBpl8eLFXHXVVelFRLt7neqyct5tt93GV199xYknnsg777zDhg0b2Lx5M9/5zne4/fbbyc/P3/Po+7FNmzbx2Wef8cADD5BKpZg7dy7nn39+b4e125YvX044HGbWrFm8/fbbvR1Ot3j22WeZPn06qprx/s5eU1FRweDBg9E0DQBN0ygqKqKioqJf/7/lOA7/+7//y4wZM3o7lN32wAMPcNZZZzF8+PDeDmWvlJaWkpuby8MPP8xHH31EMBjkqquu4qijjsr4GF0mhxUrVvDyyy9TUFDARRddxPTp03nmmWd26wX6o3POOafTdz3vv/8+tm1TUVHBX/7yF+rr6/n+97/PgQceyJQpU/ZxpF3r6jyWLl3K7373O5544ol9HNXu29Xvo+Xi+tprr/Hqq6/y7LPP7svwpJ3cfvvtBAIBLrzwwt4OZbesXr2aL774gv/6r//q7VD2mm3blJaWcthhh3Hdddfx2WefMX/+fF5//fU21bW70mVyiMVi6aGjIUOGEAgEBnxiAHjppZe6/PrQoUOZPXs2qqpSUFDA8ccfz5o1a/pccujqPP79739TXV3NeeedB7gTisuWLaOhoYEFCxbsqxAzsqvfB8Drr7/Offfdx5NPPtlvhvmKi4uprKzEtm00TcO2baqqqiguLu7t0PbY3XffzbZt23jkkUf6xd1baytXrmTTpk2ccsopAGzfvp158+Zx5513cuKJJ/ZydLunuLgYXdfTQ5bjx48nLy+PLVu2cMQRR2R0jC6Tg23bfPjhh4hWq113/nx/bB06e/ZsVqxYwZQpU4jFYqxatYqZM2f2dli75aijjuKDDz5If3799ddz+OGH97t3ewDLli3jzjvv5IknnuhXwwEFBQWMGzeOJUuWcPbZZ7NkyRLGjRvXb4eUfv/73/PFF1+waNEiPB5Pb4ez2y6//HIuv/zy9OczZszgkUce6Zf7ufLz8znmmGN47733OPHEE9myZQu1tbWMHDky42N0uc9hV2OGiqLw5ptvZh7xAJFIJLjpppv46quvADj77LPb/FH1R/05ORx77LEYhtHmovrkk0/2i0n2TZs2cf3119PU1ER2djZ33303o0eP7u2wdtvXX3/N7NmzGTVqFD6fD4Dhw4fzhz/8oZcj23P9OTmAO+/wq1/9ioaGBnRd52c/+xnTpk3L+Pt3q2S3JEmStH/oX4OCkiRJ0j4hk4MkSZLUjkwOkiRJUjsyOUiSJEntyOQgSZIktSOTg9St6urqmDVrFolEYq+PdeaZZ/LRRx/t1TEuuuginnvuub2OpSPr1q1j7ty5PXLsPXX99ddz3333Zfz8m2++ud8tN33kkUe44YYbejuMAa/LTXBS/zRx4sT0x/F4HI/Hky4xceutt3LWWWf12GsvWrSIc889N73WfW+89tpr3RBRzzn00EPJysrirbfe6hd1hF588UWee+45/vd//zf92G233daLEe2Z+fPn93YI+wWZHAag1atXpz+eMWMGv/nNbzj++OPbPc+yrHRP8O6QSqV46aWXePnll7vtmH3dnDlz+Nvf/tYvksNA0N1/s1Ln5LDSfuSjjz5i6tSpLFq0iBNOOIFf/vKXvPjii3z/+99v87yxY8eybds2wL3g33333UyfPp3jjz+em2++udMho88++4zs7GyGDBmSfuyiiy7i/vvvZ+7cuUycOJFLL720TUnqN998kzPPPJOjjjqKiy66iE2bNqW/NmPGDN5//30A1qxZw7nnnsukSZM4/vjjufPOO9PP+/TTT5k7dy5HHXUUZ511VpdDUc8//zxnnHEGU6ZMYd68eZSVlQEghGDhwoUcd9xxTJo0iTlz5qQbvSxfvpxvf/vbTJw4kZNOOonHHnssfbxjjjmGDz74gFQq1e61/v73v3Puuee2eezJJ59Mv/MNh8P84he/4Nhjj+Xkk0/mj3/8I47j0NDQwNSpU3nrrbcAt/zyzJkzWbx4MeDuqv7hD3/I0Ucfzemnn87f//73Ts+3xaZNm7jlllv49NNPmThxYrpGWuthqJa/jz/96U8cd9xxnHjiibzxxhssX76c008/naOPPppHHnkkfUzHcVi0aBGnnnoqxxxzDFdddRUNDQ0dvn5dXR1XXHEFRx11FEcffTQ/+MEP0mXVKysr+elPf8qxxx7LjBkzeOqpp9Lf99BDD3HllVfyX//1X0yaNImXXnqJhx56qE1xvK5+/y+++CKnnHIKEydOZMaMGbzyyiu7/FlJzbq1u4TU55x88snivffeE0II8eGHH4px48aJe+65RySTSRGPx8ULL7wg5s6d2+Z7DjnkELF161YhhBB33HGHuOKKK0R9fb0Ih8PiiiuuEL/97W87fK1nnnlGXHbZZW0eu/DCC8Upp5wiNm/eLOLxuLjwwgvFvffeK4QQYvPmzWL8+PHi3XffFalUSixatEiceuqpIplMtov9/PPPFy+99JIQQohIJCJWr14thBBi+/bt4uijjxZvv/22sG1bvPvuu+Loo48WtbW16df/v//7PyGEEK+//ro49dRTxcaNG4VpmuIPf/iDuOCCC4QQQrzzzjvinHPOEY2NjcJxHLFx40ZRWVkphBDihBNOECtXrhRCCNHQ0CC++OKLNuc4ceJEsXbt2nY/j1gsJiZMmCC2bNmSfuzcc88VS5YsEUII8fOf/1zMnz9fhMNhUVpaKk477bR0rCtWrBDHH3+8qKmpETfccEO6sVY0GhVTp04Vzz//vDBNU3z55Zfi6KOPFl9//bUQQojrrrtO/P73v+/w99PR77r181v+Ph566CGRSqXE3/72N3HMMceIa665RoTDYbFhwwZxxBFHiJKSEiGEEE8++aQ477zzREVFhUgmk+Kmm24SV199dYev/dvf/lbcdNNNIpVKiVQqJVauXCkcxxG2bYtzzjlHPPTQQyKZTIqSkhIxY8YM8c477wghhHjwwQfFYYcdJl5//XVh27aIx+PiwQcfFNdee+0uf//RaFRMnDhRbNq0SQghRGVlpdiwYUOH8UntyTuH/Yyqqlx55ZV4PJ5dzgsIIfi///s/fvWrX5Gbm0soFOKKK67odC6gqamJYDDY7vFzzz2XAw88EJ/Px6xZs1i7di3gvrOeNm0aJ5xwAoZhMG/ePBKJRJthsRa6rlNSUkJdXR3BYJAJEyYA8PLLLzN16lSmTZuGqqqccMIJHH744SxfvrzdMf76179y+eWXM2bMGHRdZ/78+axdu5aysjJ0XScajbJ582aEEIwZM4aioqL0a2/cuJFIJEJOTg7f+ta32hw3GAwSDofbvZ7f7+eUU05hyZIlAGzdupXNmzczY8YMbNvm73//O9deey2hUIjhw4fzwx/+MP3O9sQTT2TWrFlccsklLF++nFtvvRWAt99+m2HDhvHd734XXdc57LDDOP3001m6dGmHv5Pdpes6P/7xjzEMg29/+9vU19dz8cUXEwqFOPjggznooINYv359+ud59dVXM2TIEDweDwsWLOCf//wnlmV1eNzq6mrKy8sxDIOjjjoKRVH4/PPPqaurY8GCBXg8HkaMGMH555/f5m5owoQJnHrqqaiq2u5vdle/f1VV+frrr0kkEhQVFXHwwQd3y89pfyAH7/YzeXl5eL3ejJ5bV1dHPB5vMzQihOi0y1p2djbRaLTd44WFhemP/X4/sVgMgKqqKoYOHZr+mqqq6TLWO7vjjjt48MEHOeOMMxg+fDgLFizg5JNPpry8nKVLl7Js2bL0cy3LatOVrEV5eTkLFy7k7rvvbnM+lZWVHHfccfzHf/wHt912G2VlZZx22mlcd911hEIhHnzwQf77v/+b3/3ud4wdO5Zrr722zaR/NBolKyurw5/JnDlzuOuuu1iwYAFLlizh1FNPxe/3U1NTg2mabc5/6NChbc79/PPP55lnnmH+/PnpIoJlZWWsWbOmTel827a7bZFBbm5uevFCy4W4dcdHr9eb/h2Xl5fzk5/8pE1pblVVqa2tZfDgwW2OO2/ePB5++GEuvfRSAC644AIuv/xyysrKqKqqanc+rT9vPUy5s65+/4FAgPvuu4/HH3+cG264gUmTJnHdddcxZsyY3f657I9kctjPtLQMbOH3+9vMIVRXV6c/zsvLw+fz8dprr7X7n70jY8eO5c9//nPGsRQVFbVp4C6ESHdH29moUaP4/e9/j+M4/Otf/+LKK6/ko48+ori4mLPPPpvf/OY3u3y94uJi5s+f3+mF9OKLL+biiy+mtraWn/3sZ/zP//wPP/vZzzjyyCP57//+b0zT5Nlnn+VnP/tZ+p1pZWUlpml2Wkn1+OOPp66ujrVr17JkyRJ++ctfAu7P1jAMysvLOeiggwDanLtt29x888185zvf4S9/+QvnnnsuI0eOpLi4mClTpuxRk6adf/d7a8iQISxcuJDJkyfv8rmhUIjrr7+e66+/ng0bNvCf//mfHHHEERQXFzN8+HD+9a9/dfq9XcW9q9//SSedxEknnUQikeD+++/npptu4i9/+cuuT06SE9L7u0MPPZSvv/6atWvXkkwmeeihh9JfU1WV8847j4ULF1JbWwu4F8MVK1Z0eKwjjzySpqamDt/5d+SMM85g+fLlfPDBB5imyeOPP47H42nzrrzFyy+/TF1dHaqqkp2dnY7vrLPOYtmyZaxYsQLbtkkmk3z00Uds37693THmzp3LokWL+PrrrwF3Qvgf//gH4E54f/bZZ5imid/vx+PxoKoqqVSKV155hXA4jGEYBIPBNu+UP/74Y4499thO+xcYhsGsWbO45557aGxs5IQTTgDclqCzZs3ivvvuIxKJUFZWxhNPPJFOXI888giKorBw4ULmzZvHddddh23bTJ8+na1bt7J48WJM08Q0TdasWdNmIr8zBQUFVFZWdjh5vie+//3vc//996cn9evq6njjjTc6fO6yZcvYtm0bQgiysrLQNA1FUTjyyCMJBoMsWrSIRCKBbdts2LCBNWvWZBRDV7//mpoa3njjDWKxGB6Ph0Ag0O8aEPUm+ZPazx144IH85Cc/4ZJLLuG0005r9y7w5z//OSNHjuT8889n0qRJXHLJJWzZsqXDY3k8Hs4555yMl7KOHj2ae++9l9tvv51jjz2WZcuW8cgjj3R4oV2xYgVnnnkmEydO5I477uC+++7D5/NRXFzMH//4Rx599FGOO+44pk2bxmOPPdbh0NfMmTP50Y9+xDXXXMOkSZOYPXs277zzDuAODd14440cffTRnHzyyeTm5jJv3jzATUwzZsxg0qRJ/PWvf+Xee+9NH/PVV1/d5Ua4OXPm8P777zNr1qw2yzBvuukm/H4/p556Kj/4wQ+YPXs23/3ud/niiy948sknufvuu9E0jcsuuwxw95CEQiEee+wx/v73v3PSSSdx4okn8tvf/jajC/6xxx7LQQcdxIknntjhsNvuuvjii5kxYwaXXnopEydO5Pzzz+/0or5t2zZ++MMfMnHiRC644AK+//3vc+yxx6JpGo888gjr1q3jlFNO4dhjj+XGG28kEolkFENXv3/HcXjyySc56aSTOProo1m5ciW//vWv9/q89xeyn4PUrerq6vjBD37A4sWLu2UjXF+2bt06brnlFv72t7/1diiS1O1kcpAkSZLakcNKkiRJUjsyOUiSJEntyOQgSZIktSOTgyRJktSOTA6SJElSOzI5SJIkSe3I5CBJkiS1I5ODJEmS1M7/B+KTjTkk5JJ1AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# generate AR(1) temporal noise that is independent in space\n", + "true_time_cov = CovIdentity(size=TRs)\n", + "true_space_cov = CovIdentity(size=voxels)\n", + "noise = rmn(rowcov=true_time_cov._cov, colcov=true_space_cov._cov)\n", + "Y_tf = tf.constant(S @ B + noise)\n", + "\n", + "# This time space_cov is AR(1)\n", + "space_cov = CovDiagonalGammaPrior(size=voxels)\n", + "time_cov = CovAR1(size=TRs)\n", + "marg_cov = CovIdentity(size=components)\n", + "\n", + "# B_hat\n", + "B_hat = tf.Variable(np.random.normal(size=(components, voxels)), name=\"beta\")\n", + "\n", + "train_vars = [B_hat] + time_cov.get_optimize_vars() + space_cov.get_optimize_vars()\n", + "\n", + "# now this loss incorporates the log-likelihood of our covariance parameters\n", + "def loss(params):\n", + " return (\n", + " -matnorm_logp_marginal_col(Y_tf, time_cov, space_cov, B_hat, marg_cov)\n", + " - space_cov.logp\n", + " - time_cov.logp\n", + " )\n", + "\n", + "\n", + "val_and_grad = make_val_and_grad(lossfn=loss, train_vars=train_vars)\n", + "initial_guess = pack_trainable_vars(train_vars)\n", + "opt_results = minimize(fun=val_and_grad, x0=initial_guess, jac=True, method=\"L-BFGS-B\")\n", + "print(opt_results.message) # check that we converged\n", + "\n", + "# assign the parameters\n", + "unpacked_theta = unpack_trainable_vars(opt_results.x, trainable_vars=train_vars)\n", + "for var, val in zip(train_vars, unpacked_theta):\n", + " var.assign(val)\n", + "\n", + "# now that we have B, solving for the MLE of S is just closed-form\n", + "# linear regression\n", + "Sigma_s_btrp = space_cov.solve(tf.transpose(a=B_hat))\n", + "# Y Sigma_s^{-1} B'\n", + "Y_Sigma_Btrp = tf.matmul(Y_tf, Sigma_s_btrp).numpy()\n", + "# (B Sigma_s^{-1} B')^{-1}\n", + "B_Sigma_Btrp = tf.matmul(B_hat, Sigma_s_btrp).numpy()\n", + "S_hat = np.linalg.solve(B_Sigma_Btrp.T, Y_Sigma_Btrp.T).T\n", + "\n", + "# Since the PCA solution is not unique, we show reconstruction\n", + "plt.plot((S @ B).flatten(), (S_hat @ B_hat).numpy().flatten(), \"bo\", alpha=0.5)\n", + "plt.xlabel(\"True (noiseless) voxel time series\")\n", + "plt.ylabel(\"Reconstructed noiseless voxel time series\")\n", + "# Also show the inner products of S and B -- these won't be uniquely scaled \n", + "plt.figure()\n", + "plt.plot(\n", + " (S @ S.T).flatten(),\n", + " (S_hat @ tf.transpose(S_hat)).numpy().flatten(),\n", + " \"bo\",\n", + " alpha=0.5,\n", + ")\n", + "plt.xlabel(\"True latent response inner product\")\n", + "plt.ylabel(\"Estimated latent response inner product\")\n", + "plt.figure()\n", + "\n", + "plt.plot(\n", + " (B.T @ B).flatten(),\n", + " (tf.transpose(B_hat) @ B_hat).numpy().flatten(),\n", + " \"bo\",\n", + " alpha=0.5,\n", + ")\n", + "plt.xlabel(\"True weight matrix inner product\")\n", + "_ = plt.ylabel(\"Estimated weight matrix inner product\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the code above looked very similar to the code earlier in the notebook, that's because it was: this is exactly as MN-RSA except for replacing the known design matrix $X$ with an estimated one $S$ and integrating in the other direction. If we replaced the `CovIdentity` with a `CovDiagonal` this model would be factor analysis, and other residual covariances may map to other models. `brainiak.matnormal` does not include a `MatnormalFactorAnalysis`, but we can easily sketch one here: " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class MNFactorAnalysis(BaseEstimator, TransformerMixin):\n", + " \"\"\" Linear gaussian LVM with with structured residuals. \n", + " If time_cov=space_cov=CovIdentity (the default), this is PCA\n", + " If time_cov=CovIdentity and space_cov=CovDiagonal (or vice versa)\n", + " this is factor analysis. \n", + " ..math::\n", + " Y \\\\sim \\\\mathcal{MN}(S\\beta, time_cov, space_cov)\n", + "\n", + " Parameters\n", + " ----------\n", + " time_cov : subclass of CovBase\n", + " TR noise covariance class following CovBase interface.\n", + " space_cov : subclass of CovBase\n", + " Voxel noise covariance class following CovBase interface.\n", + " n_features : int\n", + " Number of latent dimensions\n", + " dual : bool\n", + " If false, use algorithm from \"regular\" probabilistic PCA (integrate over S),\n", + " otherwise use \"dual\" probabilistic PCA algorithm (integrate over B)\n", + " optimizer : string, default=\"L-BFGS-B\"\n", + " Scipy optimizer to use. For other options, see \"method\" argument\n", + " of scipy.optimize.minimize\n", + " optCtrl: dict, default=None\n", + " Additional arguments to pass to scipy.optimize.minimize.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " time_cov,\n", + " space_cov,\n", + " n_features,\n", + " dual=False,\n", + " optimizer=\"L-BFGS-B\",\n", + " optCtrl=None,\n", + " ):\n", + "\n", + " self.optMethod = optimizer\n", + " if optCtrl is None:\n", + " self.optCtrl = {}\n", + "\n", + " self.time_cov = time_cov\n", + " self.space_cov = space_cov\n", + " self.n_features = n_features\n", + "\n", + " self.dual = dual\n", + "\n", + " self.n_t = time_cov.size\n", + " self.n_v = space_cov.size\n", + "\n", + " def logp(self, Y):\n", + " \"\"\" Log likelihood of model (internal)\n", + " \"\"\"\n", + " if self.dual:\n", + " data_logp = matnorm_logp_marginal_row(\n", + " Y, self.time_cov, self.space_cov, self.S, self.marg\n", + " )\n", + " else:\n", + " data_logp = matnorm_logp_marginal_col(\n", + " Y, self.time_cov, self.space_cov, self.B, self.marg\n", + " )\n", + "\n", + " return time_cov.logp + space_cov.logp + data_logp\n", + "\n", + " def fit(self, X, y=None, naive_init=True):\n", + " \"\"\" Compute the regression fit.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : np.array, TRs by voxels.\n", + " Brain data (note that this is Y in the math but we \n", + " call it X in the interface to maintain scikit-learn \n", + " API compatibility)\n", + " y : None\n", + " unused, here to maintain scikit-learn API compatibility\n", + " \"\"\"\n", + "\n", + " if naive_init:\n", + " # initialize to SVD (conventional PCA)\n", + " u, _, v = np.linalg.svd(X)\n", + " s_init, b_init = u[:, : self.n_features], v[: self.n_features, :]\n", + " else:\n", + " b_init = np.random.randn(self.n_features, self.n_v)\n", + " s_init = np.random.randn(self.n_t, self.n_features)\n", + "\n", + " self.B = tf.Variable(b_init, name=\"B\")\n", + " self.S = tf.Variable(s_init, name=\"S\")\n", + "\n", + " self.train_variables = [self.S] if self.dual else [self.B]\n", + " self.train_variables.extend(self.time_cov.get_optimize_vars())\n", + " self.train_variables.extend(self.space_cov.get_optimize_vars())\n", + " self.marg = CovIdentity(self.n_features)\n", + "\n", + " def lossfn(theta):\n", + " return -self.logp(X)\n", + "\n", + " val_and_grad = make_val_and_grad(lossfn, self.train_variables)\n", + " x0 = pack_trainable_vars(self.train_variables)\n", + "\n", + " opt_results = minimize(\n", + " fun=val_and_grad, x0=x0, jac=True, method=self.optMethod, **self.optCtrl\n", + " )\n", + "\n", + " unpacked_theta = unpack_trainable_vars(opt_results.x, self.train_variables)\n", + "\n", + " for var, val in zip(self.train_variables, unpacked_theta):\n", + " var.assign(val)\n", + "\n", + " if self.dual:\n", + " self.B.assign(self.transform(X, direction=\"B\"))\n", + " else:\n", + " self.S.assign(self.transform(X, direction=\"S\"))\n", + "\n", + " self.B_ = self.B.numpy()\n", + " self.S_ = self.S.numpy()\n", + "\n", + " def transform(self, X, direction=\"S\"):\n", + " \"\"\"\n", + " Transform input X using the fit model, returning \n", + " the projected time series (if direction=\"S\")\n", + " or inferred projection (if direction=\"B\"). \n", + " \n", + " Either simply requires solving a regression problem, \n", + " which can be done in closed form. \n", + " \n", + " Again, this is Y in the math but X in the code becasue\n", + " of scikit-learn\n", + " \"\"\"\n", + " if direction == \"S\":\n", + " # Sigma_s^{-1} B'\n", + " Sigma_s_btrp = self.space_cov.solve(tf.transpose(a=self.B))\n", + " # Y Sigma_s^{-1} B'\n", + " Y_Sigma_Btrp = tf.matmul(X, Sigma_s_btrp).numpy()\n", + " # (B Sigma_s^{-1} B')^{-1}\n", + " B_Sigma_Btrp = tf.matmul(self.B, Sigma_s_btrp).numpy()\n", + "\n", + " S_test = np.linalg.solve(B_Sigma_Btrp.T, Y_Sigma_Btrp.T).T\n", + "\n", + " return S_test\n", + "\n", + " elif direction == \"B\":\n", + " # S' Sigma_t^{-1} S\n", + " Strp_Sig_S = tf.transpose(self.S) @ self.time_cov.solve(self.S)\n", + " # S' Sigma_t^{-1} X\n", + " Strp_Sig_X = tf.transpose(self.S) @ self.time_cov.solve(X)\n", + " B_test = np.linalg.solve(Strp_Sig_S, Strp_Sig_X)\n", + " return B_test" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Estimated weight matrix inner product')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# regular\n", + "mn_fa = MNFactorAnalysis(time_cov=time_cov, space_cov=space_cov, n_features=components, dual=False)\n", + "\n", + "mn_fa.fit(Y_tf, naive_init=False)\n", + "\n", + "plt.plot((S @ B).flatten(),(mn_fa.S_ @ mn_fa.B_).flatten(), 'bo')\n", + "plt.xlabel(\"True (noiseless) voxel time series\")\n", + "plt.ylabel(\"Reconstructed noiseless voxel time series\")\n", + "\n", + "plt.figure()\n", + "plt.plot( (S @ S.T).flatten(),(mn_fa.S_ @ mn_fa.S_.T).flatten(), 'bo')\n", + "plt.xlabel(\"True latent response inner product\")\n", + "plt.ylabel(\"Estimated latent response inner product\")\n", + "\n", + "plt.figure()\n", + "plt.plot( (B.T @ B).flatten(), (mn_fa.B_.T @ mn_fa.B_ ).flatten(),'bo')\n", + "plt.xlabel(\"True weight matrix inner product\")\n", + "plt.ylabel(\"Estimated weight matrix inner product\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Estimated weight matrix inner product')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Dual, integrating the other way\n", + "mn_fa = MNFactorAnalysis(time_cov=time_cov, space_cov=space_cov, n_features=components, dual=True)\n", + "\n", + "mn_fa.fit(Y_tf, naive_init=False)\n", + "\n", + "plt.plot((S @ B).flatten(),(mn_fa.S_ @ mn_fa.B_).flatten(), 'bo')\n", + "plt.xlabel(\"True (noiseless) voxel time series\")\n", + "plt.ylabel(\"Reconstructed noiseless voxel time series\")\n", + "\n", + "plt.figure()\n", + "plt.plot( (S @ S.T).flatten(),(mn_fa.S_ @ mn_fa.S_.T).flatten(), 'bo')\n", + "plt.xlabel(\"True latent response inner product\")\n", + "plt.ylabel(\"Estimated latent response inner product\")\n", + "\n", + "plt.figure()\n", + "plt.plot( (B.T @ B).flatten(), (mn_fa.B_.T @ mn_fa.B_ ).flatten(),'bo')\n", + "plt.xlabel(\"True weight matrix inner product\")\n", + "plt.ylabel(\"Estimated weight matrix inner product\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Summary\n", + "\n", + "This demonstrates how `brainiak.matnormal` supports prototyping of models with kronecker-separable residuals. Again we highlight that while the specific model variants here can be implemented more efficiently, the shared and consistent framing provided by the matrix-normal framework can allow us to showcase the similarity across methods, as well as introduce a consistent idea (e.g. a particular residual structure) to different models in a consistent way. \n", + "\n", + "We invite further contributions and suggestions in helping us use `brainiak.matnormal` to blur the lines between methods-developer and methods-user. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:brainiak] *", + "language": "python", + "name": "conda-env-brainiak-py" + }, + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/real-time/README_INSTRUCTIONS.md b/docs/examples/real-time/README_INSTRUCTIONS.md new file mode 100644 index 00000000..82d39498 --- /dev/null +++ b/docs/examples/real-time/README_INSTRUCTIONS.md @@ -0,0 +1,32 @@ +## Set Up Instructions for the Real-Time fMRI Cloud-Based Framework + +Here are instructions you have to follow in order to implement our real-time fMRI cloud-based framework when running the [rtcloud_notebook jupyter notebook](https://github.com/brainiak/brainiak-aperture/blob/master/notebooks/real-time/rtcloud_notebook.ipynb). There are some things that you have to set up only once, whereas there are other things you have to do every time before you launch and run the jupyter notebook. + +### Things to do once +Before you can run this notebook, you will have to take the following steps to set up our software framework: + +1. Clone the [brainiak aperture repo](https://github.com/brainiak/brainiak-aperture.git) and the [rtcloud framework repo](https://github.com/brainiak/rt-cloud.git). The location of the repositories do not matter but you should make a note of the paths. +2. Follow [Step 1](https://github.com/brainiak/rt-cloud#step-1-install-mini-conda-and-nodejs) of the installation instructions for the rtcloud framework: Check to see if you have conda, Node.js, and NPM installed. Install these packages if necessary. +3. Create a conda environment that will be specific for the rtcloud framework and activate it: + + `cd /PATH_TO_RTCLOUD/rt-cloud` + + `conda env create -f environment.yml` + + `conda activate rtcloud` +4. Install and build node module dependencies. + + `cd /PATH_TO_RTCLOUD/rt-cloud/web` + + `npm install` + + `npm run build` + +### Things to do every time +Here are the things that you have to do every time before you launch and run this jupyter notebook: + +1. Activate the conda environment for the rtcloud framework: + + `conda activate rtcloud` +2. On the command line, create a global variable to the full path for the rtcloud framework repo. You must do this in order to use the functions we have created for the framework. And don't forget the forward slash "/" at the end. + + `export RTCLOUD_PATH=/PATH_TO_RTCLOUD/rt-cloud/` + + Double check that you did this correctly by typing the following command, which should print the *full* path to the rtcloud framework folder: `ECHO $RTCLOUD_PATH` + +### Common Issues + +- If you get a blank blue screen when you open the localhost with the web server, then you forgot to follow Step 4 above. +- The `/tmp/notebook-simdata` folder is in your root directory. To get there, do `cd /tmp`. You want to delete this `notebook-simdata` folder whenever you want to similate the synthetic data being produced in real-time. +- If `rtCommon` can't be found, then you forgot to run Step 2 of "Things to do every time" above. diff --git a/docs/examples/real-time/certs/cookie-secret b/docs/examples/real-time/certs/cookie-secret new file mode 100644 index 00000000..349adac0 --- /dev/null +++ b/docs/examples/real-time/certs/cookie-secret @@ -0,0 +1 @@ +,rAvޟZk \ No newline at end of file diff --git a/docs/examples/real-time/certs/passwd b/docs/examples/real-time/certs/passwd new file mode 100644 index 00000000..e69de29b diff --git a/docs/examples/real-time/config.toml b/docs/examples/real-time/config.toml new file mode 100644 index 00000000..48c1dab9 --- /dev/null +++ b/docs/examples/real-time/config.toml @@ -0,0 +1,30 @@ +title = 'rtCloud Tutorial' +sessionId = '20200101T120000' +subjectName = '001_synthetic' +datestr = '20200101' + +isSynthetic = true +numSynthetic = 200 +numTrainingTRs = 100 +imgDir = '/tmp/notebook-simdata' + +subjectNum = 101 +subjectDay = 1 +sessionNum = 1 +runNum = [1] +scanNum = [14] + +# Plotting settings +plotTitle = 'Realtime Plot' +plotXLabel = 'TR #' +plotYLabel = 'Classifier Prediction' +plotXRangeLow = 100 +plotXRangeHigh = 200 +plotYRangeLow = -1 +plotYRangeHigh = 1 +plotAutoRangeX = false +plotAutoRangeY = true + +# important variables about the dicom files +dicomNamePattern = "rt_{TR:03d}.dcm" +minExpectedDicomSize = 200000 diff --git a/docs/examples/real-time/finalize.py b/docs/examples/real-time/finalize.py new file mode 100644 index 00000000..07076649 --- /dev/null +++ b/docs/examples/real-time/finalize.py @@ -0,0 +1,19 @@ +"""----------------------------------------------------------------------------- + +finalize.py (Last Updated: 10/16/2020) + +The purpose of this script is to finalize the rt-cloud session. Specifically, +here we want to dowload any important files from the cloud back to the stimulus +computer and maybe even delete files from the cloud that we don't want to +stay there (maybe for privacy purposes). + +-----------------------------------------------------------------------------""" + +print("" + "-----------------------------------------------------------------------------\n" + "The finalize script has not been implemented for this project.\n\n" + "To implement, please edit finalize.py. For an example as to how you can\n" + "do this, refer to the finalize.py script in the sample project for the\n" + "rtcloud framework. Go to https://github.com/brainiak/rt-cloud.git for the\n" + "repo and navigate to projects/sample/\n" + "-----------------------------------------------------------------------------") \ No newline at end of file diff --git a/docs/examples/real-time/initialize.py b/docs/examples/real-time/initialize.py new file mode 100644 index 00000000..260969f8 --- /dev/null +++ b/docs/examples/real-time/initialize.py @@ -0,0 +1,19 @@ +"""----------------------------------------------------------------------------- + +initialize.py (Last Updated: 10/16/2020) + +The purpose of this script is to initialize the rt-cloud session. Specifically, +it will initiate any variables that need to be initiated (e.g., configuration +file) and upload any necessary files to the cloud. + +-----------------------------------------------------------------------------""" + +# print a short introduction on the internet window +print("" + "-----------------------------------------------------------------------------\n" + "The initialize script has not been implemented for this project.\n\n" + "To implement, please edit initialize.py. For an example as to how you can\n" + "do this, refer to the initialize.py script in the sample project for the\n" + "rtcloud framework. Go to https://github.com/brainiak/rt-cloud.git for the\n" + "repo and navigate to projects/sample/\n" + "-----------------------------------------------------------------------------") \ No newline at end of file diff --git a/docs/examples/real-time/rtcloud_notebook.ipynb b/docs/examples/real-time/rtcloud_notebook.ipynb new file mode 100644 index 00000000..72bb1dc6 --- /dev/null +++ b/docs/examples/real-time/rtcloud_notebook.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Implementing a Real-Time fMRI Cloud-Based Framework\n", + "\n", + "Authors: Grant Wallace ([gwallace@princeton.edu](mailto:gwallace@princeton.edu)) and Paula P. Brooks ([paulapbrooks@gmail.com](mailto:paulapbrooks@gmail.com))\n", + "\n", + "## Overview\n", + "This notebook walks through an example using our cloud-based software framework for real-time fMRI studies, henceforth referred to as **rtcloud framework**. We have created a sample script (sample.py) in this notebook directory which builds a two-class classifier on a region of interest (ROI). This notebook will generate synthetic data for training and classification using the BrainIAK fmrisim_real_time_generator function. **Readers who are interested in running full-scale real-time fMRI studies using this framework should refer to the main [RT-Cloud Repo](https://github.com/brainiak/rt-cloud)**.\n", + "\n", + "We will begin wrapping the sample.py script within the rtcloud projectInterface. In a normal deployment the projectInterface (and sample.py) would then run in the cloud and the scanner images would be sent to the cloud where our sample.py script would build the classifier model and do classification. The projectInterface handles remote file communication for reading the scanner images and providing the classification results. It also has a web-based user interface for viewing and controlling the experiment and changing settings. In this notebook the different process all run on the the computer that jupyter is running on.\n", + "\n", + "In the steps below, we will first start the projectInterface which will watch for dicom files to process. We will then start the synthetic data generator which will generate a new dicom image every 2 seconds. And finally we will start a web browser within this notebook for controlling the experiment. Once you start the web interface you can click the 'Run' button to start the sample.py script watching for and processing images via the projectInterface. (You can also open the web interface on a different tab in your browser, http://localhost:8889.)\n", + "\n", + "## Annotated Bibliography\n", + "\n", + "1. Mennen, A.C., Turk-Browne, N.B., Wallace, G., Seok, D., Jaganjac, A., Stock, J., deBettencourt, M.T., Cohen, J.D., Norman, K.A. & Sheline, Y.I. (2020). Cloud-based fMRI neurofeedback to reduce the negative attentional bias in depression: a proof-of-concept study. *Biological Psychiatry: Cognitive Neuroscience and Neuroimaging.* [`link`](https://doi.org/10.1016/j.bpsc.2020.10.006)\n", + "*Describes the first implementation of the rt-cloud software framework in a closed-loop fMRI study that provided continuous neurofeedback to participants based on a multivariate pattern classifier.*\n", + "\n", + "## Table of Contents\n", + "\n", + "* [Before Running This Notebook](#setting_up)\n", + "* [Import Necessary Modules and Declare Important Variables](#import_modules)\n", + "* [Step 1: Start the ProjectInterface Web Server](#start_ProjectInterface)\n", + "* [Step 2: Start the Synthetic Data Generator](#start_DataGenerator)\n", + "* [Step 3: Open the Web Server on the localhost](#open_localhost)\n", + "* [Summary](#summary)\n", + "\n", + "## Before Running This Notebook \n", + "\n", + "Before you are able to run this notebook, you have to complete the installation instructions found in the accompanying [instructions README](https://github.com/brainiak/brainiak-aperture/blob/master/notebooks/real-time/README_INSTRUCTIONS.md). **Also, remember that you have to complete the following steps every time before you are able to run this notebook:**\n", + "\n", + "1. Activate the conda environment for the rtcloud framework:\n", + "```\n", + "conda activate rtcloud\n", + "```\n", + "2. On the command line, create a global variable to the full path for the rtcloud framework repo. You must do this in order to use the functions we have created for the framework. And don't forget the forward slash \"/\" at the end.\n", + "```\n", + "export RTCLOUD_PATH=/PATH_TO_RTCLOUD/rt-cloud/\n", + "```\n", + "Double check that you did this correctly by typing the following command. \n", + "```\n", + "ECHO $RTCLOUD_PATH\n", + "```\n", + "This should print the *full* path to the rtcloud framework folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# If rt-cloud repo is present in local directory and RTCLOUD_PATH is not already set, \n", + "# then set RTCLOUD_PATH to the local repo.\n", + "import os\n", + "if 'RTCLOUD_PATH' not in os.environ and os.path.exists('rt-cloud'):\n", + " os.environ['RTCLOUD_PATH'] = os.path.abspath('rt-cloud')\n", + "\n", + "!echo $RTCLOUD_PATH" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Necessary Modules and Declare Important Variables " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings; warnings.simplefilter('ignore')\n", + "\n", + "#---- Import the necessary python modules\n", + "import sys\n", + "import threading\n", + "import argparse\n", + "import toml\n", + "\n", + "#---- Load important brainiak modules\n", + "import brainiak.utils.fmrisim_real_time_generator as sim\n", + "\n", + "#---- Load important rtcloud modules\n", + "# add the path to the rtcloud repo to PYTHONPATH to access rtCommon functions\n", + "path_to_rtcloud = os.getenv('RTCLOUD_PATH')\n", + "if path_to_rtcloud == None:\n", + " print(\"Please set RTCLOUD_PATH, see instructions\")\n", + " raise ValueError\n", + "sys.path.append(path_to_rtcloud)\n", + "\n", + "from rtCommon.projectServer import ProjectServer\n", + "from rtCommon.structDict import StructDict\n", + "\n", + "#---- Declare and append important paths \n", + "# declare the path to this jupyter notebook\n", + "path_to_notebook = os.getcwd() # check and change notebook path as needed\n", + "\n", + "# declare the scripts that will be wrapped by the projectInterface and \n", + "# accessed through the webServer\n", + "scriptToRun = os.path.join(path_to_notebook, 'sample.py')\n", + "initScript = os.path.join(path_to_notebook, 'initialize.py')\n", + "finalizeScript = os.path.join(path_to_notebook, 'finalize.py')\n", + "configFile = os.path.join(path_to_notebook, 'sample-config.toml') \n", + "\n", + "#---- Declare the total number of TRs (timepoints) you want to generate, and how many should be training\n", + "num_TRs = 200\n", + "num_training = 100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Start the ProjectInterface Web Server " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#---- Set up the config and parameters for this rtcloud tutorial\n", + "\n", + "# NOTE: you can also change these parameters in the Settings tab on the web server\n", + "config = StructDict({\n", + " 'title' : 'rtCloud Tutorial', # study name\n", + " 'sessionId' : '20200101T120000', # session ID on the scanner\n", + " 'subjectName' : '001_synthetic', # subject ID on the scanner\n", + " 'datestr' : '20200101', # session date\n", + " \n", + " 'isSynthetic' : True, # are we using synthetic data?\n", + " 'numSynthetic' : num_TRs, # total number of synthetic TRs\n", + " 'numTrainingTRs' : num_training, # number of TRs used for training the classifier\n", + " 'imgDir' : '/tmp/notebook-simdata', # location of synthetic TRs\n", + " \n", + " 'subjectNum' : 101, # subject number\n", + " 'subjectDay' : 1, # study day (relevant if multi-day study)\n", + " 'sessionNum' : 1, # session number\n", + " 'runNum' : [1], # list of scanning runs that were done during the session\n", + " 'scanNum' : [14], # list of corresponding scan numbers for the runs\n", + "\n", + " # Plotting settings\n", + " 'plotTitle' : 'Realtime Plot', # plot title\n", + " 'plotXLabel' : 'TR #', # plot x-axis label\n", + " 'plotYLabel' : 'Classifier Prediction', # plot y-axis label\n", + " 'plotXRangeLow' : num_training, # plot x-axis minimum limit\n", + " 'plotXRangeHigh' : num_TRs, # plot x-axis maximum limit\n", + " 'plotYRangeLow' : -1, # plot y-axis minimum limit\n", + " 'plotYRangeHigh' : 1, # plot y-axis maximum limit\n", + " 'plotAutoRangeX' : False, # do we want the x-axis limit to automatically fit the range?\n", + " 'plotAutoRangeY' : True, # do we want the x-axis limit to automatically fit the range?\n", + "\n", + " # important variables about the dicom files\n", + " 'dicomNamePattern' : \"rt_{TR:03d}.dcm\", # naming pattern for the dicom files\n", + " 'minExpectedDicomSize' : 200000, # expected size for the dicom data\n", + "})\n", + "\n", + "with open(configFile, 'w') as fp:\n", + " toml.dump(config, fp)\n", + "\n", + "args = argparse.Namespace()\n", + "args.projectName = 'sample'\n", + "args.projectDir = path_to_notebook\n", + "args.mainScript = scriptToRun\n", + "args.initScript = initScript\n", + "args.finalizeScript = finalizeScript\n", + "args.dataRemote = False\n", + "args.subjectRemote = False\n", + "args.test = True\n", + "args.config = config\n", + "args.port = 8889\n", + "\n", + "\n", + "#---- Start the project server\n", + "def runProjectServer(args):\n", + " projectServer = ProjectServer(args)\n", + " projectServer.start()\n", + "\n", + "\n", + "try:\n", + " project_thread = threading.Thread(name='projectServer', \n", + " target=runProjectServer,\n", + " args=(args,))\n", + " project_thread.setDaemon(True)\n", + " project_thread.start()\n", + "except RuntimeError as err:\n", + " # ignore event loop already running error\n", + " if str(err) != 'This event loop is already running':\n", + " raise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "\n", + "**IMPORTANT:**\n", + "\n", + "You can only run this cell to start the projectInterface web server only once or else you will get the following runtime error: \n", + "```\n", + "Web Server already running\n", + "```\n", + "If you want to re-start the web server, you have to first SHUT DOWN the kernel. Instructions for doing this can be found [here](https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/execute.html#close-a-notebook-kernel-shut-down).\n", + "\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Start the Synthetic Data Generator \n", + "\n", + "We will be using a BrainIAK function to create synthetic fMRI data. After you run the following cell, you can execute `sim_settings` in a separate cell to take a look at the different parameter settings. For instance, you will find that the synthetic data is being produced at a rate of 2 seconds per TRs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#---- Set up the parameters for the synthetic data generator\n", + "\n", + "sim_settings = sim.default_settings\n", + "sim_settings['save_dicom'] = True\n", + "sim_settings['save_realtime'] = True\n", + "sim_settings['numTRs'] = num_TRs\n", + "sim_settings['different_ROIs'] = True\n", + "sim_settings['scale_percentage'] = 1\n", + "\n", + "outdir = '/tmp/notebook-simdata'\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir)\n", + "\n", + "#---- Run sim.generate_data(outdir, sim_settings) as a thread\n", + "\n", + "syndata_thread = threading.Thread(name='syndata', \n", + " target=sim.generate_data, \n", + " args=(outdir, sim_settings))\n", + "syndata_thread.setDaemon(True)\n", + "syndata_thread.start()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "**IMPORTANT:**\n", + "\n", + "You can only run this cell to generate the synthetic data in \"real-time\" once unless you delete the data that you have already created. Otherwise, all the data (which is found in the `/tmp/notebook-simdata` folder) will be automatically available when you open the web server, instead of having the File Watcher wait for incoming data one TR at a time.\n", + "\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Open the Web Server on the localhost " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here you will open the web-based user interface to view and control the real-time experiment, where a classification analysis will be performed. If you are interested in learning more about the details of a classifier analysis in real-time, take a look at the [real-time tutorial](https://brainiak.org/tutorials/13-real-time/) on the BrainIAK website. You will also be able to change the settings in the \"Settings\" tab.\n", + "\n", + "The first time you open the web server, either in the cell below or in a separate browser tab, you will be prompted to enter a username and password. In this demonstration, you will use \"test\" for both. Once you have logged in you will be on the Run tab. You can start the sample.py script running and waiting for dicom data to process by clicking the 'run' button within the webpage 'Run' tab. Then you will see the output as the script progresses within the view pane of the Run tab.\n", + "\n", + "If you want to re-run the sample.py script after making changes, you will most likely get the following error message: `Error: Client thread already runnning, skipping new request`. You will have to restart the kernel like in step 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%html\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Alternate Step 3: Run the classification script from command line" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of running the classification script from the web browser (as above), it can be run directly by running the scripts main function. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the classification script directly by importing the scripts main function.\n", + "from sample import main\n", + "main(['-c', configFile])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary \n", + "\n", + "You have now completed running a real-time experiment using a distributed computing pipeline (managed by the projectInterface). The synthetic data was sent to the sample.py script in real-time as it was generated, and the script started by building a classifier and then performing classification.\n", + "\n", + "As a next step you can try modifying or using your own script in place of sample.py, and you can also try running the projectInterface on a cloud VM which eliminates the need for expensive computer hardware within the control room.\n", + "\n", + "We're excited to see what interesting real-time experiments you will create!\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/real-time/sample.py b/docs/examples/real-time/sample.py new file mode 100644 index 00000000..ea30233b --- /dev/null +++ b/docs/examples/real-time/sample.py @@ -0,0 +1,284 @@ +"""----------------------------------------------------------------------------- + +sample.py (Last Updated: 01/26/2021) + +The purpose of this script is to run a sample project for the BrainIAK Aperture +paper. This sample project script will be wrapped by the projectInterface and +it will be made accessible on the Web Server. + +The purpose of this *particular* script is to demonstrated how you can use the +various scripts, functions, etc. we have developed for your use! The functions +we will reference live in 'rt-cloud/rtCommon/'. + +Finally, this script is called from the projectServer which is started in the +jupyter notebook. + +-----------------------------------------------------------------------------""" + + +# add the full path to the rtcloud +import os +path_to_rtcloud = os.getenv('RTCLOUD_PATH') +if path_to_rtcloud == None: + print("Please set RTCLOUD_PATH, see instructions") + raise ValueError + +# import other important modules +import sys +import time +import argparse +import numpy as np +import nibabel as nib +import scipy.io as sio +from nilearn.input_data import NiftiMasker +from sklearn import preprocessing +from sklearn import svm +import nilearn +from nilearn.masking import apply_mask +from scipy.stats import zscore +from sklearn.preprocessing import StandardScaler + +import warnings # ignore warnings when importing dicomreaders below +with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=UserWarning) + from nibabel.nicom import dicomreaders + +# obtain full path for current directory: '.../rt-cloud/projects/sample' +currPath = os.path.dirname(os.path.realpath(__file__)) +sys.path.append(path_to_rtcloud) +# import project modules from rt-cloud +from rtCommon.utils import loadConfigFile +from rtCommon.clientInterface import ClientInterface +from rtCommon.imageHandling import readRetryDicomFromDataInterface, getDicomFileName, convertDicomImgToNifti, convertDicomFileToNifti, readNifti, convertDicomFileToNifti + +def doRuns(cfg, dataInterface, subjInterface, webInterface): + """ + This function is called by 'main()' below. Here, we use the 'dataInterface' + to read in dicoms (presumably from the scanner, but here it's from a folder + with previously collected dicom files), doing some sort of analysis in the + cloud, and then sending the info to the web browser. + + INPUT: + [1] cfg (configuration file with important variables) + [2] dataInterface (this will allow a script from the cloud to access files + from the stimulus computer, which receives dicom files directly + from the Siemens console computer) + [3] subjInterface - this allows sending feedback (e.g. classification results) + to a subjectService running on the presentation computer to provide + feedback to the subject (and optionally get their response). + OUTPUT: + None. + """ + + # variables we'll use throughout + scanNum = cfg.scanNum[0] + runNum = cfg.runNum[0] + + # obtain the path for the directory where the subject's dicoms live + cfg.dicomDir = cfg.imgDir + print("Location of the subject's dicoms: %s\n" %cfg.dicomDir) + + # Initialize a watch for the entire dicom folder using the function 'initWatch' + # in dataInterface. (Later we will use watchFile() to look for a specific dicom) + # INPUT: + # [1] cfg.dicomDir (where the subject's dicom files live) + # [2] cfg.dicomNamePattern (the naming pattern of dicom files) + # [3] cfg.minExpectedDicomSize (a check on size to make sure we don't + # accidentally grab a dicom before it's fully acquired) + dataInterface.initWatch(cfg.dicomDir, cfg.dicomNamePattern, + cfg.minExpectedDicomSize) + + #We will use the function plotDataPoint in webInterface whenever we + # want to send values to the web browser so that they can be plotted in the + # --Data Plots-- tab. + #However at the start of a run we will want to clear the plot, and we can use + #clearRunPlot(runId), or clearAllPlots() also in the webInterface object. + print("\n\nClear any pre-existing plot for this run using 'clearRunPlot(runNum)'") + webInterface.clearRunPlot(runNum) + print('' + '###################################################################################') + + # declare the total number of TRs + num_trainingData = cfg.numTrainingTRs + num_total_TRs = cfg.numSynthetic + + for this_TR in np.arange(num_total_TRs): + # declare variables that are needed to use 'readRetryDicomFromDataInterface' + timeout_file = 5 # small number because of demo, can increase for real-time + + # use 'getDicomFileName' from 'imageHandling.py' to obtain the filename + # of the dicom data you want to get... which is useful considering how + # complicated these filenames can be! + # INPUT: + # [1] cfg (config parameters) + # [2] scanNum (scan number) + # [3] fileNum (TR number, which will reference the correct file) + # OUTPUT: + # [1] fullFileName (the filename of the dicom that should be grabbed) + fileName = getDicomFileName(cfg, scanNum, this_TR) + + # Use 'readRetryDicomFromDataInterface' in 'imageHandling.py' to wait for dicom + # files to be written by the scanner (uses 'watchFile' internally) and then + # reading the dicom file once it is available. + #INPUT: + # [1] dataInterface (allows a cloud script to access files from the + # control room computer) + # [2] filename (the dicom file we're watching for and want to load) + # [3] timeout (time spent waiting for a file before timing out) + #OUTPUT: + # [1] dicomData (with class 'pydicom.dataset.FileDataset') + dicomData = readRetryDicomFromDataInterface(dataInterface, fileName, + timeout_file) + + # We can use the 'convertDicomFileToNifti' function with dicomData as + # input to get the data in NifTi format + base, ext = os.path.splitext(fileName) + assert ext == '.dcm' + niftiFilename = base + '.nii' + convertDicomFileToNifti(fileName, niftiFilename) + niftiObject = readNifti(niftiFilename) + + # declare various things if it's the first TR + if this_TR == 0: + # load the labels and mask + labels = np.load(os.path.join(cfg.imgDir, 'labels.npy')) + print(os.path.join(cfg.imgDir, 'labels.npy')) + ROI_nib = nib.load(os.path.join(currPath,'ROI_mask.nii.gz')) + ROI_mask = np.array(ROI_nib.dataobj) + mask_nib = nib.Nifti1Image(ROI_mask.T, affine=niftiObject.affine) + # declare the number of TRs we will shift the data to account for the hemodynamic lag + num_shiftTRs = 3 + # shift the labels to account for hemodynamic lag + shifted_labels = np.concatenate([np.full((num_shiftTRs, 1), np.nan),labels]) + # set up a matrix that will hold all of the preprocessed data + preprocessed_data = np.full((num_total_TRs, int(ROI_mask.sum())), np.nan) + + # preprocess the training data by applying the mask + preprocessed_data[this_TR,:] = np.ravel(apply_mask(niftiObject,mask_nib).reshape(int(ROI_mask.sum()),1)) + + ## Now we divide into one of three possible steps + + # STEP 1: collect the training data + if this_TR < num_trainingData: + print('Collected training data for TR %s' %this_TR) + # STEP 2: train the SVM model + elif this_TR == num_trainingData: + print('' + '###################################################################################') + print('Done collecting training data! \nStart training the classifier.') + + # snapshot of time to keep track of how long it takes to train the classifier + start_time = time.time() + + scaler = StandardScaler() + X_train = preprocessed_data[num_shiftTRs:num_trainingData] + y_train = shifted_labels[num_shiftTRs:num_trainingData].reshape(-1,) + # we don't want to include rest data + X_train_noRest = X_train[y_train != 0] + y_train_noRest = y_train[y_train != 0] + # and we want to zscore the bold data + X_train_noRest_zscored = scaler.fit_transform(X_train_noRest) + clf = svm.SVC(kernel='linear', C=0.01, class_weight='balanced') + clf.fit(X_train_noRest_zscored, y_train_noRest) + + # print out the amount of time it took to train the classifier + print('Classifier done training! Time it took: %.2f s' %(time.time() - start_time)) + print('' + '###################################################################################') + elif this_TR > num_trainingData: + # apply the classifier to new data to obtain prediction IF not a rest trial + if shifted_labels[this_TR] != 0: + prediction = clf.predict(scaler.transform(preprocessed_data[this_TR,:].reshape(1,-1))) + print(f'Plotting classifier prediction for TR {this_TR}: {prediction}') + webInterface.plotDataPoint(runNum, int(this_TR), float(prediction)) + + # To send feedback for the subject at the presentation computer use + # the subjInterface as shown below. For this demo there is no + # presentation computer so we won't actually it. + # subjInterface.setResult(runNum, int(this_TR), float(prediction)) + else: + print(f'Skipping classification because it is a rest trial') + + + X_test = preprocessed_data[num_trainingData+1:] + y_test = shifted_labels[num_trainingData+1:num_total_TRs].reshape(-1,) + # we don't want to include the rest data + X_test_noRest = X_test[y_test != 0] + y_test_noRest = y_test[y_test != 0] + # and we want to zscore the bold data + X_test_noRest_zscored = scaler.transform(X_test_noRest) + accuracy_score = clf.score(X_test_noRest_zscored, y_test_noRest) + print('Accuracy of classifier on new data: %s' %accuracy_score) + # print(y_test_noRest) + # print(clf.predict(X_test_noRest_zscored)) + + print("" + "###################################################################################\n" + "REAL-TIME EXPERIMENT COMPLETE!") + + return + +def main(argv=None): + """ + This is the main function that is called when you run 'sample.py'. + + Here, you will load the configuration settings specified in the toml configuration + file. It will initiate the class clientInterface which automatically connects + to the projectServer and allows making requests, such as to get DICOM or NifTi + data using the dataInterface contained in clientInterface. + It will then call the function 'doRuns' to actually start doing the experiment. + """ + + # define the parameters that will be recognized later on to set up fileIterface + argParser = argparse.ArgumentParser() + argParser.add_argument('--config', '-c', default=None, type=str, + help='experiment config file (.json or .toml)') + argParser.add_argument('--runs', '-r', default='', type=str, + help='Comma separated list of run numbers') + argParser.add_argument('--scans', '-s', default='', type=str, + help='Comma separated list of scan number') + args = argParser.parse_args(argv) + + # load the experiment configuration file + cfg = loadConfigFile(args.config) + + # obtain paths for important directories (e.g. location of dicom files) + if cfg.imgDir is None: + cfg.imgDir = os.path.join(currPath, 'dicomDir') + cfg.codeDir = currPath + + # Make an RPC connection to the projectServer + # The 'dataInterface' class allows you to read and write files from the + # control room computer to this script running in the cloud. + # The 'subjInterface' class will allow us to send classification results + # as feedback to the subject at the presentation computer. + clientRPC = ClientInterface() + dataInterface = clientRPC.dataInterface + subjInterface = clientRPC.subjInterface + webInterface = clientRPC.webInterface + + # now that we have the necessary variables, call the function 'doRuns' in order + # to actually start reading dicoms and doing your analyses of interest! + # INPUT: + # [1] cfg (configuration file with important variables) + # [2] dataInterface (this will allow a script from the cloud to access files + # from the stimulus computer that receives dicoms from the Siemens + # console computer) + # [3] subjInterface - this allows sending feedback (e.g. classification results) + # to a subjectService running on the presentation computer to provide + # feedback to the subject (and optionally get their response). + # [4] webInterface - this allows updating information on the experimenter webpage. + # For example to plot data points, or update status messages. + doRuns(cfg, dataInterface, subjInterface, webInterface) + + return 0 + + +if __name__ == "__main__": + """ + If 'sample.py' is invoked as a program, then actually go through all of the portions + of this script. This statement is not satisfied if functions are called from another + script using "from sample.py import FUNCTION" + """ + main() + sys.exit(0) diff --git a/docs/examples/srm/SRM.ipynb b/docs/examples/srm/SRM.ipynb new file mode 100644 index 00000000..a1cb4c7d --- /dev/null +++ b/docs/examples/srm/SRM.ipynb @@ -0,0 +1,563 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Shared response model\n", + "\n", + "Authors: Javier Turek ([javier.turek@intel.com](mailto:javier.turek@intel.com)), Samuel A. Nastase ([sam.nastase@gmail.com](mailto:sam.nastase@gmail.com)), Hugo Richard ([hugo.richard@ens-lyon.fr](mailto:hugo.richard@ens-lyon.fr))\n", + "\n", + "This notebook provides interactive examples of functional alignment using the shared response model (SRM; [Chen et al., 2015](https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model)). BrainIAK includes several variations on the SRM algorithm, but here we focus on the core probabilistic [`SRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.srm.SRM) implementation. The goal of the SRM is to capture shared responses across participants performing the same task in a way that accommodates individual variability in response topographies ([Haxby et al., 2020](https://doi.org/10.7554/eLife.56601)). Given data that is synchronized in the temporal dimension across a group of subjects, SRM computes a low dimensional *shared* feature subspace common to all subjects. The method also constructs orthogonal weights to map between the shared subspace and each subject's idiosyncratic voxel space. This notebook accompanies the manuscript \"BrainIAK: The Brain Imaging Analysis Kit\" by Kumar and colleagues (2020).\n", + "\n", + "The functional alignment ([`funcalign`](https://brainiak.org/docs/brainiak.funcalign.html)) module includes the following variations of SRM:\n", + "* [`SRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.srm.SRM): A probabilistic version of SRM\n", + "* [`DetSRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.srm.DetSRM): A deterministic version of SRM\n", + "* [`RSRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.rsrm.RSRM): Robust SRM for better filtering idiosyncratic components and outliers in data\n", + "* [`SSSRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.sssrm.SSSRM): Semi-supervised SRM for labeled data \n", + "* [`FastSRM`](https://brainiak.org/docs/brainiak.funcalign.html#brainiak.funcalign.fastsrm.FastSRM): A faster version of SRM with reduced memory demands" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Annotated bibliography\n", + "1. Chen, P. H. C., Chen, J., Yeshurun, Y., Hasson, U., Haxby, J., & Ramadge, P. J. (2015). A reduced-dimension fMRI shared response model. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, R. Garnett (Eds.), *Advances in Neural Information Processing Systems, vol. 28* (pp. 460-468). [`link`](https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model) *Introduces the SRM method of functional alignment with several performance benchmarks.*\n", + "\n", + "2. Haxby, J. V., Guntupalli, J. S., Nastase, S. A., & Feilong, M. (2020). Hyperalignment: modeling shared information encoded in idiosyncratic cortical topographies. *eLife*, *9*, e56601. [`link`](https://doi.org/10.7554/eLife.56601) *Recent review of hyperalignment and related functional alignment methods.*\n", + "\n", + "3. Chen, J., Leong, Y. C., Honey, C. J., Yong, C. H., Norman, K. A., & Hasson, U. (2017). Shared memories reveal shared structure in neural activity across individuals. *Nature Neuroscience*, *20*(1), 115-125. [`link`](https://doi.org/10.1038/nn.4450) *SRM is used to discover the dimensionality of shared representations across subjects.*\n", + "\n", + "4. Nastase, S. A., Liu, Y. F., Hillman, H., Norman, K. A., & Hasson, U. (2020). Leveraging shared connectivity to aggregate heterogeneous datasets into a common response space. *NeuroImage*, *217*, 116865. [`link`](https://doi.org/10.1016/j.neuroimage.2020.116865) *This paper demonstrates that applying SRM to functional connectivity data can yield a shared response space across disjoint datasets with different subjects and stimuli.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Table of contents\n", + "- [Example fMRI data and atlas](#Example-fMRI-data-and-atlas)\n", + "- [Estimating the SRM](#Estimating-the-SRM)\n", + "- [Between-subject time-segment classification](#Between-subject-time-segment-classification)\n", + "- [Summary](#Summary)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import necessary python modules\n", + "from glob import glob\n", + "import nibabel as nib\n", + "import numpy as np\n", + "from nilearn.plotting import plot_stat_map\n", + "from scipy.stats import zscore\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import brainiak.funcalign.srm\n", + "from brainiak.fcma.util import compute_correlation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example fMRI data and atlas\n", + "To work through the SRM functionality, we use an fMRI dataset collected while participants listened to a spoken story called \"[I Knew You Were Black](https://themoth.org/stories/i-knew-you-were-black)\" by Carol Daniel. These data are available as part of the publicly available [Narratives](https://github.com/snastase/narratives) collection ([Nastase et al., 2019](https://openneuro.org/datasets/ds002345)). Here, we download a pre-packaged subset of the data from Zenodo. These data have been preprocessed using fMRIPrep with confound regression in AFNI. We apply the SRM to a region of interest (ROI) comprising the \"temporal parietal\" network according to a cortical parcellation containing 400 parcels from Schaefer and colleagues ([2018](https://doi.org/10.1093/cercor/bhx179))." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2020-12-07 02:06:15-- https://zenodo.org/record/4300825/files/brainiak-aperture-srm-data.tgz\n", + "Resolving zenodo.org (zenodo.org)... 137.138.76.77\n", + "Connecting to zenodo.org (zenodo.org)|137.138.76.77|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 9927319659 (9.2G) [application/octet-stream]\n", + "Saving to: ‘brainiak-aperture-srm-data.tgz’\n", + "\n", + "brainiak-aperture-s 100%[===================>] 9.25G 4.37MB/s in 13m 37s \n", + "\n", + "2020-12-07 02:20:30 (11.6 MB/s) - ‘brainiak-aperture-srm-data.tgz’ saved [9927319659/9927319659]\n", + "\n" + ] + } + ], + "source": [ + "# Download and extract example data from Zenodo\n", + "!wget -nc https://zenodo.org/record/4300825/files/brainiak-aperture-srm-data.tgz\n", + "!tar --skip-old-files -xzf brainiak-aperture-srm-data.tgz\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Get filenames for example data and atlas\n", + "data_fns = sorted(glob('brainiak-aperture-srm-data/sub-*_task-black_*bold.nii.gz'))\n", + "atlas_fn = 'brainiak-aperture-srm-data/Schaefer2018_400Parcels_17Networks_order_FSLMNI152_2.5mm.nii.gz'\n", + "\n", + "# Load in the Schaefer 400-parcel atlas\n", + "atlas_nii = nib.load(atlas_fn)\n", + "atlas_img = atlas_nii.get_fdata()\n", + "\n", + "# Left temporal parietal ROI labels\n", + "parcel_labels = [195, 196, 197, 198, 199, 200]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Load in functional data and mask with \"temporal parietal\" ROI\n", + "data = []\n", + "for data_fn in data_fns:\n", + " voxel_data = nib.load(data_fn).get_fdata()\n", + " \n", + " # Take union of all parcels (brain areas) comprising the full ROI \n", + " roi_data = np.column_stack([voxel_data[atlas_img == parcel, :].T\n", + " for parcel in parcel_labels])\n", + " data.append(roi_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The left \"temporal parietal\" ROI comprises auditory association\n", + "cortex extending from anterior superior temporal cortex to the\n", + "temporoparietal junction.\n" + ] + } + ], + "source": [ + "# Visualize the left temporal parietal ROI\n", + "sns.set(palette='colorblind')\n", + "roi_img = np.zeros(atlas_img.shape)\n", + "for parcel in parcel_labels:\n", + " roi_img[atlas_img == parcel] = 1\n", + "\n", + "# Convert to a NIfTI image for visualization with Nilearn\n", + "roi_nii = nib.Nifti1Image(roi_img, atlas_nii.affine, atlas_nii.header)\n", + "\n", + "# Plot plot left temporal parietal ROI\n", + "plot_stat_map(roi_nii, cmap='tab10_r', cut_coords=(-53, -46, 10),\n", + " colorbar=False, title='left temporal parietal ROI');\n", + "plt.show()\n", + "\n", + "# Print short \"figure caption\" describing visualization\n", + "print('The left \"temporal parietal\" ROI comprises auditory '\n", + " \"association\\ncortex extending from anterior superior \"\n", + " \"temporal cortex to the\\ntemporoparietal junction.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once data is loaded, we divide the data into two halves for a two fold validation.\n", + "We will use one half for training SRM and the other for testing its performance.\n", + "Then, we normalize the data each half." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the number of subjects and TRs\n", + "n_subjects = len(data)\n", + "n_trs = data[0].shape[0]\n", + "\n", + "# Set a train/test split ratio\n", + "train_test_ratio = .5\n", + "test_size = int(n_trs * train_test_ratio)\n", + "\n", + "# Split/compile data into training and test halves\n", + "train_data = []\n", + "test_data = []\n", + "for subject in np.arange(n_subjects):\n", + " \n", + " # Take the first chunk of TRs as training\n", + " train_data.append(zscore(data[subject][:-test_size, :], axis=0).T)\n", + " \n", + " # Take the second chunk of TRs as testing\n", + " test_data.append(zscore(data[subject][-test_size:, :], axis=0).T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Estimating the SRM\n", + "Next, we train the SRM on the training data. We need to specify desired dimension of the shared feature space. Although we simply use 50 features, the optimal number of dimensions can be found using grid search with cross-validation. We also need to specify a number of iterations to ensure the SRM algorithm converges." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting SRM\n", + "SRM has been fit\n", + "Share response shape: 50 Features x 275 Time-points\n" + ] + } + ], + "source": [ + "# Set the number of features of shared space and number of iterations\n", + "features = 50\n", + "n_iter = 10\n", + "\n", + "# Create an SRM object\n", + "srm = brainiak.funcalign.srm.SRM(n_iter=n_iter, features=features)\n", + "\n", + "# Fit the SRM data\n", + "print('Fitting SRM')\n", + "srm.fit(train_data)\n", + "print('SRM has been fit')\n", + "print(f'Share response shape: {srm.s_.shape[0]} '\n", + " f'Features x {srm.s_.shape[1]} Time-points')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After training SRM, we obtain a shared response $S$ that contains the values of the features for each TR, and a set of weight matrices $W_i$ that project from the shared subspace to each subject's idiosyncratic voxel space. Let us check the orthogonal property of the weight matrix $W_i$ for a subject. We visualize $W_i^TW_i$, which should be the identity $I$ matrix with shape equal to the number of features we selected." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weight matrix shape: 935 Voxels x 50 Features\n", + "\n", + "This test confirms that the weight matrix for subject 0 is orthogonal.\n" + ] + } + ], + "source": [ + "# Use the first subject as an example\n", + "subject = 0\n", + "\n", + "sns.set_style('white')\n", + "fig, ax = plt.subplots(1)\n", + "m = ax.matshow(srm.w_[subject].T.dot(srm.w_[subject]))\n", + "ax.set_title(f'Weight matrix orthogonality for subject {subject}', pad=10)\n", + "ax.set_xlabel('SRM features')\n", + "ax.set_ylabel('SRM features')\n", + "ax.tick_params(length=0)\n", + "cbar = fig.colorbar(m, ax=ax, ticks=[0, 1])\n", + "cbar.ax.tick_params(length=0)\n", + "plt.show()\n", + "\n", + "print(f'Weight matrix shape: {srm.w_[subject].shape[0]} '\n", + " f'Voxels x {srm.w_[subject].shape[1]} Features\\n')\n", + "\n", + "# Check against identity matrix\n", + "if np.allclose(np.identity(features), srm.w_[subject].T.dot(srm.w_[subject])):\n", + " print(\"This test confirms that the weight matrix for \"\n", + " f\"subject {subject} is orthogonal.\")\n", + "else:\n", + " print(\"Weight matrix is not orthogonal.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Between-subject time-segment classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we trained SRM above, we learned the weight matrices $W_i$ and the shared response $S$ for the training data. The weight matrices further allow us to convert new data to the shared feature space. We call the `transform()` function to transform test data for each subject into the shred space." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Transform subject-space test data into shared space\n", + "test_shared = srm.transform(test_data)\n", + "\n", + "# z-score the transformed test data\n", + "test_shared = [zscore(ts, axis=1) for ts in test_shared]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We evaluate the performance of the SRM using a between-subject time-segment classification (or \"time-segment matching\") analysis with leave-one-subject-out cross-validation (e.g. [Haxby et al., 2011](https://doi.org/10.1016/j.neuron.2011.08.026); [Chen et al., 2015](https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model). The function receives the data from `N` subjects with a specified window size `win_size` for the time segments. A segment is the concatenation of `win_size` TRs. Then, using the averaged data from `N-1` subjects it tries to match the segments from the left-out subject to the right position. The function returns the average accuracy across segments for each subject." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def time_segment_classification(data, win_size=10): \n", + " n_subjects = len(data)\n", + " (n_features, n_trs) = data[0].shape\n", + " accuracy = np.zeros(shape=n_subjects)\n", + " n_segments = n_trs - win_size + 1\n", + " \n", + " # Set up container for training data\n", + " train_data = np.zeros((n_features * win_size, n_segments), order='f')\n", + " \n", + " # Training data (includes test data, but will be removed)\n", + " for m in range(n_subjects):\n", + " for w in range(win_size):\n", + " train_data[w * n_features:(w + 1) * n_features, :] += \\\n", + " data[m][:, w:(w + n_segments)]\n", + " \n", + " # Analyze each subject (leave-one-out)\n", + " print(\"Between-subject time-segment classification accuracy \"\n", + " \"for each subject:\", end=' ')\n", + " for test_subject in range(n_subjects):\n", + " test_data = np.zeros((n_features * win_size, n_segments), order='f')\n", + " for w in range(win_size):\n", + " test_data[w * n_features:(w + 1) * n_features, :] = \\\n", + " data[test_subject][:, w:(w + n_segments)]\n", + "\n", + " A = np.nan_to_num(zscore((train_data - test_data), axis=0))\n", + " B = np.nan_to_num(zscore(test_data, axis=0))\n", + "\n", + " # Compute correlation matrix\n", + " correlations = compute_correlation(B.T, A.T)\n", + "\n", + " # Correlation-based classification\n", + " for i in range(n_segments):\n", + " for j in range(n_segments):\n", + " \n", + " # Exclude segments overlapping with the testing segment\n", + " if abs(i - j) < win_size and i != j:\n", + " correlations[i, j] = -np.inf\n", + "\n", + " max_idx = np.argmax(correlations, axis=1)\n", + " accuracy[test_subject] = sum(max_idx == range(n_segments)) / n_segments\n", + "\n", + " # Print accuracy for each subject as we go\n", + " print(f\"{accuracy[test_subject]:.3f}\",\n", + " end=', ', flush=True)\n", + " \n", + " # Get a rough estimate of chance (accounting for excluded segments)\n", + " chance = 1 / np.sum(~np.isinf(correlations[n_trs // 2]))\n", + " \n", + " print(\"\\nThe average accuracy among all subjects is \"\n", + " f\"{np.mean(accuracy):.3f} +/- {np.std(accuracy):.3f}\")\n", + " return accuracy, chance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's compute time segment matching accuracy for the anatomically-aligned data:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Between-subject time-segment classification accuracy for each subject: 0.094, 0.173, 0.090, 0.004, 0.158, 0.064, 0.064, 0.075, 0.143, 0.135, 0.132, 0.162, 0.083, 0.098, 0.053, 0.083, 0.169, 0.132, 0.030, 0.188, 0.075, 0.124, 0.083, 0.094, 0.135, 0.180, 0.195, 0.135, 0.102, 0.128, 0.109, 0.120, 0.060, 0.132, 0.041, 0.113, 0.132, 0.135, 0.165, 0.113, \n", + "The average accuracy among all subjects is 0.113 +/- 0.044\n" + ] + } + ], + "source": [ + "# Time-segment classification on anatomically-aligned data\n", + "win_size = 10\n", + "acc_anat_test, chance = time_segment_classification(test_data, win_size=win_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we compute it after transforming the subjects data with SRM:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Between-subject time-segment classification accuracy for each subject: 0.267, 0.462, 0.331, 0.038, 0.808, 0.188, 0.278, 0.462, 0.654, 0.876, 0.688, 0.553, 0.120, 0.327, 0.282, 0.440, 0.459, 0.312, 0.079, 0.523, 0.109, 0.583, 0.391, 0.436, 0.575, 0.511, 0.665, 0.308, 0.429, 0.320, 0.538, 0.571, 0.481, 0.372, 0.395, 0.229, 0.410, 0.451, 0.613, 0.526, \n", + "The average accuracy among all subjects is 0.427 +/- 0.186\n" + ] + } + ], + "source": [ + "# Time-segment classification on SRM data\n", + "acc_shared_test, chance = time_segment_classification(test_shared, win_size=win_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we plot the classification accuracies to compare methods. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRM functional alignment provides a marked improvement in between-\n", + "subject time-segment classification over anatomical alignment.\n", + "The dotted line indicates chance performance (chance = 0.004)\n" + ] + } + ], + "source": [ + "# Box plot for the classification results\n", + "labels = ['anatomical\\nalignment', 'SRM']\n", + "\n", + "plt.figure()\n", + "plt.boxplot([acc_anat_test, acc_shared_test], vert=True,\n", + " patch_artist=True, labels=labels)\n", + "plt.axhline(chance, linestyle='--', color='.4')\n", + "plt.xlabel('alignment')\n", + "plt.ylabel('classification accuracy')\n", + "plt.title('Between-subject time-segment classification')\n", + "plt.show()\n", + "\n", + "print(\"SRM functional alignment provides a marked improvement in \"\n", + " \"between-\\nsubject time-segment classification over \"\n", + " \"anatomical alignment.\\nThe dotted line indicates chance \"\n", + " f\"performance (chance = {chance:.3f})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "The SRM allows us to find a reduced-dimension shared response spaces that resolves functional–topographical idiosyncrasies across subjects. We can use the resulting transformation matrices to project test data from any given subject into the shared space. The plot above shows the time segment matching accuracy for the training data, the test data without any transformation, and the test data when SRM is applied. The average performance without SRM is 11%, whereas with SRM is boosted to 40%. Projecting data into the shared space dramatically improves between-subject classification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### References\n", + "* Chen, P. H. C., Chen, J., Yeshurun, Y., Hasson, U., Haxby, J., & Ramadge, P. J. (2015). A reduced-dimension fMRI shared response model. In C. Cortes, N.D. Lawrence, D.D. Lee, M. Sugiyama, R. Garnett (Eds.), *Advances in Neural Information Processing Systems, vol. 28* (pp. 460-468). https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model\n", + "\n", + "* Haxby, J. V., Guntupalli, J. S., Connolly, A. C., Halchenko, Y. O., Conroy, B. R., Gobbini, M. I., Hanke, M., & Ramadge, P. J. (2011). A common, high-dimensional model of the representational space in human ventral temporal cortex. *Neuron*, *72*(2), 404-416. https://doi.org/10.1016/j.neuron.2011.08.026\n", + "\n", + "* Haxby, J. V., Guntupalli, J. S., Nastase, S. A., & Feilong, M. (2020). Hyperalignment: Modeling shared information encoded in idiosyncratic cortical topographies. *eLife*, *9*, e56601. https://doi.org/10.7554/eLife.56601\n", + "\n", + "* Nastase, S. A., Liu, Y. F., Hillman, H., Norman, K. A., & Hasson, U. (2020). Leveraging shared connectivity to aggregate heterogeneous datasets into a common response space. *NeuroImage*, *217*, 116865. https://doi.org/10.1016/j.neuroimage.2020.116865\n", + "\n", + "* Anderson, M. J., Capota, M., Turek, J. S., Zhu, X., Willke, T. L., Wang, Y., Chen P.-H., Manning, J. R., Ramadge, P. J., & Norman, K. A. (2016). Enabling factor analysis on thousand-subject neuroimaging datasets. *2016 IEEE International Conference on Big Data, pages 1151–1160*. http://ieeexplore.ieee.org/document/7840719/\n", + " \n", + "* Turek, J. S., Willke, T. L., Chen, P.-H., & Ramadge, P. J. (2017). A semi-supervised method for multi-subject fMRI functional alignment. *2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 1098–1102*. https://ieeexplore.ieee.org/document/7952326\n", + " \n", + "* Turek, J. S., Ellis, C. T., Skalaban, L. J., Willke, T. L., & Turk-Browne, N. B. (2018). Capturing Shared and Individual Information in fMRI Data, *2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP 2018), pages 826-830*. https://ieeexplore.ieee.org/document/8462175\n", + "\n", + "* Richard, H., Martin, L., Pinho, A. L., Pillow, J., & Thirion, B. (2019). Fast shared response model for fMRI data. *arXiv:1909.12537*. https://arxiv.org/abs/1909.12537" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/srm/download_data.sh b/docs/examples/srm/download_data.sh new file mode 100644 index 00000000..f2374820 --- /dev/null +++ b/docs/examples/srm/download_data.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +wget -nc https://zenodo.org/record/4300825/files/brainiak-aperture-srm-data.tgz diff --git a/pr-check.sh b/pr-check.sh index 1d58bb8b..38a89441 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -18,6 +18,45 @@ set -e +# Check whether we are running on Princeton's della compute cluster. +is_della=false +if [[ $(hostname -s) == della* ]]; +then + is_della=true +fi + +# Set this to where brainiak example notebooks and their datasets should be stored when running. +EXAMPLE_NOTEBOOKS_DIR=docs/examples + +# Check if we are running on della.princeton.edu +if [[ "$is_della" == true ]]; then + echo "Running on della, load required modules" + + # Load some modules we will need on della + module load anaconda3 + module load openmpi/gcc/2.0.2/64 + module load rh/devtoolset/8 + + # Turn off infiniband + export OMPI_MCA_btl="tcp,self,sm" + + # We need to fetch any data needed for running notebook examples + # Update our data cache with any download_data.sh scripts found in the repo + BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak-example-data/ + echo "Copying download_data.sh scripts to brainiak-example-data cache" + rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR $BRAINIAK_EXAMPLES_DATA_CACHE_DIR + + # Download any data, this should only trigger downloads for new datasets since download_data.sh shouls check if the data exists. + echo "Executing download_data scripts in cache directory" + pushd . + cd $BRAINIAK_EXAMPLES_DATA_CACHE_DIR + bash download_data.sh + popd + + echo "Updating the working repo with any data downloaded into the cache" + rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR $EXAMPLE_NOTEBOOKS_DIR +fi + if [ ! -f brainiak/__init__.py ] then echo "Run "$(basename "$0")" from the root of the BrainIAK hierarchy." @@ -43,7 +82,7 @@ function remove_venv_venv { } function create_conda_venv { - conda create -n $1 --yes python=3.6 + conda create -n $1 --yes python=3.8 } function activate_conda_venv { @@ -51,10 +90,24 @@ function activate_conda_venv { # Pip may update setuptools while installing BrainIAK requirements and # break the Conda cached package, which breaks subsequent runs. conda install --yes -f setuptools + + if [[ "$is_della" == true ]]; then + # On della, we need to set LD_LIBRARY_PATH to the conda environment libs explicitly. + # This is because when importing tensorflow the system libstd++ is picked + # up instead of the conda one. This causes subsequent GLIB version errors + # when trying to load compiled modules + export LD_LIBRARY_PATH="$CONDA_PREFIX/lib:$LD_LIBRARY_PATH" + fi + } function deactivate_conda_venv { - source deactivate + + if [[ "$is_della" == true ]]; then + conda deactivate + else + source deactivate + fi } function remove_conda_venv { @@ -106,8 +159,20 @@ $activate_venv $venv || { exit_with_error "Virtual environment activation failed." } -python3 -m pip install -U pip || \ - exit_with_error_and_venv "Failed to update Pip." + +if [[ "$is_della" == true ]]; then + + # Skip upgrading pip, this was causing failures on della, not sure why. + + # Needed to install type-pkg-resources to get mypy to stop complaining. Not + # sure if there is a better solution. + python3 -m pip install types-pkg-resources || \ + exit_with_error_and_venv "Failed to install type-pkg-resources for mypy." + +else + python3 -m pip install -U pip || \ + exit_with_error_and_venv "Failed to update Pip." +fi # install brainiak in editable mode (required for testing) # brainiak will also be installed together with the developer dependencies, but @@ -121,13 +186,24 @@ python3 -m pip install $ignore_installed -U -r requirements-dev.txt || \ exit_with_error_and_venv "Failed to install development requirements." -# static analysis -./run-checks.sh || \ - exit_with_error_and_venv "run-checks failed" +# static analysis, skip on della for now, failing for numpy 1.20 typing issues I think +if [[ "$is_della" == false ]]; then + ./run-checks.sh || exit_with_error_and_venv "run-checks failed" +fi # run tests -./run-tests.sh $sdist_mode || \ - exit_with_error_and_venv "run-tests failed" +if [[ "$is_della" == true ]]; then + echo "Running on della head node, need to request time on a compute node" + export BRAINIAKDEV_MPI_COMMAND=srun + salloc -t 03:00:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ + exit_with_error_and_venv "run-tests failed" +else + ./run-tests.sh $sdist_mode || \ + exit_with_error_and_venv "run-tests failed" + +fi + + # build documentation cd docs @@ -135,7 +211,11 @@ export THEANO_FLAGS='device=cpu,floatX=float64,blas.ldflags=-lblas' if [ ! -z $SLURM_NODELIST ] then - make_wrapper="srun -n 1" + if [[ "$is_della" == true ]]; then + make_wrapper="srun -t 00:30:00 -N 1 -n 4 " + else + make_wrapper="srun -n 1" + fi fi $make_wrapper make || { cd - diff --git a/requirements-dev.txt b/requirements-dev.txt index ac2483bc..bdcc27eb 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -16,3 +16,4 @@ numdifftools # examples matplotlib +testbook diff --git a/setup.cfg b/setup.cfg index e616ffe0..2075d92f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -12,3 +12,8 @@ parallel = True [coverage:report] fail_under = 90 + +[tool:pytest] +addopts = + -s + --durations=0 diff --git a/setup.py b/setup.py index 2aa348d3..23a17093 100644 --- a/setup.py +++ b/setup.py @@ -122,7 +122,7 @@ def finalize_options(self): 'cython', # https://github.com/numpy/numpy/issues/14189 # https://github.com/brainiak/brainiak/issues/493 - 'numpy!=1.17.*,<1.20', + 'numpy', 'pybind11>=1.7', 'scipy!=1.0.0', 'setuptools_scm', diff --git a/tests/conftest.py b/tests/conftest.py index 5f0864bf..3d9628d6 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,9 +1,11 @@ + import multiprocessing from mpi4py import MPI import pytest import numpy import random +from brainiak.fcma.classifier import Classifier import tensorflow diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py new file mode 100644 index 00000000..a6f6021f --- /dev/null +++ b/tests/test_notebooks.py @@ -0,0 +1,50 @@ +import os +import glob +import pytest + +from testbook import testbook + +notebook_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) + +# Exclude the rt-cloud notebook, we need to write a custom test for this one +# notebook_files = [f for f in notebook_files if 'real-time' not in f] + +# Helper function to mark specific notebooks as expected failure. +def mark_xfail(nb, **kwargs): + nb_index = None + for i, nb_file in enumerate(notebook_files): + if nb in nb_file: + nb_index = i + + if nb_index is None: + raise ValueError(f"Cannot set notebook {nb} to xfail because it could not be found") + + notebook_files[nb_index] = pytest.param(nb, marks=pytest.mark.xfail(**kwargs)) + +#mark_xfail('rtcloud_notebook.ipynb', reason="Needs to have a web server installed, will probably need to run this in singularity on della") + +@pytest.fixture(autouse=True) +def chdir_back_to_root(): + """ + This fixture sets up and tears down state before each example is run. Certain examples + require that they are run from the local directory in which they reside. This changes + directory. It reverses this after the test finishes. + """ + + # Get the current directory before running the test + cwd = os.getcwd() + + yield + + # After the test, we need chdir back to root of the repo + os.chdir(cwd) + + +@pytest.mark.parametrize("notebook_file", notebook_files) +def test_notebook(notebook_file): + + os.chdir(os.path.dirname(notebook_file)) + + with testbook(os.path.basename(notebook_file), execute=True, timeout=3600) as tb: + pass + From 0e0b5cd6995e0f4f9dce25626b8d65c2ce02d389 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 24 Jan 2022 14:41:02 -0500 Subject: [PATCH 03/96] Disable notebook building from docs for now. Since notebooks are running under pytest now, I will need to cache the results from these notebooks so that they can be rendered to HTML for docs. --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 8e03e2b7..f0ead4f2 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -294,4 +294,4 @@ # Myst-nb execution_timeout = -1 -jupyter_execute_notebooks = "force" +jupyter_execute_notebooks = "off" From 2f70417225bae6027a1cfea052b2d1fd3d0632f7 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Feb 2022 13:29:15 -0500 Subject: [PATCH 04/96] Fix some issues with notebook tests - Turn off notebook tests by default, need to pass --enable_notebook_tests to pytest to enable. - Remove an extraneous print statement from test_gbrsa that was cluttering logs. --- pr-check.sh | 38 ++++++++++++++++++----------------- run-tests.sh | 8 ++++++++ tests/conftest.py | 5 +++++ tests/reprsimil/test_gbrsa.py | 2 +- tests/test_notebooks.py | 4 ++++ 5 files changed, 38 insertions(+), 19 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index 38a89441..ac44778d 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -34,27 +34,13 @@ if [[ "$is_della" == true ]]; then # Load some modules we will need on della module load anaconda3 - module load openmpi/gcc/2.0.2/64 module load rh/devtoolset/8 - # Turn off infiniband + # Load openmpi and turn off infiniband + module load openmpi/gcc/2.0.2/64 + export MPICC=$(which mpicc) export OMPI_MCA_btl="tcp,self,sm" - # We need to fetch any data needed for running notebook examples - # Update our data cache with any download_data.sh scripts found in the repo - BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak-example-data/ - echo "Copying download_data.sh scripts to brainiak-example-data cache" - rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR $BRAINIAK_EXAMPLES_DATA_CACHE_DIR - - # Download any data, this should only trigger downloads for new datasets since download_data.sh shouls check if the data exists. - echo "Executing download_data scripts in cache directory" - pushd . - cd $BRAINIAK_EXAMPLES_DATA_CACHE_DIR - bash download_data.sh - popd - - echo "Updating the working repo with any data downloaded into the cache" - rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR $EXAMPLE_NOTEBOOKS_DIR fi if [ ! -f brainiak/__init__.py ] @@ -162,6 +148,22 @@ $activate_venv $venv || { if [[ "$is_della" == true ]]; then + # We need to fetch any data needed for running notebook examples + # Update our data cache with any download_data.sh scripts found in the repo + BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak_tests/brainiak-example-data/ + echo "Copying download_data.sh scripts to brainiak-example-data cache" + rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR $BRAINIAK_EXAMPLES_DATA_CACHE_DIR + + # Download any data, this should only trigger downloads for new datasets since download_data.sh shouls check if the data exists. + echo "Executing download_data scripts in cache directory" + pushd . + cd $BRAINIAK_EXAMPLES_DATA_CACHE_DIR + bash download_data.sh + popd + + echo "Updating the working repo with any data downloaded into the cache" + rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR $EXAMPLE_NOTEBOOKS_DIR + # Skip upgrading pip, this was causing failures on della, not sure why. # Needed to install type-pkg-resources to get mypy to stop complaining. Not @@ -195,7 +197,7 @@ fi if [[ "$is_della" == true ]]; then echo "Running on della head node, need to request time on a compute node" export BRAINIAKDEV_MPI_COMMAND=srun - salloc -t 03:00:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ + salloc -t 00:10:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ exit_with_error_and_venv "run-tests failed" else ./run-tests.sh $sdist_mode || \ diff --git a/run-tests.sh b/run-tests.sh index 0c7fda31..5328de85 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -37,8 +37,16 @@ if [ -z $mpi_command ] then mpi_command=mpiexec fi +echo "Using mpi command: ${mpi_command}" $mpi_command -n 2 coverage run -m mpi4py -m pytest +# Check whether we are running on Princeton's della compute cluster. +# If so, run the notebook tests separately +if [[ $(hostname -s) == della* ]]; +then + pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests +fi + # Coverage produces empty files which trigger warnings on combine find . -name ".coverage.*" -size 0 -print0 | xargs -0 rm -f diff --git a/tests/conftest.py b/tests/conftest.py index 3d9628d6..8d46c50d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -13,6 +13,11 @@ def pytest_configure(config): config.option.xmlpath = "junit-{}.xml".format(MPI.COMM_WORLD.Get_rank()) +def pytest_addoption(parser): + parser.addoption('--enable_notebook_tests', action='store_true', dest="enable_notebook_tests", + default=False, help="Enable tests for Jupyter notebook examples in docs/examples. + These can take a long time and are disabled by default.") + @pytest.fixture def seeded_rng(): random.seed(0) diff --git a/tests/reprsimil/test_gbrsa.py b/tests/reprsimil/test_gbrsa.py index 7038d35b..725f876e 100644 --- a/tests/reprsimil/test_gbrsa.py +++ b/tests/reprsimil/test_gbrsa.py @@ -303,7 +303,7 @@ def test_gradient(): s[:, None, None] * a[:, None, None] # test if the gradients are correct - print(log_fixed_terms) + # print(log_fixed_terms) ll0, deriv0 = gbrsa._sum_loglike_marginalized(L_vec, s2XTAcorrX, YTAcorrY_diag, sXTAcorrY, half_log_det_X0TAX0, diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index a6f6021f..2d9fde6a 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -4,6 +4,9 @@ from testbook import testbook + +enable_notebook_tests = pytest.mark.skipif(not pytest.config.option.enable_notebook_tests, reason="needs --enable_notebook_tests option to run") + notebook_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) # Exclude the rt-cloud notebook, we need to write a custom test for this one @@ -40,6 +43,7 @@ def chdir_back_to_root(): os.chdir(cwd) +@enable_notebook_tests @pytest.mark.parametrize("notebook_file", notebook_files) def test_notebook(notebook_file): From c63caab27894e7591b9104c53598f47a44e7930f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Feb 2022 13:32:05 -0500 Subject: [PATCH 05/96] increase job time on della tests --- pr-check.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pr-check.sh b/pr-check.sh index ac44778d..6219a66d 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -197,7 +197,7 @@ fi if [[ "$is_della" == true ]]; then echo "Running on della head node, need to request time on a compute node" export BRAINIAKDEV_MPI_COMMAND=srun - salloc -t 00:10:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ + salloc -t 03:00:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ exit_with_error_and_venv "run-tests failed" else ./run-tests.sh $sdist_mode || \ From 015ce0285976372d51e147be8cd50a4a98c6facc Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Feb 2022 13:35:45 -0500 Subject: [PATCH 06/96] Add log message for running notebook tests --- run-tests.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/run-tests.sh b/run-tests.sh index 5328de85..2bce00a4 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -44,6 +44,7 @@ $mpi_command -n 2 coverage run -m mpi4py -m pytest # If so, run the notebook tests separately if [[ $(hostname -s) == della* ]]; then + echo "Running notebook tests on della" pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests fi From 5b92e422247d687c50961ac64d2546c38fd6e640 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Feb 2022 15:56:48 -0500 Subject: [PATCH 07/96] more fixes - Fixed and issue with the data caching that was causing examples\ copied repeatedly (yikes!) - Updated pytest syntax for turning off notebook tests by default. --- pr-check.sh | 8 ++++---- tests/conftest.py | 14 ++++++++++++-- tests/test_notebooks.py | 4 +--- 3 files changed, 17 insertions(+), 9 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index 6219a66d..cac03d03 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -150,11 +150,11 @@ if [[ "$is_della" == true ]]; then # We need to fetch any data needed for running notebook examples # Update our data cache with any download_data.sh scripts found in the repo - BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak_tests/brainiak-example-data/ + BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak_tests/brainiak-example-data echo "Copying download_data.sh scripts to brainiak-example-data cache" - rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR $BRAINIAK_EXAMPLES_DATA_CACHE_DIR + rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR/ $BRAINIAK_EXAMPLES_DATA_CACHE_DIR/ - # Download any data, this should only trigger downloads for new datasets since download_data.sh shouls check if the data exists. + # Download any data, this should only trigger downloads for new datasets since download_data.sh should check if the data exists. echo "Executing download_data scripts in cache directory" pushd . cd $BRAINIAK_EXAMPLES_DATA_CACHE_DIR @@ -162,7 +162,7 @@ if [[ "$is_della" == true ]]; then popd echo "Updating the working repo with any data downloaded into the cache" - rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR $EXAMPLE_NOTEBOOKS_DIR + rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR/ $EXAMPLE_NOTEBOOKS_DIR/ # Skip upgrading pip, this was causing failures on della, not sure why. diff --git a/tests/conftest.py b/tests/conftest.py index 8d46c50d..f7af4846 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -15,8 +15,18 @@ def pytest_configure(config): def pytest_addoption(parser): parser.addoption('--enable_notebook_tests', action='store_true', dest="enable_notebook_tests", - default=False, help="Enable tests for Jupyter notebook examples in docs/examples. - These can take a long time and are disabled by default.") + default=False, help="Enable tests for Jupyter notebook examples in docs/examples. " + "These can take a long time and are disabled by default.") + +def pytest_collection_modifyitems(config, items): + if config.getoption("--enable_notebook_tests"): + # --enable_notebook_tests given in cli: do not skip notebook tests + enable_notebook_tests = pytest.mark.skip(reason="needs --enable_notebook_tests option to run") + for item in items: + if "notebook" in item.keywords: + item.add_marker(enable_notebook_tests) + else: + return @pytest.fixture def seeded_rng(): diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 2d9fde6a..e738c61f 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -5,8 +5,6 @@ from testbook import testbook -enable_notebook_tests = pytest.mark.skipif(not pytest.config.option.enable_notebook_tests, reason="needs --enable_notebook_tests option to run") - notebook_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) # Exclude the rt-cloud notebook, we need to write a custom test for this one @@ -43,7 +41,7 @@ def chdir_back_to_root(): os.chdir(cwd) -@enable_notebook_tests +@pytest.mark.notebook @pytest.mark.parametrize("notebook_file", notebook_files) def test_notebook(notebook_file): From e0a745b358bab94fce987dbbf4bb972790fb021b Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Feb 2022 13:48:18 -0500 Subject: [PATCH 08/96] Fixes some bugs on della's new head node - Needed to disable sm BTL for new version of OpenMPI. - Needed to put upperbound on tensorflow_probability. New version requires TF 2.8 which is causing issues on della. - Fixed a bug with the pytest argument enable_notebook_tests - Fixed random numpy warnings about using np.* types instead of python primitive types for numpy array dtype. --- brainiak/searchlight/searchlight.py | 10 +++++----- pr-check.sh | 9 +++++---- pyproject.toml | 5 +++++ setup.py | 2 +- tests/conftest.py | 4 ++-- tests/searchlight/test_searchlight.py | 18 +++++++++--------- 6 files changed, 27 insertions(+), 21 deletions(-) diff --git a/brainiak/searchlight/searchlight.py b/brainiak/searchlight/searchlight.py index 9d921a5d..55e40bf9 100644 --- a/brainiak/searchlight/searchlight.py +++ b/brainiak/searchlight/searchlight.py @@ -70,7 +70,7 @@ class Cube(Shape): def __init__(self, rad): super().__init__(rad) self.rad = rad - self.mask_ = np.ones((2*rad+1, 2*rad+1, 2*rad+1), dtype=np.bool) + self.mask_ = np.ones((2*rad+1, 2*rad+1, 2*rad+1), dtype=bool) class Diamond(Shape): @@ -90,7 +90,7 @@ class Diamond(Shape): """ def __init__(self, rad): super().__init__(rad) - self.mask_ = np.zeros((2*rad+1, 2*rad+1, 2*rad+1), dtype=np.bool) + self.mask_ = np.zeros((2*rad+1, 2*rad+1, 2*rad+1), dtype=bool) for r1 in range(2*self.rad+1): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): @@ -116,7 +116,7 @@ class Ball(Shape): """ def __init__(self, rad): super().__init__(rad) - self.mask_ = np.zeros((2*rad+1, 2*rad+1, 2*rad+1), dtype=np.bool) + self.mask_ = np.zeros((2*rad+1, 2*rad+1, 2*rad+1), dtype=bool) for r1 in range(2*self.rad+1): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): @@ -462,7 +462,7 @@ def run_block_function(self, block_fn, extra_block_fn_params=None, global_outputs = self.comm.gather(local_outputs) # Coalesce results - outmat = np.empty(self.mask.shape, dtype=np.object) + outmat = np.empty(self.mask.shape, dtype=object) if rank == 0: for go_rank in global_outputs: for (pt, mat) in go_rank: @@ -536,7 +536,7 @@ def _singlenode_searchlight(data, msk, mysl_rad, bcast_var, extra_params): voxel_fn = extra_params[0] shape_mask = extra_params[1] min_active_voxels_proportion = extra_params[2] - outmat = np.empty(msk.shape, dtype=np.object) + outmat = np.empty(msk.shape, dtype=object) if mysl_rad > 0: outmat = outmat[mysl_rad:-mysl_rad, mysl_rad:-mysl_rad, diff --git a/pr-check.sh b/pr-check.sh index cac03d03..207a9cb9 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -33,13 +33,14 @@ if [[ "$is_della" == true ]]; then echo "Running on della, load required modules" # Load some modules we will need on della - module load anaconda3 - module load rh/devtoolset/8 + module load anaconda3/2021.11 + #module load rh/devtoolset/8 # Load openmpi and turn off infiniband - module load openmpi/gcc/2.0.2/64 + # module load openmpi/gcc/2.0.2/64 + module load openmpi/gcc/4.1.0 export MPICC=$(which mpicc) - export OMPI_MCA_btl="tcp,self,sm" + export OMPI_MCA_btl="vader,self,tcp" fi diff --git a/pyproject.toml b/pyproject.toml index ba9610bd..7a213d9a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,3 +23,8 @@ title_format = "BrainIAK {version} ({project_date})" directory = "removal" name = "Deprecations and removals" showcontent = true + +[tool.pytest.ini_options] +markers = [ + "notebook: marks example notebook tests", +] diff --git a/setup.py b/setup.py index 23a17093..6cb077d7 100644 --- a/setup.py +++ b/setup.py @@ -152,7 +152,7 @@ def finalize_options(self): extras_require={ 'matnormal': [ 'tensorflow', - 'tensorflow_probability', + 'tensorflow_probability<=0.15.0', ], }, author='Princeton Neuroscience Institute and Intel Corporation', diff --git a/tests/conftest.py b/tests/conftest.py index f7af4846..15c7fe85 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -21,12 +21,12 @@ def pytest_addoption(parser): def pytest_collection_modifyitems(config, items): if config.getoption("--enable_notebook_tests"): # --enable_notebook_tests given in cli: do not skip notebook tests + return + else: enable_notebook_tests = pytest.mark.skip(reason="needs --enable_notebook_tests option to run") for item in items: if "notebook" in item.keywords: item.add_marker(enable_notebook_tests) - else: - return @pytest.fixture def seeded_rng(): diff --git a/tests/searchlight/test_searchlight.py b/tests/searchlight/test_searchlight.py index a6b4c175..ee1bf1a0 100644 --- a/tests/searchlight/test_searchlight.py +++ b/tests/searchlight/test_searchlight.py @@ -40,8 +40,8 @@ def test_searchlight_with_cube(): dim0, dim1, dim2 = (50, 50, 50) ntr = 30 nsubj = 3 - mask = np.zeros((dim0, dim1, dim2), dtype=np.bool) - data = [np.empty((dim0, dim1, dim2, ntr), dtype=np.object) + mask = np.zeros((dim0, dim1, dim2), dtype=bool) + data = [np.empty((dim0, dim1, dim2, ntr), dtype=object) if i % size == rank else None for i in range(0, nsubj)] @@ -70,8 +70,8 @@ def test_searchlight_with_cube_poolsize_1(): dim0, dim1, dim2 = (50, 50, 50) ntr = 30 nsubj = 3 - mask = np.zeros((dim0, dim1, dim2), dtype=np.bool) - data = [np.empty((dim0, dim1, dim2, ntr), dtype=np.object) + mask = np.zeros((dim0, dim1, dim2), dtype=bool) + data = [np.empty((dim0, dim1, dim2, ntr), dtype=object) if i % size == rank else None for i in range(0, nsubj)] @@ -108,8 +108,8 @@ def test_searchlight_with_diamond(): dim0, dim1, dim2 = (50, 50, 50) ntr = 30 nsubj = 3 - mask = np.zeros((dim0, dim1, dim2), dtype=np.bool) - data = [np.empty((dim0, dim1, dim2, ntr), dtype=np.object) + mask = np.zeros((dim0, dim1, dim2), dtype=bool) + data = [np.empty((dim0, dim1, dim2, ntr), dtype=object) if i % size == rank else None for i in range(0, nsubj)] @@ -148,8 +148,8 @@ def test_searchlight_with_ball(): dim0, dim1, dim2 = (50, 50, 50) ntr = 30 nsubj = 3 - mask = np.zeros((dim0, dim1, dim2), dtype=np.bool) - data = [np.empty((dim0, dim1, dim2, ntr), dtype=np.object) + mask = np.zeros((dim0, dim1, dim2), dtype=bool) + data = [np.empty((dim0, dim1, dim2, ntr), dtype=object) if i % size == rank else None for i in range(0, nsubj)] @@ -286,7 +286,7 @@ def do_test(dim0, dim1, dim2, ntr, nsubj, max_blk_edge, rad): rank = comm.rank size = comm.size mask = np.random.choice([True, False], (dim0, dim1, dim2)) - data = [np.empty((dim0, dim1, dim2, ntr), dtype=np.object) + data = [np.empty((dim0, dim1, dim2, ntr), dtype=object) if i % size == rank else None for i in range(0, nsubj)] From b283f0aa2dccd41f8603073705cfb250907f600f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Feb 2022 17:06:21 -0500 Subject: [PATCH 09/96] fix some style errors --- tests/conftest.py | 19 +++++++++++++------ tests/test_notebooks.py | 32 ++++++++++++++++++++------------ 2 files changed, 33 insertions(+), 18 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 15c7fe85..23c99074 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,11 +1,9 @@ - import multiprocessing from mpi4py import MPI import pytest import numpy import random -from brainiak.fcma.classifier import Classifier import tensorflow @@ -14,20 +12,29 @@ def pytest_configure(config): def pytest_addoption(parser): - parser.addoption('--enable_notebook_tests', action='store_true', dest="enable_notebook_tests", - default=False, help="Enable tests for Jupyter notebook examples in docs/examples. " - "These can take a long time and are disabled by default.") + parser.addoption( + "--enable_notebook_tests", + action="store_true", + dest="enable_notebook_tests", + default=False, + help="Enable tests for Jupyter notebook examples in docs/examples. " + "These can take a long time and are disabled by default.", + ) + def pytest_collection_modifyitems(config, items): if config.getoption("--enable_notebook_tests"): # --enable_notebook_tests given in cli: do not skip notebook tests return else: - enable_notebook_tests = pytest.mark.skip(reason="needs --enable_notebook_tests option to run") + enable_notebook_tests = pytest.mark.skip( + reason="needs --enable_notebook_tests option to run" + ) for item in items: if "notebook" in item.keywords: item.add_marker(enable_notebook_tests) + @pytest.fixture def seeded_rng(): random.seed(0) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index e738c61f..b4b17159 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -5,31 +5,40 @@ from testbook import testbook -notebook_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) +nb_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) # Exclude the rt-cloud notebook, we need to write a custom test for this one -# notebook_files = [f for f in notebook_files if 'real-time' not in f] +# nb_files = [f for f in nb_files if 'real-time' not in f] + # Helper function to mark specific notebooks as expected failure. def mark_xfail(nb, **kwargs): nb_index = None - for i, nb_file in enumerate(notebook_files): + for i, nb_file in enumerate(nb_files): if nb in nb_file: nb_index = i if nb_index is None: - raise ValueError(f"Cannot set notebook {nb} to xfail because it could not be found") + raise ValueError( + f"Cannot set notebook {nb} to xfail because it could not be found" + ) + + nb_files[nb_index] = pytest.param(nb, marks=pytest.mark.xfail(**kwargs)) - notebook_files[nb_index] = pytest.param(nb, marks=pytest.mark.xfail(**kwargs)) -#mark_xfail('rtcloud_notebook.ipynb', reason="Needs to have a web server installed, will probably need to run this in singularity on della") +# mark_xfail('rtcloud_notebook.ipynb', +# reason="Needs to have a web server installed, " +# "will probably need to run this in " +# "singularity on della") + @pytest.fixture(autouse=True) def chdir_back_to_root(): """ - This fixture sets up and tears down state before each example is run. Certain examples - require that they are run from the local directory in which they reside. This changes - directory. It reverses this after the test finishes. + This fixture sets up and tears down state before each example is run. + Certain examples require that they are run from the local directory in + which they reside. This changes directory. It reverses this after the + test finishes. """ # Get the current directory before running the test @@ -42,11 +51,10 @@ def chdir_back_to_root(): @pytest.mark.notebook -@pytest.mark.parametrize("notebook_file", notebook_files) +@pytest.mark.parametrize("notebook_file", nb_files) def test_notebook(notebook_file): os.chdir(os.path.dirname(notebook_file)) - with testbook(os.path.basename(notebook_file), execute=True, timeout=3600) as tb: + with testbook(os.path.basename(notebook_file), execute=True, timeout=3600): pass - From e5d68ea8789f6c8854bcd8a814b9da1616616617 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Feb 2022 17:18:35 -0500 Subject: [PATCH 10/96] Added type: ignore for pkg_resources --- brainiak/utils/fmrisim.py | 2 +- brainiak/utils/fmrisim_real_time_generator.py | 2 +- tests/utils/test_fmrisim_real_time.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/brainiak/utils/fmrisim.py b/brainiak/utils/fmrisim.py index d6d5bba4..4c388a5c 100644 --- a/brainiak/utils/fmrisim.py +++ b/brainiak/utils/fmrisim.py @@ -85,7 +85,7 @@ # https://github.com/PyCQA/pyflakes/issues/248 import numpy.matlib # noqa: F401 from numpy.linalg import LinAlgError -from pkg_resources import resource_stream +from pkg_resources import resource_stream # type: ignore from scipy import stats from scipy import signal import scipy.ndimage as ndimage diff --git a/brainiak/utils/fmrisim_real_time_generator.py b/brainiak/utils/fmrisim_real_time_generator.py index 34c2a479..301648d9 100644 --- a/brainiak/utils/fmrisim_real_time_generator.py +++ b/brainiak/utils/fmrisim_real_time_generator.py @@ -35,7 +35,7 @@ import pydicom as dicom from brainiak.utils import fmrisim as sim # type: ignore import logging -from pkg_resources import resource_stream +from pkg_resources import resource_stream # type: ignore from nibabel.nifti1 import Nifti1Image import gzip diff --git a/tests/utils/test_fmrisim_real_time.py b/tests/utils/test_fmrisim_real_time.py index 4b06b01b..a31759cc 100644 --- a/tests/utils/test_fmrisim_real_time.py +++ b/tests/utils/test_fmrisim_real_time.py @@ -22,7 +22,7 @@ import os import time import glob -from pkg_resources import resource_stream +from pkg_resources import resource_stream # type: ignore from typing import Dict from nibabel.nifti1 import Nifti1Image import gzip From fa864b211952ee994387f5998818249a62a54e2b Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Mar 2022 12:06:41 -0500 Subject: [PATCH 11/96] Get rid of install of types-pkg-resources --- pr-check.sh | 6 ------ 1 file changed, 6 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index 207a9cb9..888b25b2 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -166,12 +166,6 @@ if [[ "$is_della" == true ]]; then rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR/ $EXAMPLE_NOTEBOOKS_DIR/ # Skip upgrading pip, this was causing failures on della, not sure why. - - # Needed to install type-pkg-resources to get mypy to stop complaining. Not - # sure if there is a better solution. - python3 -m pip install types-pkg-resources || \ - exit_with_error_and_venv "Failed to install type-pkg-resources for mypy." - else python3 -m pip install -U pip || \ exit_with_error_and_venv "Failed to update Pip." From bc780986712ba94381605770fba57cb989c8e7d2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Mar 2022 14:21:48 -0500 Subject: [PATCH 12/96] Remove numpy pin --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 6cb077d7..36fe0bed 100644 --- a/setup.py +++ b/setup.py @@ -135,7 +135,7 @@ def finalize_options(self): 'nitime', # https://github.com/numpy/numpy/issues/14189 # https://github.com/brainiak/brainiak/issues/493 - 'numpy!=1.17.*,<1.20', + 'numpy', 'scikit-learn[alldeps]>=0.18', # See https://github.com/scipy/scipy/pull/8082 'scipy!=1.0.0', From e179634fa0d40cd73722a679d2b0d2cf888ac7a9 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Mar 2022 14:42:21 -0500 Subject: [PATCH 13/96] replace some references to np.bool with bool --- brainiak/io.py | 2 +- tests/image/test_image.py | 2 +- tests/io/test_io.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/brainiak/io.py b/brainiak/io.py index 4cb36d6f..0fdfa676 100644 --- a/brainiak/io.py +++ b/brainiak/io.py @@ -127,7 +127,7 @@ def load_boolean_mask(path: Union[str, Path], if predicate is not None: mask = predicate(data) else: - mask = data.astype(np.bool) + mask = data.astype(bool) return mask diff --git a/tests/image/test_image.py b/tests/image/test_image.py index 4796bc3f..fe4d0eaf 100644 --- a/tests/image/test_image.py +++ b/tests/image/test_image.py @@ -92,7 +92,7 @@ def mask() -> np.ndarray: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], - [0, 0, 0, 0]]], dtype=np.bool) + [0, 0, 0, 0]]], dtype=bool) @pytest.fixture diff --git a/tests/io/test_io.py b/tests/io/test_io.py index 9f72550f..dd1d5337 100644 --- a/tests/io/test_io.py +++ b/tests/io/test_io.py @@ -79,7 +79,7 @@ def test_load_images_data_shape( def test_load_boolean_mask(mask_path: Path) -> None: mask = io.load_boolean_mask(mask_path) - assert mask.dtype == np.bool + assert mask.dtype == bool def test_load_boolean_mask_predicate(mask_path: Path) -> None: From 014e0b45af200a0ac5b50810804ce607024ee35f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Mar 2022 14:49:22 -0500 Subject: [PATCH 14/96] fix type error in test_image.py:129 --- tests/image/test_image.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/image/test_image.py b/tests/image/test_image.py index fe4d0eaf..e5b4d13a 100644 --- a/tests/image/test_image.py +++ b/tests/image/test_image.py @@ -126,7 +126,7 @@ def multimasked_images(masked_data) -> Iterable[Iterable[np.ndarray]]: masked_data_2 = np.concatenate(([[2]], masked_data[1:, :])) return [[masked_data, np.concatenate(([[0]], masked_data)), masked_data[:-1, :]], - [masked_data_2, np.concatenate(([[0]], masked_data_2)), + [masked_data_2, np.concatenate((np.array([[0]]), masked_data_2)), masked_data_2[:-1, :]]] From c4a5494f6c3fecadb1931143ded57aca06e30958 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Mar 2022 15:46:22 -0500 Subject: [PATCH 15/96] Fix syntax error in pr-check.sh --- pr-check.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index 888b25b2..a11ba20a 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -113,14 +113,14 @@ function exit_with_error_and_venv { exit_with_error "$1" } -if [ -z $IGNORE_CONDA ] && [ $(which conda) ] +if [ -z "$IGNORE_CONDA" ] && [ "$(which conda)" ] then export PYTHONNOUSERSITE=True create_venv=create_conda_venv activate_venv=activate_conda_venv deactivate_venv=deactivate_conda_venv remove_venv=remove_conda_venv - ignore_installed="--ignore-installed" + #ignore_installed="--ignore-installed" else create_venv=create_venv_venv activate_venv=activate_venv_venv From 0cb0adc359a29ab61b394d0a8b28f5e77a98ccd4 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 13:13:08 -0400 Subject: [PATCH 16/96] workaround for newer numpy and theano see: https://github.com/numpy/numpy/issues/21079#issuecomment-1043734244 --- brainiak/funcalign/sssrm.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/brainiak/funcalign/sssrm.py b/brainiak/funcalign/sssrm.py index b43e9428..c436c767 100644 --- a/brainiak/funcalign/sssrm.py +++ b/brainiak/funcalign/sssrm.py @@ -32,6 +32,13 @@ from sklearn.utils import assert_all_finite from sklearn.utils.validation import NotFittedError from sklearn.utils.multiclass import unique_labels + +# Workaround for Theano for numpy after 1.20.3, see: https://github.com/numpy/numpy/issues/21079 +try: + np.__config__.blas_opt_info = np.__config__.blas_ilp64_opt_info +except Exception: + pass + import theano import theano.tensor as T import theano.compile.sharedvalue as S From d30b4e51f4a336824ccb5b9ba92a9513ad0c166f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 13:55:14 -0400 Subject: [PATCH 17/96] pin statsmodel<=0.12 ARMA has been removed from stats model. Need to convert to ARIMA API now. Tried to do it but was getting NaNs in the test so this needs to be looked into. --- brainiak/funcalign/sssrm.py | 9 ++++++--- setup.py | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/brainiak/funcalign/sssrm.py b/brainiak/funcalign/sssrm.py index c436c767..75add743 100644 --- a/brainiak/funcalign/sssrm.py +++ b/brainiak/funcalign/sssrm.py @@ -33,11 +33,14 @@ from sklearn.utils.validation import NotFittedError from sklearn.utils.multiclass import unique_labels -# Workaround for Theano for numpy after 1.20.3, see: https://github.com/numpy/numpy/issues/21079 +# Workaround for Theano for numpy after 1.20.3, see: +# https://github.com/numpy/numpy/issues/21079 try: - np.__config__.blas_opt_info = np.__config__.blas_ilp64_opt_info + import numpy.distutils + blas_info = np.__config__.blas_ilp64_opt_info # type: ignore + numpy.distutils.__config__.blas_opt_info = blas_info # type: ignore except Exception: - pass + pass import theano import theano.tensor as T diff --git a/setup.py b/setup.py index 36fe0bed..e23a971e 100644 --- a/setup.py +++ b/setup.py @@ -139,7 +139,7 @@ def finalize_options(self): 'scikit-learn[alldeps]>=0.18', # See https://github.com/scipy/scipy/pull/8082 'scipy!=1.0.0', - 'statsmodels', + 'statsmodels<=0.12', 'pymanopt', 'theano>=1.0.4', # See https://github.com/Theano/Theano/pull/6671 'pybind11>=1.7', From 9e06236161b4d611cb5f60fff4448155e3e45265 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 14:30:11 -0400 Subject: [PATCH 18/96] Convert comparison to np.allclose --- tests/eventseg/test_event.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/eventseg/test_event.py b/tests/eventseg/test_event.py index 30b32add..1dadaf94 100644 --- a/tests/eventseg/test_event.py +++ b/tests/eventseg/test_event.py @@ -199,5 +199,5 @@ def test_sym_ll(): hmm_backward.set_event_patterns(np.flip(ev_pat.T, axis=1)) _, ll_backward = hmm_backward.find_events(D_backward, var=1) - assert (ll_forward == ll_backward),\ + assert np.allclose(ll_forward, ll_backward),\ "Log-likelihood not symmetric forward/backward" From e6fceaf95ac2659d661fee924fdb25a30ceaab6b Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 15:10:50 -0400 Subject: [PATCH 19/96] fix the statsmodel issue with deprecated ARMA Got rid of the 0.12 pin and instead fixed the underlying issue. It was caused by ARMA being removed in favor of ARIMA. Had to make a couple of slight modifications to the code to extract parameters correctly and set the order of the model correctly to get ARMA out of ARIMA. --- brainiak/utils/fmrisim.py | 10 +++++----- setup.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/brainiak/utils/fmrisim.py b/brainiak/utils/fmrisim.py index 4c388a5c..d688c187 100644 --- a/brainiak/utils/fmrisim.py +++ b/brainiak/utils/fmrisim.py @@ -78,7 +78,7 @@ import logging from itertools import product -from statsmodels.tsa.arima_model import ARMA +from statsmodels.tsa.arima.model import ARIMA import math import numpy as np # See pyflakes issue #248 @@ -1270,15 +1270,15 @@ def _calc_ARMA_noise(volume, # Pull out the ARMA values (depends on order) try: - model = ARMA(demeaned_timecourse, [auto_reg_order, ma_order]) - model_fit = model.fit(disp=False) + model = ARIMA(demeaned_timecourse, + order=[auto_reg_order, 0, ma_order]) + model_fit = model.fit() params = model_fit.params except (ValueError, LinAlgError): params = np.ones(auto_reg_order + ma_order + 1) * np.nan - # Add to the list auto_reg_rho_all[voxel_counter, :] = params[1:auto_reg_order + 1] - ma_all[voxel_counter, :] = params[auto_reg_order + 1:] + ma_all[voxel_counter, :] = params[auto_reg_order + 1:-1] # Average all of the values and then convert them to a list auto_reg_rho = np.nanmean(auto_reg_rho_all, 0).tolist() diff --git a/setup.py b/setup.py index e23a971e..36fe0bed 100644 --- a/setup.py +++ b/setup.py @@ -139,7 +139,7 @@ def finalize_options(self): 'scikit-learn[alldeps]>=0.18', # See https://github.com/scipy/scipy/pull/8082 'scipy!=1.0.0', - 'statsmodels<=0.12', + 'statsmodels', 'pymanopt', 'theano>=1.0.4', # See https://github.com/Theano/Theano/pull/6671 'pybind11>=1.7', From fadc914d6c2148edf5e5747bc83af9f98248d1fe Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 15:15:19 -0400 Subject: [PATCH 20/96] fixed deprectaion warning for ndimage --- brainiak/utils/fmrisim.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/brainiak/utils/fmrisim.py b/brainiak/utils/fmrisim.py index d688c187..586a6ac3 100644 --- a/brainiak/utils/fmrisim.py +++ b/brainiak/utils/fmrisim.py @@ -1176,8 +1176,7 @@ def _calc_snr(volume, # Dilate the mask in order to ensure that non-brain voxels are far from # the brain if dilation > 0: - mask_dilated = ndimage.morphology.binary_dilation(mask, - iterations=dilation) + mask_dilated = ndimage.binary_dilation(mask, iterations=dilation) else: mask_dilated = mask From 12921d6f886105f4d758b71c0e56d784084d0862 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 15:21:47 -0400 Subject: [PATCH 21/96] swap np.matlib.repmat for np.tile becuase of deprecation --- brainiak/utils/fmrisim.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/brainiak/utils/fmrisim.py b/brainiak/utils/fmrisim.py index 586a6ac3..d425f28f 100644 --- a/brainiak/utils/fmrisim.py +++ b/brainiak/utils/fmrisim.py @@ -83,7 +83,6 @@ import numpy as np # See pyflakes issue #248 # https://github.com/PyCQA/pyflakes/issues/248 -import numpy.matlib # noqa: F401 from numpy.linalg import LinAlgError from pkg_resources import resource_stream # type: ignore from scipy import stats @@ -945,7 +944,7 @@ def apply_signal(signal_function, if timecourses == 1: # If there is only one time course supplied then duplicate it for # every voxel - signal_function = np.matlib.repmat(signal_function, 1, len(idxs[0])) + signal_function = np.tile(signal_function, (1, len(idxs[0]))) elif len(idxs[0]) != timecourses: raise IndexError('The number of non-zero voxels in the volume and ' From fb5647bae9731e2eb5a6833dd44e77c330f6c490 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 15:42:20 -0400 Subject: [PATCH 22/96] fix ref to moved example iem_example_synthetic_RF_data --- docs/examples.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples.rst b/docs/examples.rst index 0e9cc9ef..8a3037f6 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -4,4 +4,4 @@ Examples .. toctree:: - examples/iem_example_synthetic_RF_data + examples/iem_synthetic_RF/iem_example_synthetic_RF_data From 09300556f31fd1ef34ba820184fb48f7c3b65ec6 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 15:48:40 -0400 Subject: [PATCH 23/96] add python 3.9 and 3.10 testing, add testbook req --- .conda/meta.yaml | 1 + .github/workflows/main.yml | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index 6bb30199..5473456c 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -64,4 +64,5 @@ test: - conda inspect objects -p $PREFIX brainiak # [osx] requires: - pytest + - testbook - numdifftools diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 24cec168..f6f4f362 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -7,7 +7,7 @@ jobs: strategy: matrix: os: [ubuntu-20.04, macos-latest] - python-version: [3.8] + python-version: [3.8, 3.9, 3.10] steps: - uses: actions/checkout@v2 - uses: actions/setup-python@v2 From 83a170a4c6b611842a0a37180dc282331acf2d69 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 21 Mar 2022 16:42:32 -0400 Subject: [PATCH 24/96] fix python version specifiers to string in ci --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index f6f4f362..b6336699 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -7,7 +7,7 @@ jobs: strategy: matrix: os: [ubuntu-20.04, macos-latest] - python-version: [3.8, 3.9, 3.10] + python-version: ["3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v2 - uses: actions/setup-python@v2 From 9a6e1f44a0580d6b605f40b833cdc624af187c18 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 4 Apr 2022 10:51:04 -0400 Subject: [PATCH 25/96] Attempted fixes for conda build and doc generation - Adding libgcc as host and run dependencies to meta.yml. Hopefully this fixes the conda build issue. It seems like system lib c++ is getting picked up instead of conda libs. The only other thing I can think to do is to set LD_LIBRARY_PATH after activating environment. - Notebook HTML generation was erroring out because one of the notebooks uses Markdown headers that skip levels. I turned off warnings as errors for now. Lets see how it looks. --- .conda/meta.yaml | 2 ++ docs/conf.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index 5473456c..883c41d9 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -38,6 +38,7 @@ requirements: - pip - mpich - openmp + - libgcc {% for req in data.get('setup_requires', []) if req not in conda_package_nonexistent -%} - {{req}} @@ -47,6 +48,7 @@ requirements: - python - mpich - openmp + - libgcc {% for req in data.get('install_requires', []) if req not in conda_package_nonexistent -%} - {{req}} diff --git a/docs/conf.py b/docs/conf.py index f0ead4f2..d546e8e1 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -57,6 +57,8 @@ # The master toctree document. master_doc = 'index' +suppress_warnings = ["myst.header"] + # General information about the project. project = 'brainiak' copyright = '2016, Princeton Neuroscience Institute and Intel Corporation' From f9a992bbad2e7d3dd6a42540c54d9df88d8e3e04 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 4 Apr 2022 11:20:58 -0400 Subject: [PATCH 26/96] Convert embedded image in notebook to non-embedded. It looks like MyST-NB can't handle embedded images (attachments). I have converted to HTML img tag with the image extracted to a file. Needed to override git ignore to include the png. Not sure if this is the best thing to do but it should work for now. --- .../Matrix-normal model prototyping.ipynb | 9 ++------- docs/examples/matnormal/schematic_kron.png | Bin 0 -> 230403 bytes 2 files changed, 2 insertions(+), 7 deletions(-) create mode 100644 docs/examples/matnormal/schematic_kron.png diff --git a/docs/examples/matnormal/Matrix-normal model prototyping.ipynb b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb index 68cdb138..a7267abf 100644 --- a/docs/examples/matnormal/Matrix-normal model prototyping.ipynb +++ b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb @@ -34,11 +34,6 @@ ] }, { - "attachments": { - "schematic_kron.png": { - "image/png": "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" - } - }, "cell_type": "markdown", "metadata": {}, "source": [ @@ -47,7 +42,7 @@ "\n", "Unlike many of the other tools in `brainiak`, the `brainiak.matnormal` package is only a little bit about specific methods and a lot about letting you try new ideas and method variants quickly. If the variants are useful, they can be sped up and made neater for broader consumption. To understand the idea behind matrix-normal or kronecker-separable models, consider the following figure: \n", "\n", - "![schematic_kron.png](attachment:schematic_kron.png)\n", + "\n", "\n", "**Matrix normal models simultaneously model spatial and temporal residuals.** \\[A\\]: a schematic view of a vectorized data matrix, where each voxel's time series is vertically concatenated (in orange), and the covariance of every voxel at every timepoint with every other voxel at every other timepoint is modeled. Modeling all of these elements independently is intractable, and some structure needs to be imposed -- in this case, kronecker-separable structure. \\[B\\]: the un-vectorized data matrix (orange rectangle), and its spatial and temporal covariances on the right and bottom. \\[C\\]: A matrix-normal distribution with the mean M and row/column covariances R, C is equivalent to the large structure in \\[A\\], but can be much more tractable to estimate. Figure and caption reused under CC-BY-NC-ND from doi:[10.1016/j.neuropsychologia.2020.107500](https://doi.org/10.1016/j.neuropsychologia.2020.107500). \n" ] @@ -1071,5 +1066,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/docs/examples/matnormal/schematic_kron.png b/docs/examples/matnormal/schematic_kron.png new file mode 100644 index 0000000000000000000000000000000000000000..c1053bb357e80f8bba98a1a3fe73bc679ad43230 GIT binary patch literal 230403 zcma&Oc|4Zw*FAh0iclybl_{ajiX`(a%8+>;Dio2-Lqsx1$WUgLDWnLMDMO(`85@LB zLK!k8!@JI&=lgq}-}}e=dEKA;?vBfOo#%1vWAC-sTKkIBJ*mExhK+_qB5l>wP|+um zC?AkWNx%-FLjZ$Gr4;>ShN zIqON!VLhEI)A9FXR-Ss>ZMvDr=11B`1V=qb3r}c$f2OnN?0!uyIX-rY@sQ>?ixkVt zUo1RKhSO~KCEnV%ZAWyAWb%j9n{+pQ5~Okq*v4p0Q<&eFr}w(wl$dU_W^F&;;Z*u= zkIJ5C4bCl$;za`ryLRSQoV$~%(S7+N;0+Uz6RM!?yJK=Gf&MQiHiN= z4YO1D9_e$aKgKuj3?Xswf)xSWSKMHeu@Tr<$1-tc{8lZXvg$J*a5E|6s03!_M;E=61Pa zj!fqdKjuFtSP)sBovWrATfVfNwl5-rx}YGKNm2KQ;FRyifH&W(Umj{M-Hvjz>d}qq?Iho-9`tivxq@DkHZ7ZvP z{zX#sfBhoyn%Z|#!7cyiQmsQydm8Ni=Tg&$x7qy9Ys!YX^?SQkeYDYo{_= z|3BaMN0G?#)30M=jm^y}fnxt|$UlyOQUBDbUY2MN4-cEOXE)p1+b{6^yR8@NH%Q4A z!Y^K>9TL0rO*=I$t&r~!@ssi;4Kp(~?tS|hnV2XQ8MFaN2 zJM0*Id2J=fs@5;Q&8LfmcUr955fRbDQs*KjCRSiwFL!;$YM!sUJLgM3KG6$Rs&0Z{NL>8Bxb?9<*(aV0`)VW&9oD=BL(vS5ZCC z*VlLZGj}Fnu8nW`&-bj0(?hZgg8$ZWO4gvetAS18T()K+uZEVEvb+03KXGEIh7OJO zvkfIYa_F?1AMa+Ba^oZo_ge=Ub~OImk5q#T7lhxwdzVvOOdA*&_+JlJ>#*KOGP1H_ zS5j8)zIS4Gg=07Qwr$%69-g6n`}S?mqks1;wprm1dA4%+wvmb6Vpdtd!xMca#hGEm zrcbBUF9=;t5w=vC9;($V)Zb51(A8zATbuV1lJ|ri} z1g-C(qGxaJD=`-fS`P@AZDHx^?$$F8{dc|F^(9oqo|alZ?JBodznE54b>!9S*X03! z+?kk}Z??Vu_bfxkl9G}SDk@ZN9yGMEvm^KS_ctgq*kWpG8W9`YoBB25-?g%EEh8l* zazR1C;o)IUBkA;v3`PcqV9&|Ek@uD79S0xYeQ)+(iyHW4WQ6R{p+mFN*Y_TK{^A7{ z85x;Lt)IlUz0y}7yL?DC{m>bdFpZ3^78U{{yjpB7>W2z5{X5`N<~w1%fF*lzBKSzoT_i|k%O2`1BrF_ zZe?|K^|{WEANTB2zfMWoBkiH#a)O9AvDPFzJ3A7ouC8v+GvdS!U2>HTzIpq0G)K@X zV~JU%zRvc_3!m6pTU!Sn*iwieI@Fu^U%M5whjHZ3@9z`QWc=?ge5}60EMS!Fw=l6h z|4t{T_-_^69wL2?D2G3=X(X>W-@k2PqPM9rl&ZVJ=~Si8 zzxVj7mR&V(HM+VQF!i~f1IL$~v9Yyvvz3*Vo10twSFIB#T4ukzxN+;&LE%T0m8#$0 zWa#0+#E<^>bHpm;G`zljL{Vk*c2UQ6O0p2nZ2h~(-8?+LvaA#7k*>jZT6j9t_kH!$y32=-p}qe}l~W>qi&MKYaTeme%al;Gu<u-4l6AE`lM%K zQjob?b~8Rcm|kv~WckEHQBm=V-<&{V#~ACOvvkM?S36Qfiuvjj>;8P(?c?J!JT>@e zLNmrN0@=5`J_D=JTWoxBUa4%>VFr1 zj{N)?`*&%&*x`>lp2=oq{>S+HN`VVQ&k8eFvlLWJs@=E(0s}WB=$EvM?%bh7ruCWo z+7?vQf6~e6z=cmw!oGezy>O>rN#*71*Qy>K^T!yOf|!pUJ-YlQPJUg2Sk5OCw5;~G zqN1ZOjy7*$V0>0vn^RU+mKkQ4T~Wbw>D#Nu^|il@yLLq$G%PA`IM9z+60?0yNdzde z+C%$^M9lJO`KJ}*e zo*oLrO86!BFMe&?;ry|hap%sR52~ty#%PMJU*Bd{bz!TltZZ|0GpCTyR%9PLt$S%{ zyO3r^rlw-f^%fPDytd-SkE$+wQcC1Kp<8**kjT5isi~}D%a_L5nWdzqi^i5up(G(4 zhJXBM@$&S;s=nJQ!YQE2d$(kS4NtgEpd>ee@KYnlt3ep{M9lDy5lHxaaJ~B481+N~Nn1~XoU)7gQ zLo)gtgHT_KLy_R(;v&0y_pW1CHjc=Kg{>{u=;$br!?jxy=Zp9bE%sqiranDo$qHIO zy0SDKw^PVW<85L>f~e1ojg*v>&6n2LgzPkJ-cW3%ySqDybnV(Tsf(kO01c$Qd-vYC zcaNK!o16%?;l@xsGqWfpu&BvLb8V-^@yz5TXJ_Xg{ayCK?sCP?pDPg+HFo!r)~{`e zVu33jB}=b!bGdOksfbfN*;j&yx`yv8IG5c;2;V;9s-~iH)$gsqWKUt@O72EFs!y)V zhsP7q*5&~LGD=EH4BNNoW;Ww2ax?%-t*c*NomHpYyxFcJS!nt+Nq~ok5|Q@2@Kk<< zQS&Z;^X=QWGqABmp?WvAwQV_h@?^q%b+r^JxTfalvuDpL7FYB)J-~hrkB>(Hija{e zdJ03OJtwl&V%cUE7hB)n)#|Q1Z_IvjndY?kE^-PAF&qsOQ&R$IW$y_wHZY)6R#raj z^p=w3wm4;q$Gdu!a_VEvj$)&d?V(NYzl8}33#(aJ?Ag9!$Bm4PSiDDLOUouH zYkb@4nGe^SHWV@18jEctfFtF~bG`9dS#eLjr=w!^P+zOv$7q;nHU$I(a3;1f?ASqp z7gAAC8I)S=!cTqX#~CRV6>9w!4*MlCGcj?>$*~7NWVw$M!&7^|qT=wK{Cs5{owAQZ zw!3!i($Lhr@l}tXNkc;exsMwVCp$ks90e&)F?93Tg}9s?E(=S`+0hnSi&{S-^AP#V z!_$+Ig(Vz&Iq?2{F3MoS0-|MRW<*)$@+zwerGtaRVaF~7@x2O0MmrPmli@~+iy1Fp zYEXxe0JN%WY9f8f&bY3Pk2}iv%#g&>v_E=LP*7;fx!?dG6>UZKsjjXjGFW$acSKxV zxHhly+R6gL+w4M|8|menH#H9Xkxo-Vs;`W?A z8P!-^UtabBtQr0BE?@M}q0s2)4y~XM9R(@jD7_z_`R>@VWlMqnU7A~xE(bG%RIXx| zRn*n@$;)$GxNyM{@FA>rA`8_GvBk50KbdYO1-{RGl7l!ONVWS=aBwCI42yTNNjeu~ zo}geH8LIWi!>VJ^?w6G4;a0G`MGk>Nv$M1O{QL?)O}3{`6A5l)@#hCrEH!L$SGFR> ztl4jrNEKC8E-^7iBqhi96$cI)m)>8DJpSXy4`OSPPQSVz-LrQuuDa&_`+VN5>6i#z zpwn1s+p}kRe|@Y81vEvIL5VmlFs~}@v%jaykJt)D)a4?JqFA_HyvP_Q|2KuZbwF$E z+qdl`as^a^i8eMGTG|8h^45Xn&CkPVw~$;0AF9e0TKM|F zSEpk0HF9(d_!w`v%cI)~C!y_G>Pd{$NaH(lr0V0GVc)|u9f+mt|8O2|RZ=pUq#L?< zYx}2rI44D?^0(p8=;`Yx_=)4*6QiSP$+EE?MSMGM%*pr-`u-JHRaG_6)y=Lm2|c%g zL|e#LDJ!S{5sPSUf>WTSNMAhF2>ND;TKl*8%j>PoJ_$jGR2 zN9M)mt!yeJN95Vj$A!+Hp4=pLUEQ+7%1?Nx=2AG_)~#*5y*G(QCowX@@z2~CPhuPK zhl zJ2y;i{R#z@KKi)SGMOT2htG9^2M!#Fl-pRn)b@RRV&ZMcCfbT*u^Nk$I1BrcZDOZg z2Oe-`NP8a7dqZ?1+bOS{OqWs&r{}oWep6rviH4q@k2@DHW+c&U+jb9N<6M7f#@9<9 zDx8#YxRSE6bb#l0QOnvM3!6XI&J&JLP1Ue`>eV}-1~{|w>*@62(oeuF+@!BRe*Ag+ zcmB(ZxVHB8C;&QTK=8NAnP!#e^iH4V!Ggbg;yH=tRYUt-cQ=7VoYt-*!r#|i;v4+% z;kw>pPjK)|yV^|#3BEe}sETI08V;QuEEoxZ-jK^cs7;u01R61w}~fhf5G9{Fxh zkAdd6L(Sy$YdGh256BCmPwr9uh?TocPvw%e*8pg)P3H9jJ*n9`;X_tVjwleM9 zY4;}mXjgA99??h-_ogDAU^aymsoG9J&9CFRAvAb>U?L+71JSl=-xKwZc!Jo%lxskBARMawo!>0tN3YZth~U-%{P%yM+VC6 zr7nGoSw5DYo-TU&CBtFYA&c|TZ>(=7CtusIl}sY>YNwLUpFdx@r=cmFzTAE6`1ttv z@YCtKP!wL$SXUxWlPx+&jpN6au>H<1E+f;^^k899Q&UO0k1a|pYPPqvwK?{e?nNKb zaajhrxZHVA{Pfwgxq#}9L(h(q&J3agG@xQ!1iXIcGfQq{WHj^pcW74DX8|3f+dvk` zFSbarXg#)QpExn{>(_M@{~WKM?JGAwFSBR}kY@ zuU#7jF6HC~Ow88Fk{cf=&r2=i22Q|Z(=ASajzcshB`4 z_479!xRpSwfCmwCddow!8weHTh=IDmW9W3QVvqI#lJ1rEh^IT`hvzz(B^L`afD>=+ zUbDx`%WJ&1m_^$AmtYznSQDo6{iUkFUf*7&g+6;GGc{07k$*Bn>Ey|61o%U+<~hB) zXVz)T{T#b=alDIb_QXA4U;>8H; z>KwSuFDOWm6 z>Zecb7pDeMb+6z=5EUAygo~e_y7GL#8jd3uH93+;7%;<^53cnsHwBCz*fwo0uL_y) z6QCxiqoa#YON+#9D+;IBqn{`+eRR)9E~%E6Jov^9Mih$ciF`VC$X_$_^Gxz0KqJ;c zYZBmWu5a1Ft6*F;s=kGVg~j9Nd*-KJKa~s&n9y17|MBO~pMl3NyMaEjc620BNlCS_ z_M7FdpXC7fNZ24B0I|MO%jlM9mZrYGod{p%NkeIAX;E=;CE%K!B33bo2udodrta?Y z=l<28{~kYX#Q{guZNmXWH*Sjqo_g4c=)WGE>DY-#&p!M5mXzlNldwf~@UBB=ZC<5{ zjSoKJ!};*+eQZ(VzUlJi%Z_jFY!SAui&{-qB+mC`WAOm8TG2R& zo@r+yb`49B(6corHdaw3;`((pH#bofI(k&Za+aKlbq;3cFw}*njt*LEYB)H%Yg=~{ ztp+Yc6as=2+r};vfi{>+TAB?_iIR;CCsHKe(M2pB5j1Zyj)kLqJa1?q;rOc z9H;V6w%j*;)b+qtd3Kq+{mFA&ex`-RIvXw2K!wu|wj&o}LPE&*9P^^XOI49;X3>E@ z@95C75IJ^iH{$&T;$O^TTsMYIf(EGr3~Lj}2a{hi=fc9ma6&f|{TASFwnJy8sF;`{ znzFNb6!(p+pTQ7XBi)~Bf`%+w17lOW$hzw+2 zJA@Ol=-2}W^nn+@wAv!p?e;R00BB=C%QU@vw*$xbWm{V#y3Cn{erx;XnGq@9xvyH2 zzV#dH$6BxNjRyX)2XmI-H;3cV{nXnvhEq@63~A=gn>Q~nesFEM zbQyJr;9`hlffL%;)5C=2SJl>z8PLjF(^?DSj21JxGUsPA_WgTeem)n zq`!Xssv=}o!HL)CrJ@WB_Y3l z{rWmGqKF)mi|tP=EfqF3GXvfc2X{z-jRN(rDsl3l*A<&${4!Rt)f+YuVhmijK%AcC8JB9H9jK0}*TUoSs6 zFwlis=Y$15>@{T~e&h%rslxun^@r9%Kdw~bpq=~lMB=Elv_3k7m)L%1O9Jlwz`G`R zc1&I|)YVnM`PfJL`t#=rke2xP3igCSc+2XTB7j9xzS)H|HX_WPD~s7Zja zTnfIW9^+kC&;zR?;POBL9yhxoV)aY|%^tAx%l`h9kkC*kgs9!*G=jR>Xaa5X-0$D} zNb`TE>!Y*ujF3ghvO&G1MOay72K^ahX9~5ib?6#mA(4}MRMrFMbo7r!9|C6o_qRxz)TFhUCi;W` znlPnF&tF(N%3!~xUqUrrEIW5b$!fO`r5J!4c=_s8%&S+gUUqisyv@5Z-Z{B>#(`e& zCLW!U#CFu3hnbmKj{v^ACGS6=OGdC<+%D7nU0aPGWDpFr`Ds#e+whynbW7^ zfv(e1Q@bDPLr{;Ut z`ZYBYKM#+}!*mT(ky-2zG?ZBXGW1%i(K{pi8>7B{`<4KVO_mK3^?XnC;;&CyB=E8) z-qKDYq76#SB#NwRpY*YdgYo4{(?)fc$OYJq=rCMT1SNFqn0Kj~PBu_1d6FmO7n`;P z*?s$z?|U1TSy_JZcKukbH#xgs|JM#r@DXUCD$n!%aVdL8p=HQHQb4gtNEbn1F-(_$ zxb83TFK92y&(FWZ9{8notGI;3elS3O%QLoV5=r&;$l^TIZxOXE6+jG8FUp-| zqcjHJJwRfkbX;t}QH?iw)6?OIbWQZ1Sy@@taaL7S$rG8*uC5|KZkFouJ0dNP&RRWo zPCG3R)`-Y_TS634M67qF>~NA#0X6URvHBvV!WZ_kAqoL;@r3*L?~gap%iqBQXwBWb zcQ4`g?cIT^voGw{RM20>)^uQSWcxzC~Hi z8FmegOfkxwW9xSt?|b8=!0MB;2R5A>)KDwlWgV0TAMFN0+~# zq9Uo(y8a|b;5;K)HrU$8NyeKT4etSz$l4Wj200avAE!Y=3e(osZr*LGipp2A;GKH= z_9;Bker0y1s3WvCjEsQUailXO&A@Thix{UULMLP--D@oL$({yn$U*Z;(B{pf zpxUNUO4VOx4Z`IJxdPR;Jq-PWP*TaVAyGwl7-Y%^oh&i0;>GFE{8I30=09G5u}8Uc zQxg*h|5zduf*aC8Htm7pH81xr zG`F=yBJmyo;Q+8Y_VsHQ3d$BzZ-HK@xVSjac z>5oG=N=eFx@-nx$$cwEmq4$ib-C}5S4y98?B`H2$;q2M7Jpfc~p}zsGG=Tq}9oYcy zkA)&H;}#K#Bfa)}*+FiC&g`_Utzrl#gxeQAiJCe5^1(zMMb+J}$S{uVyd(68RW%A~Lhtv?0QuhjbW-wdBV^kZ`9VX)UBO9N_qNzPCsfkSF2E(A-$Z z7E%e4mG&=rFc#5G0v*3xdqp23=ez@g?YN(lbmInBvh2ba_4)5fJ7`&i4RmtBnvyHv zP_s3WSGIxA($dl*R{#+T~L3QBT3aO%kKkO_j*$qJZ@>|3F`@la-IqBk0D zh0sG~yBqW+7ST1Fp9&oqFadSO2_CtmG3&sodj{1aJwHF!XOYf`-oO8l>^`w?b91@q zr_Pl;Ee?5HzqWYWZ#(1Kpwv^qKJJx6!FP*`{~rGvy7tuI<8+GHqCOf;0&>2*v5%ng z%e5|}lFyE%SlfMg>>}ki&rb+1K+Wg06@;imTE!Lq)PQ3nxaV(gGK$4!?-dspe{}_S z@b&A};9!zPwHq1e0lQ2zlCRQ_?f^w-^62bVu=PBjoj~?^IT#Cx{Iz!Z&|iJgzU?#g zSAbkZ;l9i3e;hv6`WsI&)BxFzc8Jt7g|lu63FbX<%cd=1zhiF^Gu|*-E^x(B`=J@o z%TB^Afi9hJOC*fAzyQE1e_4j;Fc4r)+V_i22I`yQzR=I>$geRWtks>Jr_3`No}i!= zfL1cPZ*nC&o3l+N9Y?zwlGp0$YO_7du3ZOy-9`bAY8ob;@%{;*I|_M*Xcjipv&R7Y zvy!@sjYZO>E|P9mFL@Ho z5*R>m?NL&Ub2v%yH*Q>6nC#EP_3ehR%0vgq&dyHwNM^pf?RGg+B?xu`!A1ziFn_e- zi0@Z6gle%rQECH_ zAiT=`mo9v)xkQC#<7IpMbAY%m=vGq4j!^{r&bpZHrBiuZuC_h znfUR;sVCM-_3~voLi7f(<2rbd28FpAwS+YGVAa?YZ563qa~VmxIJsz#-&WF#IF1+3 ze1G@oR|@#+7>OM@qW=1p#4Lgd@j|YfoQAqWPLf-lX?i%QiWANXh`fzME~cP>KlZ?8 zh&E;;UxybL7e`P3Jacqy%07961ub)P^VpS=!HxPU&Z9?n;f_g3OMgM7lE$XZv1kD+Kk^Aj2Uz^> zx3}GDlO<0t zFE1Ye+{bpL7)}%P>Wb&i9gK>KYVJI#t!>az*z?Fir)^d0AkOHuxHx(^%R&GdjaeI> z1pbv|mkWr1G}j1qJWv0QU-1{9tXWvT>ff3NwXa`C`*bl&K5)fA==<$LiyCpPK{!aE z;n9}p@lQ{yQoZ2UKv!ck+;C-74kC&u$p#u(!tl-GfK;Mx!wMFlY~jxe0bD?QgA4<^ zL>xa`ux)_zExD@EqOf7LtXR73j$=KwpOg90JkL_qFH zUgQV_Iu5x#M0)q|sNe~{Thst8M&Zj73ddxJM;k#}sVloX4L-;^4?Hm5W_9!Kll41y z?r=h|d$tZ5tYFN5hMKyofZ=vpTH~irdkNkXO*Xay%sk9eqF{b5mOh^Q_{5Vojzhi` z?XS(bb47aB4Vg!gG-CD~)t{7zD6i)RSww24^0&0Kod5M{H~7uwyILtk?Ey_pI0Vqj z3;GxRCVU|P(xa7-3^{UgatI18f*NU0DSD?6t{er*kPBckFQA@AS-Gj6i4N|P7csjI zF)%QYNU-5Wx2}qTX>NgIi_3H~3FHUMM!j*F6|u6{*=3`UKooU!=!uF3og6uuckuDs zxB7czd>C+oU!Zv+%v3(UzBx$F1g{R-1*WW2>z0Ow;YxCUlG~5B`vaCfc}ux}rG~oP zg>xIQJQ5Bw7hwysK5tz-^h(OUm9C`!jKZ#J!D&US-7ZTzp&iBgo&+Xp@k@D}9UC=a z#lXQq&+Rm9aMLKW-u)93B^gj7+of7Gv;@(ZD(S-Je(4e*8*Rn8UK;ct5y*>pno9OB z{alG{73@^K;x0}g+(ku2NsN&%VQ_Zq z&G+O_4&s)SQNtprf!5Wr6^9q2&y^0N);N9QRn)E9S~0ag{-H`Ff*Sbn1zap}8O0&k z?GctD8PU1_nwp z*lnAE_RGDetq40|2|j7g3Aeq{97Mk)>sx$kAk4k*tHs>}z4gjBHzgnJjoGb*va zIH`6$$#Ceh;m@XrXQogFNx`TpP9>*P?n>(rEPvqN#lpMmzH719uV4NlaizRJ$4^w` zZ*UP!brJ7{I-gl?l7^L3wx5{t@#9gf4f^~{#5;r67X??1BfS~s8{8uyDuA+s>fGGv zvo|EW_Q*m9D$NMYM5CWUxrcz~_s8%sW96&V`1R z@XX;&x+3J*F2GR&6ax8-HdPcYIr&VN;nIETiO#Jt3I%5tN^GTPcJBk(qX(*qWIjS1gxYaB-$ zE=8t0L_y$g!W>XCTb~C*ahmqEgoN#}*(XfTEV&GRfnm|)m*1EWRWJmKeKIo7o;y+(l9eoCafPXMhP zB|Krvpyw{aQ~fGSo&$JMSzDV9rsv*A(U#|XL#cxdVS+{%bq%$Qkj((~pCkXlq${v^ z{EvV^iS(H4Y7w+ylCIHqK_MZDbu|5Uh+z2J`W;&i2q3>7I{QiiXZ}V)0{8lLlmr_z z{}Y3s*+8xmmP{OIyJ#oqZct?+vA5-C;Ma(tpJ(30Zb*L;lndKUE)WN-Y-~z7x(zKY zs(DAUieAJ3Wwlgo9!Y-%*j+RD$d0;H*YH7sld#0DwpN;~)`qyPXd7OC{I|aoY7b9;MITUXK7|XLk3qKN(0|<>49cC^f zIbm+@q5Hayz_C@M-UqqYBM6s2DQH`{@z#EMq=}jZGsC_21#wn;?wjsF;SZ~=tyTMT z;IB^Y$)$RC5ct?5TlB|-q#YUACXiAF!Y~i&7U9Iq$;%5xdmZV@Xf!)NPnmt6ws<=9 z;YNi-D;~fWwQCsyQg_WIhpG3KT9fe(i_?v=4_N=QJOOkd&Nfz@8ETqaUaA7DgXd2-g2SHuF7n9WNtdw6ez- zb|pDMvkGc3YFN|9U%j6R2G8<>h!lk!L-;@mOoue@1|JAq05B<-%gDhSw^}lxT;Hz0 zNdvm!{w?uD36qjy1(8DpF0k4#JjQ_ZQN9LOqQAYqO$c9OUYCLlS5{UCvmQ8|a5O#I zwB~xDf?wGtOabP0#u^bc_w?NJU}CB=RQGvfV9CYPU<5(123o<>kJ= z&tj&8icka5E>yl*B3s>May>RS&?%0+SMD-=b&xbFH%9|Vv3?cs-)2~-zX?)Ls;DhF zZf*0iW5@%Oh!k4J>LA5g0LzO zu1LBxs-$`@aq;a?uh~4W;P|I3c3n1vX$KP(n`RvLYKBELANDM=C#G!lvh)`ski$hF zD(|b=yzz-rv7zA##l@Ln#jD}rU(loVQLpFUxnlz_6?z88o`M@ZKeG(bDZpfiv#$K? zO))`-HMI;ehj7}U99E-xq9F+dfIW9uZ9m2%IM!>jwZXalODv@Za8izf`WqD zq=Ut0C^RNplarGHs3as^hhhMB^MIx8-an0qXm-+?nwmPCDOT}%#4vecWnuOOhyBR& zu+c|^YZ!b74Q7Hc>=LlCwlwh6yR47vTG{jVb{Z%qttk7}g;tG2mLKWb1~wul6xYwt z*S{xn00}A!ee8(V8GqM;0$yK8txLPDDc3FZ>h+2p}LdW&9dA`e@W3N4hPi zDy88O)|_soO*`v1ZWlF&L&svdvHGh?18mAemOmlsQes2wE zmiuC5iO_!3;@D#WNo?UCW>c;v8>9T>I>}mi{&StIjEoFnS3$+poDf6ZA(Hhhnq6Y^ z;6J^PCb40PM<5(FAW2Y-TgD*xz!aZh!tzI8;Y+<15KA|_uP`1EZAF5UB6xjKcnk@L z)8~NSu>(zS;G)R7ymA0%5n$5|D&On??4pF#;d9W2EDQy7H5S76;5$X#XH$U4CN5U}g$>k?{VFrK!&k zY(rZq=Me61yR=k%W`?h{_H0H<2Pf(KYCQu(GdMj(4&mp>2l{hpwikZ>7>%I~$h)Ms zyHx=|3Cx1`Bh2<}N0eL)$RrnXtk0wr1_gm~BWCXuR@PK_hOPplNnCgW*D}FPf;&to1t(3rFu*q^% zh#flA1fL2SKObkWS7rfm&=Df4AV?%Hd@PvlGKN2TX2uO{q#f#WLKO{pd!{D=k>PP6 zW?W=o%7bhhPiKmLV$5je_uSlri(k~*9v;b&4(hE}7f$&C!JA}dr5DHyen|~}Ubk6-{r z9pgQ)5)(uSC=@cFB~ZEw0Lz=V?V(m+<4p_*mK87Sv}eqcchNcayyW94^u81g3CV$D$^mSMgq zckJdSCI_qoW;YSmG!!ecg6i@qL*Uotm6hjc6bZnK;C=wESNqoCEkwA3*4U(QXxX~h zNa*nSJ~|XxRW#IMXJ4_F>*)a_6QfDszh*vpe{MuWgm`NrC@=Vo2oQpX@%{|^JTCzy z5nZ_$2xS$sql9btD*kFm0Ij8edm(1mOs$hau1j4-Zc^Iyr*nB}5WRkqGA#EM_ntJ_pMv<~d<7KiN+YB7~*0AG#dj3{$>FM@R~caC@PfB=9JR{cN>R z^1t4`kIK0*a;7bzCWmrEh{Q0naKBNW7YBtUMrbgQrW=}?D6qb*h?f~CKQ@pWNq1x; zz!ng_0$dMJ1S18ywSJypI5}ly2@7#TvaaFubf zb!!*`9?CE*%@MG*MSRNX*xY8YBbXrkkRge{h4f|X>KcbEJ`9+*3`>O#{I&q-brt8` zK$et)IogVKm<3Ju0gGh;auX7pmy_kRzFfMH-K&bP8DC8l9XR}ry zYKdS)0YLrdNiO`}nf1@>h(&sEzF&CuXBaX^3;I2xtUpKVjJy!6&D#{urA(N|pk~tm z<|7DLtVJ?lWQBqWto7yYZ!aPZqKyO&V}#KKaver)Bw@I^C|n9(4P3s;&TH#@Qb&(A z_VzO4$HZ7M)`4)t0xvLQ!>+#Ds9MfC=Dm#|ObK%4qg?N0T6+2yAe%tniJt4>$D=9X zyrH^5#;98+9fJXQkNo95L?s6}7zhR7vXw~2s63#L_i3j~>Cv$lk55kKpu4lfNknA}zq=&sA+K^!5;)1%En>U%ib!NpuORz_ysB!Y- zHJlfbu}AW z-9Y7e7Ua>x>|W^Lh{OIWQ+78V{|fL63JHn-yT(*k4h0j9YRxj+{J?*_082)o0AK=* zP`-#MU<@%_AxOz*3mwRQz_($TI`sPWF%ljS$9c9A4TK#r1PtQ?fqvPVVo7IQQwWX+ zU^-PkNG>KOMiiL~CxZ%2GsbOFC}(lo!w6|qxfK7-s;a8+`uh4i{jSIlZeL$A5{(Z^ z*goP_STfWmSU2`@aVh5AC`U_1h`U6h0;JfB;+H}fR#jQq0@&^bH_m;tN*bd1Mm0dA zM@$zHiqP1FyeLlU@wazrX=rFF*bl+fi6I6k08RnP=$DBRYrG4=7f5+cv0@gj3y7FN z+!*p@YZ{1+iNTGOiKXkPs;g7s*?^3~`o5fj&|mIqh}kbdqZ?USBBk&F*R4zl5b_av z`Ba!Eii}F4%IeqIhgdBRVo`{)1g(?sU}9j5N<>6tkE|aPXv03Aj#8MUcy%&kP|}DdgRs3qd+olf z#X`JhE8F1)IMlAg7trPhavBm8F|0;deTj?0HBW3Qk->n)HF(`vD9KQSXBHNESM(2f zBF_=K(--;5)5D_+ULl;8^Fl#IbNY*~5n%nT;CdML?1{mh*r9&_f}lX6A?6}s*h6^& z^`#=i3y&hfQVm#PjsaVAJl($xK~-Q?D~%i;4$p-R>H;xP`oQa_83Q9?rt7}xq4|kk zEy3MrynzT}e9}o{OC`u^=S4ghMU-R8Q`%p@-cO05q> zUT_OZRYgT3`8%vA!DJNFq#xts@i6&gv||V34R~+RZ@|s=Wn5{- zBXmbJgB7adHXUUqW284xRa8{H!aOs)lX+8$p#g)gjIN%dq6(uai>0c9qN2hT%I)}= zkecaZiD|F&K65l3es{_3$K{T5^6O^euC(`5%9;CdqF?5P!q5nP&@-gC@QFIX@m zP0p~szRoQ!u8;O%ONo&H=^{wrmZQJ0zwLjZ$0h!T4lh^^dW|e%X~F?{ z{~!)L^iNq}@XN6x{vf;X#ck;38XDiGXN5TzCe1ic6Wqa@d+;R*`5jfej z3aoUSyWuVZvBgmDbcO8LxWe;6D(ieVIZ>k~*`B*IyKBRzd;`=bPO2BzKsU%wiasMQ0#T+H9B$N)HIEgVHY zBykG~{ZvvBem2)G!2W$#tlI2=eO%igA_4&Mb|N$HIOa9Q;8$z)@lvNO3pb zeWFW%P{Hn7&BXHbF+<8W7Nv-l6+b;)-QgP|t`-ODqQj0g2{ZrNn%KsJtj^@wmr^HE zb42*AfB8&w*wMnWG8X(gOYO$50cT050l4--rtcOLeqK*4dwP2#VY9_#=)wC&#l~w| zEnnL2dX!0iyx`sQ2ew_UZ{4?F-HZ-1FEN6+%!BkC)^>WX@VoN|969Yo+vKbJ>?QXb!v_g1y*o#l3ezD|<;^*F?p#GbfnhL0+{I``^|L@1Lqle0 z{olchVtD9nm8&(dqnf9u1cDwjB*8GUldcciV02F{fd?5v!No;Leq;4e{puX8*V7EJ ziErWOkDCl_%2$U?63AdlHjip1L4tw+t$Hu&LbOA>7Z~(!ZgeQ)I0^>EbApi1FL*|V6^15H5Dw3F-Jh-n8;}bowyTm~p z%wm;V%?FW}kd&kXS_|Y$b4v>`J0$HjRj|xf1A5q5ayRUaiS^G7jg1piQ(wY*1!R?v z*%9Meb9lE6B83sa6Bkc4=%+V1HQd; z_imf@q~K0k7_)%?h^f3rn{3!?=BEbVoi|?$8+88G9JvE>AuukX5C8@M{apv5J8;$@ z?e$q0EssJ^f)rEXJeYtHXM8Zi=xk;GUWY80YbP&FP8FAQmM(SQgzFB86!T^^cKM=@ z1_hVohfRKUVW)UBiO)Phap;DYS!2b!e?P+fI9Q6>3s-(Re}@-pzp(Hd*;GjMHJ^)$ ziqMMgY;J8$h>y=Ud9wei?)(-B35h7V97s7SQ#-(z{?}LO2?L5`ykk`R2Cd}n6J7=c z`=}*Mp^IewpRbF#Y!CkP`v3E1sZ)<7wc-Ey>wo`GsndU7j=1E1zS<>X&o$`(=W74? zv*w=ORudfF|NE=|a1ogngxUY=YwVVqgiT?=|Le=*UBPBSxB&jIubb!DdV}wxdi>|h zJ(l~b0`-Wnk=~ys_e#(8bDgLDd{+G5ms`~=C@gGrmV6p*SgHrq@dF|i$PRR6FJ+f? zBHK&r1IXItUXSMk$i?jfgYthr+8kAGT^)OL%cwBCwTU=3zgH&9PMMoevIq1QJhC-dug6FL zK4U{}BwC~nPV0BF%k;6m=kC_k4Os@fwvoJDyLjy2!Fs;`z212L*Jr=P9vPac`FJ0M z$Fo1*ZbK!@fDvnHSm0i6ZU_u#;x-Mz0=Ew2fnaR>W{4^ zYI!#T4E7{bZTh3rR)mgscbs(19$h zH0@qkQZm+4`0kh8XN$(4)#QfH&eOWpZzv6)Fs6RWQsZsu%580NWy1GkXLX3o%OeYO zZgGwN_gR{5KVF)DQl+f^d!cl4SJ{zW%QBxWy{vwvZPrOcxx&8;#%_E8XI|5?7+<1a zU@m_cz_aJa0{dXCmGk=}3{1}0AJBCWX?sk1YMDtwh3CVhaktdEn zK$f<4WbAlK!y28dFRAR$Omg^dch@I%?jt|X8DI0Ks~4i*R-S($uYe!vnOXeid5Y+k z=g?w+P3U$;hoRMHU}3>5<<Fa&@h)PD{|09YhLE^sFqC)FW6o0aq} z=#x%6I9!4&0~Rd+(0sI19#aF1pi50(oU24kb9X)#z5SZ_7za+x?Es+5fB$x@;7}mM z;aU)7i^XS}gh0t5oC%Y`O-H>kpNtL~`Q7#~o2IrlkF0D4Iy%4kaYb0pN$Q!0#KkeP z#)H&`*WAFT7@f@DGh|?BcoBLg3W^ivd9f5os+H=6w zuk$ZZLV)zV4T&=B{c8{S%{wR;_$-2pXg|^V?1GPFm_H6SnE0DF36l+=bA{{YOx$hU zytNQYYD^5>A2!(3@aYxM1(bDl^Y;(E^{CUEpo3HOtln|nz0ZPZoJwQPw28SeFj>A!c^0DWrJMpn$Nb8*a zvRss?Gx|v>@2pL{ydI~2N2Nv$9M|iIle+EYOU}cGlOWNYGB#GnhygL2#m^rB^a8i( z?zs7yQRmxWb^g1m;v}hIOm9?%ixNBwM8;e22jT-YG*GdbT?SZSqiA)O#HFYjKxZKn zlQ{8AsQERP$A0UZnYF`1@nF#TqsO}w!Fh7TkPB7`wno3&OkjX_P=@FIY6E1w?;8n# zF2LLqW-ruGC_$6+!LD0tr2}Upl0Iv!8p{ApPv1gE=V4sSgDb$mnV6WU?B@0${hHP%s+;G-Kj(+9a--PTwY+6@l_!oNuT4T8UzBmTC6ly2>QcsW zO)Y4og&|vVL-5+>5(~pZ5$O))L^b}+O51gBCaQg?zRto#b}8eAq@UuuZ$hWjcr;Jn z<$YTlF7A4C&~$mzwH*vTBbzj+8wVUDxh2kh&)wp=$-%MfF-0kbw0Ui$@au)EY7$Sg zshQG`DxUt}qps}1t=Zg@m8Vt3&T?8|G3}Jc_<$ZwP+wod zDP0W@4=qz(&F$fr1C z#d3!2I>%a=Rjt2&Px+1)m+v~1Sqa~An^W0tDJ{^+qU1I;p!dY|?>boA**k+4c?#e&eb@$SdxK*RG zS$EBi&pe4~HB+(N-z_9kp{1E1CmD%&n|n^9!#YGdc!Oxmu#Z?=v-iy?FmnDP$| z-)oHWa*^oQGc?n-p&09^x+fYNS+(sq|L^BLJfqSA@66NF)T~8*N`H42xBU43&~)AL zSoUq75-LSXMn*z5*_$FVQ}&iUviFvdB75(UmA&^$_Nr``nUKBrdXMvY-scaW`*WvU zm-9N$V|>?dVjqxlGs00R$~=ydoqsXDel^3pJH3VpZI9`?>uY&KDX$l7-F(&fc_E2U ze7@55#=MNxgwzI+OY)0&lPsFMsFE^Kr;{JAF>n7{3ZEII4gH;wy`y7nl1%lGI^t=p zPcYv5>#UZPbo?XYcNt3M2RR?>yk5L-Pj>wl#vQpR4z|*lG`~5sf*##6x>oafZRoyt z6?b%ejA+2il=a$wS~s?>j8eiAWZ!F^A|Fzs?sJEmMr4}xUIOhoM1*oV^j%cxdiUI7 z-B|EAxr~0XvrLQMEq$5#RbBQ)Xrq#1n7DkETS|mOl$DU1ThwvQpp?UA8q;pMBJID4 zK8~iQ3%B0+@$kfyKlaTzJ2M%ux0s~3e&Ct$P@H??4p1sW7X(ZA;=Knvq8R)O5PZT1 z&JaKd!R{kJ68iDuESOP^ASEHtxeJH^4nRReC`4F#&|rN9q<{-Cd*==7myIKWV%UPi z25n(pc_f7o1sGZw2yJ2j!!zkPl*Aw!(nsdUx%-+FCQq|m^FB(X`zvUt}yp(dhIKqpvX9cY=bed z%(4LpEfGT61psh7D0_fvjc$ea(+OZ5Y(KLZp~47XRXRXcpwa_Szk0c8xc(b=XiG4d zAjuvsfM2Qu;B4KnA4AF_g%3cF0Bge@z9otwl@$#*Nkf4A5FNn{*9?hZgaCJ*v<>)P z9h;aa18nGcy(kMZ0Dwcv8wS%q5L~SR6ka)T^x1>UN2r+#Bx&n9E^h3C zs+h6yV@8$yS-2W4hU{H-QV|H~3M~zT^jr=sHS&Vn7?&4^O$3g-U_u0u8i(zl=QSxv z&vD;ui0z>8PJ%ylC-R4(4kT#^xVHvoI}po&&x#nJ%3koteEoR~2j{Opp$-xZaN}w> zOe8gPA0CWBZVNO=pn?(Qd8NfTqK?)&Y%a;jDr*21<_Rc)h0pgC#f2UC$>7J$0m-NI znJekg45S`s`$gVH7iY%^fMr+R@@5u>YJK40$tA=S``Te;fy;Xb5=&ldvGVf9As*nD z$)uYYj*gCycaZ`l7TsAtgz=TR?VBU8jQF{&2`K0gC&dmIe2DZ_t002$0o%L+xXR$_ zxB{8{W5xjyIf^U2?{J2$)%ZYEDbu0>xU0VD7j#;_LGpC6#KK&+vps>%Ue zEKCR;RH1_3AuOc_AnhBx{1vblvqNHEX<6A+Vb*){k2ZXyAC6}}eicmeuI*`In~l)A ztv(~iA|)B?`YwA-8rS4R&{nQVv4f+4citwpMt7+`<#eA6OUG~;*Q2wZoP60%t3!Jr zvDdZnw8DcTq}qG)Dl2;t)--&mu1A(w5q=rpcncXRB2b&VW_JH{c}dN6{$Az^9x-rq zF*o#!H2js}zua6P-53q;*X__=+^v??F8s4a(6OL3Bev-*Xd{qxNpIK~!YEn9Gv4-h zBS2ordf#_9AgDJjVClHurfR0q!F$z*C%&62V9II<)|**St1TfH6g-AN>439l0JwO9 zvKvVkSx6Kj@{z$)0~6<8z*p)oPF7)31+49`7^Z+@QX8D~j^GC!fKC8xkPTZAfHRQs z)p`|Iuo={&=p9eN5MKi*d?b)y00$p|xnvwz8<4eT0k#q7GQ}1zD|o&)2+U1lqIDxY zu(*nVAOYa%vQe{yWaL8aqXkyW2Is_SbGi?nuyE>6z#VU`SIv|HWe3P5%YZN=J-r?{ z8xXP=(PKr$#wsc+w*lG$_tK>2;S|^fx|d-Pf06MEyk0FF1A<~8NI3@45+B6(KtV&2 zlOR227t9c)@N5WQ92t0labEazjRO>k1CXMH(B}(B&1_@$zq5&1LJ%YJ41fq4VuV59 z#0oVD3sfTp-BI-L4Ab>bm6_l|xq^UXUqB?nV`D+1PLBkl0MqvuYLy<`e>bjv7<2(M zOdohY!PD~w^jLfRmwF6LOrK%TM09}gTp&do5Ea>Yc7Ft^K{`mtsyVWZAcfMpejD>} z##;m=r8E#|g``9PQDHabINDVU#D@_Cn}F_Nr(a+b@`mJKrUrV9Qdl@8fZXk)s*bDp z#YYh+->}d?HQb_OwDG9FTuih^*wm?hZ>`K;){<(j~%j1+w*Lpp=1?3fTg{GqekmBBXMP zk0S}dA3?WR29*tYL_pOEf_?;-st4OHLf;T{ipWul zq-em_08h&+H8n}VDv{3$dcEM~*{;PzxsenS~r*Io6iU%_ZZwyfOjM6Gr_Iq zt2(P`0;1SRn}9ak0gtAXj7&yW)`$Fjru$54&G5*&f}mWe`{}~OUwM(MtNOeYPq`Cs z6{yI-Hui_+_nRkp5CsP6Z=OjTU%_CFyy2Z$UtD%z%BNlCZ>j744|Q4y_31K1B2)lx zL&$a4+|N7);r4t}A{X1Z$nW#zneX3X1Ve?-5b&U$2pSnktokVU073n-Q@u1st_48Q z@lvV@cuEo13yckD&@h0pf(011@HZ72#82Kd8=Yn$fo6HCMaJL#t|R1rzl^CV9XzFC z&_E!&SjS^qeA;c5dCyG2;hw*BYr@8Lu4IL#gep~KzsL?k1rnnv(tPP*9KUZamn8xLj?aJ zqQ?i$ilu7WjS<$Ncdga5Quy!y>A~Guf40-JBO8R^13+bi_72g$BeMuha96(6*C#>y zdJjYp)Te&19oVu1MU3QE%kfP80Bu1(a^2LQy=+}TE*Os$X;J;ojqq?n0yFG=-A#eOHthY6B@CsKY}%SivxJbUJg{4-X$Q>VV8` zmv6ODSEPf<+$0%X+ak=GI%+~_A@Qn>J~RsY7c7a`d0ScK*7`tqa)J* z-JUoE#Utei{xTsf-|r`z043c1aaSG!hY?k6Hf7_dy}&(64y;m(9ozXe^T)72)~)&-sc|V%~eUS-b=) zva?m)%Rc~(Zxw&YJLB2*c-Q4}YlorUg1T$FxUN1od%AEzZt>=3?R4h!-w2*LR}V}V zo8ttR*9Ul=l3%tCsk$zA-&50{VJ8zZc)PmBqqFGX=xk-K+Rij+4Qz{Uury!`J2V)N z-kg4U_}KoB&Z2O|LZa=b=SQ9S7}(a&ruP~?k{)4iQ95;GCxoJfp57#{ZCr_S&b?}# z`A>634waZ5%ITuoh^?CLMN_M@rEE3LP+ON(WKX8BsYfokgo|5$qe0SB!baRB&tRkE zq`Rowo6y_a8{)ruVfXBY3(*H7EwXu;juoeM2-)AB)`HzBeQ+5GHvlE1f57SW#6C!G zx)05D9&RLL7~a{jTUlKNs-+o_%d+4?#CwIzD1gm>3ROMvw#O$UlY7E|NI(O20Q>rNBuDX`L3>c$c1stuG_)~D>Vh8g{Y~|3C>JOe z4t)QH;Jq&`We0SiA7*ZZkY8&iC%xz_`~VEr70`|41o3BL1(Z435Z&-xC<5UW8WPj$ zeKt>FTA=|6N^(G+9k1jSfvq|X$^#nYFuVt(nB4X6olv_<)H=iz*{zMSfgg>IH8U?a zH!VM3_P}6K8tQoA*k&r;d$=~ptHV7Bg2E0{PP>zGgECs{g>R#)4gF5`{0&7w!vWg~ z5k*i-j-gZjG9~38XZH_$`MRB7VMK##Yq4L0l11tN0P+V`XY;(z)>cYeet~ckHK zMjDsRhC>i1*QFO>Ff>suDp)wF(r#RFH)2s^@gTlZtV(FJ5!+ggi^~~f$7!`0$tAA7 zHh#`g=&mXyi4nhB@-|8?`_U%ptnea!T%cWX^}3-a_d2I&M3~m^H|)dc`(qY_q?T94 zm?h{O>)-I+Su_s}Iro#ub~vJ2VZ8o~kB(dQZ^>re)oNU;tClosmfcwXZ5HWjaUYqg zw;ZKK)45r%Qqu2gD#gkBc1pJOgyUV2F(TJ!NX+Q@Cdg1$9>_VyZ2U5I0vp?zsm@VB zGt5U~Y3cQ1)BS8kwLICPnjgEARDNHWXzzj!-s5_pJ$vzZ^ira%EQJqD zh^b?DY}Xz~itdshUXoDc;x@kbK`-$dfonH=RYGo2UW-DWhwEK}@g(7$p!A)DJZaP4 zrNkPlSSwE*$B)^ayCkIg)z2LG#XT|U2805}vq+!D$vG0`KMs_J%N|SpX|1;m;~HI& zvRYhd<{sS&VJ~9o{BC|&-$YXN@`sY@3+*{Rhx;A<&t87^AHR1@e9tV0k#&(!lYqa9 zy@;`2;S7_mumA6M!0zQ*pE9dt-6^*1QMdBE??NM}J7-oLO zGT^=czUI)&ZFGF!Fx$PHUQwHjOF263GvP`NwUp95W4%fS(Af0^6)Q!jaaCL0dq`K% zo0cOnZX0Wud@WX;^yRmmem#eHAGEO8l)#oZTmL#r2T~+VqptcS^*Xd!+YFW16Ps-9 z*8MD`c^b#cd#PN*{nM0F@MzW-O>lomQ8w<04-7k{00qLm|Br1Di}VA7E-%&_;1k5K zJ8nlWEG)oC9s~1y0xU)lL@K(uo9JCFFx995Bn32ZAoG74s6M5QpuR&uaE;e#yOuPm z%p5@wK!gA9{tAGN>7%PcJGLcuwM2v*6CgG^{>%fk3@o}ZPZ@Tsyc~VF(UYcS%W?_^ z#MiurSRMQI!8c*IM7k76t!Nc(ggYX!*pO?`yWeNtBGI5}|0P1lggH zW+CsY7>vR2jzFG&7a#w-L8uTUpKu@|23U+Guv=hND@LtPx`GjA&AGRczM;FF4mcwfNmjlwAu)1)1QO!bur!~1-zrNAaF%OePFSdl9va8%FwE# z$1t&!U2oDo(a!y{oScu}zA=E}etuVw7L+(Czvd^e|0Dyb7xK{bAET^c7j)s0n6Tgm zjcFI)3dlQyJPeF0T%^H>pe@zzHfbJ5Hq&<42l^{6vp6qfeG+84Da9)kOU6w zKPHIWT1KGXgi#h?NCQwYDmvPAkD?G1JL*e5SmawSA+7%I>nk}r3lnYb!LMo_6#_5~ ztUGMVw*d7JhvuZMEe972)I8nY(y+8QIMI14fd$EIB!8Sh$i?gKEzJz&wQkyGtpM(y z>p_8SvY%*3+aw7;-sZrYsBaKeF)ItpHA^QNqmtTtn@;u3a_!oyCav7rSS-g2z8qJQo?(67XUyVkJp;O)OA5gp) zeXf3+MCze`g~Hbs9qV+JA^lsggo(s$$bu(+(Ca(_XZS~wVP%zmde>WPwPs2` zy|DhCWlpKwkS24~+Xsv*t__&{m8P2|H}!~L-OKR^FT%;mRIlR=Ju|2NBvD{+k3I62 zB$07K&H5Rg#lC|riiVwCfb=rQ{Olek8FDWu#Gwe)^ZePV%;5jRde-C zZl7q1w|%J76qVA8NT+VMt9T1BSd+S06#n=2~mQ%l#t+@wFwO@qtKOSc;cg_pF@M$SG zoqo^e1Ir`imv(A7=GL}=V&oPd<;@|gZ0TF2~$LAe%gLp)w?;q3Q1fvRr z(q?~|+@K7@E4Nr0!8N0vaDKJeqNXY1Y3cu>&dP(1OwquI{F|>B-UmD*A;K#em}|FC zI$`MP6S6@EWP;s-GT3Js(Y4Ro`6t@i+@orS^|PWib#LGeJ{uo_50TTU*5P&K;pahG zf~Kk5yu6Ic%8}K4g6K<9*hvL0xCw{;PFk=^-~0 zQ}1h&d=;>3cY^@|5x(OJ?cqU;%CiV+K;K+pL!Q*H=17>I!N5k<6{h zWZrosiO}_5TEL`ebh&w^NBgC>K^1C&n67`^uHQTP_~65C53R^)vDR}SFcJhy)+XB?YrRZJ=3ULIo9iPmNgi5u2wX@43&^wVK}6V&C~dU0 z$tXOw&|%|M>_xNVXY+=N6vtytj!;HmD3gi+JOz=594J-iRw5c8u z)w~^bpW5`{JO|*XL#k8l+D!YsJ3(kb$dyoyfB!xrb7q;a@+$Iz7_n7=`j;wERt6C0 zj=V)kK0^36Osx`Q-psya7xN0j&{R(cBsli||8-{uJBW$k|}(fb~J>s}L|O+x&@3hs|%E zAfkAXYC-DNRxPt9$OPl#<0T`WLl)1ZF9D_|ZU49cG(t$d*l4<-9IaXV{QwjKP;!w3 zg9lDYzH7j{!9c(8jRmZVHxauo>uT~S@Jj-X5KHS9LdHr|kxY^4b+i8n-T+yplWBp`yvvKj_B_021%tMw5JsPS zbQ1(ih=GOc7;rhWiSp%5?!;y3JEFzF*#Hy_%{CJ>66A9mS^!TVpFapXLfN*W^*Kq@ zAzMTg8__AXtu@OG`@ou%>S+vq8UQFj1En>@n=`s<21h4=mIZEot&ts*=(i6RJWfRD zKP}C642Bq7n&t3cTG(@c1LPP~ftg_--~R~Ezxu`c(ozQkjX~%8wd{bPL7=1$goUI8 zm_m{0?Hi=5{Qs|*x)cGk*D61< zaCD<|+@chh{Lsh?ULlf}Rd{em0f(3!;~gM(>k(xd$VrFPpJ0m_UVV%K@*E`L`W?`O zjGy&D?1M~Ypf*By2$&V50J!z=qm}kEjMepe z-C1}a)?Y~SyTQBSUsbvG1MUaly~y4Hr!~R6*KJFJ=Sl3~p~szwsBA&4)H)hFZt<9w z_621m^`{5c^>^OEk5QkSoFeSc47(rHM&%hD9SuU3yZ7%eZu@}rRr)|=0d`KPq#y<*2Nx|12^oh=n>6qGhG&?106zvB(K#Rs#x7s}DV9SPXB@GGWmU@+!0V|75L z9|RLn7v`gE?@aH@(;0Y%yH4N^uHSBd0HD+O_42#$uc4ZiXcU0TwR0y3ZW-7!G0{SW zPw4(Lcpbrk3+ICnwOuy zN3?Z8i%{eM4MupQ)}25H{cy<|X2sI9EFb_TA-#@N*dq?%WlCf;px%RCa4Gfjj22kW z@L=s&knnfb(bjHon^kB4)Lgd4v22bt4yOho90v&L!8FtbAP|9(j;1E#=GX`TN#yQp zZ1B{(08v8VnBUl#0&=cmXee+f*QO(37odzG01hEE7vk&LXu9-*1J??E+MdWkVc)!m zIR(tkwAZO62s~NLF>19S$pcOX16ir49!7pq(GpzOSzxD{hhy^?ou^%Cf!#6$H9t~w z1MRK`uxVg-tW{}RHxM9*470`$pg-nck0uuyvtTWS1iZXdiVXt&Fg)X+VTZF`jB5If zBY7TO4QTn@rF*eM2-UO=kX~2d^n^aA!EFf7+%dRnpMVj#)q>l7Er$pn|2>$e;ah>A z67B^y#E2?;b>EWvfhaaK2bZ;yj(eW*gV<+q#^aUSsY9`UKpdJ4hob-?5CxxRr$M@Z zpK(UD+H#ZP!i2cC=)bE#-9R=<5Z-$jxLtl$|%S;sD4^NbCOzbFxvR6e#>+vu)Icap4=Gx2nW@df<&MBb5 zV{*XN#;3;IEvQ6jXtxvh`*jH{$BQO<&UvTC_GCT>Zf!F8)KY(q+^o8El+@m(og^iS zdHOUwBFx*#GAQb7`>LuUSXYsP-yl+v+07cDd`zrn=@iO7a4&_Gg}_x^(#a^^w^=Jm zrU8X{$Dc2LY_hxE@LOw=H)e+Vv7Lr$n9p#?_bz8`aki1bC%7HQ6WvW0$SwA%8I&0$aW3U3dgzqP&HF{MI$oszDvZ!c#_ye59kvYX%d zTVAXAw*%8rnsJksuk|Js3vF?n=r=l!MX^7Nr+7*lSz($tds&1VdETXKe6{`?Aiz~Q=hNzq& zG7_=m3=Itx1I&)dQ~{R;fwA(Cs#HWAB=SRYGa`%G>3#>v`6}FxT{3{cL%4f{=mx^# z3FK1)G}#BV>v*jrB9#P!={RC-{w?*fbr{4c0V7vW^3 z1t8xgibi*V2m)fb^KDT>J80-?7GgBPgoZekji4z(8e$?;OxNVO-w+uMiii%Nd(nZr zj_#-}e!PJsR3F+#hBEVrxA)3EQc+is;GuObVqax*bRIVl5W^UIuU^n2tqm_`WC?TIhYrr!TW(s zEDk;|Z9Tj))cXHZH6T|Zg5v@}#E}kxPhfc{@jP|%!$a;-VdoQvOgPa9Uf}~4xeGF~ zl|l9h0;NL}fb*#kBN>EC_i!*M7g{P^9TB%_`~hC8at&tKN&~@-^aKwN?`7^87_Mlcy~8ASE_`Qs_A?ElM%4)Jy5+Aj}Qt-!<>sXyPVRd~XAl z0D;kcp)7TM!p6vp`My9+dTwd2|MT5NJhE(uFzqP4+0VL+JgE0y-afcmz|Vkni@$*) zc%p{y70(F%8;;-g{=d_z$IUa|I%j&nOIl+(^A$|4et>iF!^y#Zv0xAnm7CZhlcZz) zaN6=o#_&^%rHyJ5_v9rS2gMUPIAS5Y3}=0reMFlwmXpNo`aL5nu2I|BY{Rqf z(WpD4%N3@NCKzz2HMF0ow@Y$bwMTtKV+=+)t3=i4WK;c`)>7}l_`&`A=VTvoV{ZS) zhOEFXW6%q8G+7ETRCylYcBOX|OZ?Lc{vcZHP5Uo{^g=Hw?)<#u8dqzD_RYLcYvvqo z^nczz`ckEgcNaCBp>6V&JUd@UoxAUS0q3WErd{@il;RPq+cS=C6HW??EvETKVZTB@ zusonb`}+9WEBr|n+nKjPyTw?3ZoK_PUBim_LlUnS34Hc(K5nkO?kN3z_JsR&OmI%& zu6l>Y4?0v7_rs*P5jlc=E$nBhI+>i#sQibg4n#|wazZO=;o4M;OGAc<--a^{Kd-A;EmY5ZUZJ{} z#wijI#USEv!D5E@p0pq)ET-G5S3h8<_#p61`YA8}L8E+T^0XV6A|m`wDkIsGdqEwe9L>9r^s|Ru@c)&1$ngctk%jtR*2odxDkb!n(3$$2+V9S{H*p&lTN)n1< zyok3jjL9wFt^i{x+Ytq5D!|K#$TSeLYovgzjJ28VCo-7A#+#dtYkND)Kwtm-Fazy> zS^(%JxQOBmc`JxO6FMPCt5QK!>8|~_3Mg7XJY=;)Vu*iq=$gKT6%85okQo}n!*_wA z4T7a5ZEzVmISQOi4CECdR?Es^6Ay?T~N=<-R09wl7T<3!zTz zLa!|GzVt#gE)Y5dqBZ2j5oHwOOx#6uBLL4M4%RM20R@tgFzSHI9OzZ-kO~o+{D6z( z7BKUN2@+Bfh+^TVc?FYZ%6yLNY`PXiu*3ZnU-Sz~7NX)+9JS^gCQk z2<(}Kuv0^rY9M6|3EJ%D*iC};V?-AT!m$?EqbVN*gS5ALe?(L0b0y+z1GWKCd&58k zGY9MtKv8gjrV6gL>zqHK%b!oQNSB8(zzB3}i0BT0pEf%M_;qjbOg@EhW<)Ilxk~kW zzh#mjC->_q4Z_eu#dYRp; z%|dF|_LNYbn1x-nrs%9T7Q9s3VFKmRC!*g?>NnU~A~12sU4@)$s&FA_oM1nUKATW*Z7`D?lQU`u9M1sSnZj4vudyP8kw{9 zT)eRfnf>T~d|^=MlpkR<7)(+;eU?W1qb$^N)T>=J$5<7V4_ z*1yaB<5SvpK0G*BliSG1$dr==4y+dZ{BYw(M+bsm>VTUBEYILz625g8xdVZ|f!jD> zVnX9TmaalLjaK4|MY>zHeS*g68d8+~BU z$6!2x)mt=zx&)kx$JW-s!P$;#JKKT@0K(X$VNiprC%oSh-URcEJ>Xs7W(rivqY)IG zT=Ili(?#Uwm=z)e!U=(<1U9ODL3RL+umwc;&SL^#@r`qYMuhWHo83L8;buloc|@o- zz-nIU>dL#g@Iuifw}ofU4v<|Ahyeg#GmLttGZxBstmt7SpTj=a#sX3U^rB<*#h9`Mb;Mt7l-eH z$A2=lS{Kl{IB?dngWxIDi}uNrFvwH2L9VWj&Px}U>b1eum`j7rz6@%<755o=r4gN} zVN|b!{NdWE@Nd(nlI-_`!dMQ(-i^1!1iLU{8uWNg^R|zEXWBuhAVzKV>JuCOM5h`r z?Temi!wK^5y@r8LRo=h1*ErOuYGlkzycxQZ`KU~Tgqefn(~%9Q!#O*{F5#V~&W(?~ zM;C<+F|cB&@Xdg3B)ZxSg_>?poH;Wt9cK!cH0<-Qwc+ixteV1funvIFcNf)kj;i1E z+@wmh+*JD5F|Xa>zxZ98^^MT2#^XL~IGv{k)O^U7P?1f4Ums#e*(nM2%wJWETVhbq|fqF|4yf}I1c7V_XRl=^X9#LqWP|<^)yV+$l_k&zZ@q~Z*}>P)Kq9=Q5` znMRo^d5Z09m&+ZDk|#rpB^i!DgY6?&5X`mhUt9xjysPzG%a`T*5V5-eeF^>1@i^+zrY zK@u6iOjE4?@f4?^v(&Az}!fMfHrnQQjiFD+7-cJLvPqYKPL+ zW2@Fm`z*Z$Q5sIel@4-kBU1rZGrEH;7%2w?S7J`nBQsa&Zyoa*`M*MGIV{gaQ?Y1P zRW2KAmN@U~F{8S@dmfh<+Kr-POd0fQS0?Jd9j_Z#%dqNkau(?B*nakDm#ZIDXm$8D zH_Hj-RB>AGR2#iMVl3KR+5kT|x2nX6Z_~AINUv+LvPc>0&^5LRRj_8~x{vl2#XrzP zBFr=@$5x5@qN!eWi{HZ?|M{ak5OohiChZDeyq3N?#pjV&MX^Tgsh(qHDmnA>sVW7cIH%pH(efW!XGRE!H`-E>8sH9~A{s zJfacMHDWt3 zjWT;LV97CK^;RnX;lq334~KtTdD*%s(s=POZTdEw0_E5}W`&YrCiP5|!nT;~TqoEl9?tO)_{&x|WR1xQ4mk{xvqOdN;A?ze8Fk#pRyzTB^7r*Elj< zVds)2yV|)n`ITOLipKkd%=Y(|>bxq^j)Uua4L?&jvrIZ{XKH#ghB!O8y#? zyQbV|7`}%HM^COe*Qw56C2#r5;yCHTF+V)RtoE+jiN~=oBLuZuD3mtg?xtg%sy0Ao?6F;#q0C0gNU5zahBQ8FcBl`OWQwn%rxz2R~E$O zAOH9#@OYaNo3x=9EFM;cX6!0F&_TTvMh;Hdp?$z zyNGVyMSuV4b_;{?(M$SVLo|#q|7-GO)DZzDw61g&2^C7%59`K^v=TXcZzyuy%#(m9 z!gC^V%>psD$aIkjnP!zugY5gX*Q<3N7P7o#N9`CB7MLul_2wC*m)l^Po;G}b8kWT0 zC#!xgq$t;%kZ8XOZJbk=GWnI&Qf; z<4bQe?M!%lS1##zxjoR zEqz7j-~Bfd+;b_*A^AMZ_C`4j#OV1g>w&lEiHQq9ZKii)&R}r5wflJ|_glXa!jCvE zhi!*e0y(m0D{a*N_prtKM6vN(U(xzX2E?#^tZQuX!7E{_uuQ5I&kW0)MwRerV}Ia| zA#ya*529WqCe|)8#EVp5FMh-Rw_B9XLs-K3TRh$amEc_Ik2bL+|MgLt(xL+6$J(=jxq!qCf3sf4&|LkmUXP_3(pJ zB94sVO2_9{ZW((O9EypU%D2#Eb!kT=nCx)I>Mfiydda-NN>J zZ>V^Oe}2+Tjnm%jvyS7V84Qx`^%SC@j#J`^v;(7l?4KkDA*;VG9-$6$J>zc&j5W%i zHyVv}emEf}eO-okWsToOY57n~KSjF#;m>%-J9rmpC9k<|(tUs7uN}1|G-$1e6xtqMxuemn-jJjcq#P3T6C}FPtRpa1g305I(eJ1uw zRkPivPT^a%`ziTBX(`y6S|txNf3$RjF$TRUFN*anl=U<&2vlY%wT(>h-zu^Aq^J70 zZS4=~`Bkx$(=nIAxtdVo56>LtS>zK{MJe4XYuOd9pm0gI%Uxyo$tm(p{mu)$!W8gt zoQ!)*l5Iw}*)Ehlpu~WajPC`BH@tI1w}Tzi9=_`O5_X%x*@s}Llg7x+E{OH(rdqSi z?eDBi=LHNtMc;7Oxa1?07&5C^|J$d@w~syGI3~S>6-~4MHWbbQ!aato>m~=uxXQyz zc?q;KEU~+W#Q&LQBu8pHE{nf9}~q08)kM*2A^sYBv_$AKiOGcOT1x178{FgWW$g+?#{larPsNiP_p zZ-7V^q-(XfW-PB74;waXDKjNtR|@1LiTYvtw>${fS|zddCuB zr$ooWUCKB*<0s0&dfmtOUK%M4lZoLovf{DkuXLfsEnHJj{IHW?Fj)Do1pm2g#ceqb zaV{|Pzrav&yYFF+8XLxloO`Dqsh}`0phr|#nyC!;>`JA$)>u?`p6L9QXGXRWF0!7! zPvX_66PKyhe$yr-5Ous3^BG^}usr9A7ZduVcH$2hgU@mp;cBxy5*mL(!DpQMwHR3ZK9m1BBIoVlT*M=H8LJ3MDwQzOavCy|1djh|di{l|gVzN7TCY>|4-AH(|>bMjiT7*SVOb7nCVoeZC~b zwFQ22ELN0Sv?G2`wjZtVXvhA@ZMgdGF`xA9X>Q#l72&H&_p@C7`NY}H+{eDLtB7%B zC60l$f6Jh0HH9{<`iXzhZVK(2hg(0aRj&Cy`@LL_%KznpCz|x4KtYZNr?q)$ciGG3 z_S^{1uqo#fMZ>#HSBY>1g}h-Rl9f(F=fZHCg=p4SelFn=FCqyCpo4pn8nj_Uiyt(!~8c>E>q(3cStG7|66UGiH5pPiDec0ozgy% zSSWBr#H)1I=V@Cf%f|AUSg@&NJy3YUqd!d;RO!wkhoa;C(uO?lW~L!tuLUckKLJr%B)5utXdVd(6a6)O`-9`xI+>RIrknDb zD~s_HS{??Zv)p=M@MiVftzuFsg`DrF*j*uPA`dE^0~u~cL_T?-;$QwCuHGW!O=}JV z-NxQgO(#u^FwdC$!x8y%u}Qc1s{yweZ{87}E4GYfuxdElO*vnAyA)j8cffK575t&^ z!dIu|aNT{VR6*J=YE9rvj3sBn-oa-&;W6Xj_&SP=QJUf@iy`7^M@c?wt~$vD*?3S!|G7YMA^Hk*dKDeEe+Z-n$0z`a#ml4OloI9^hEo-*k|9 zEYH(bp%lJ$?pv($sm>{JbIOqM(-pLnvsVwsbIV;HPPA^IS2UvG2H@Oa+duW94lhZr zM%CZAr=Ry{0WEl%LDOmT@W+@-LrB9j=C=Zvn$GLgf6VRke!Uq$S5`YOQF~{&8OL6@ zsuJ9ob_=I=!@%Tw*k=nx1E#wj*MB_GdbFYZA|j|-e3M4AipXMOiawtu?wa}P5dTmC zi9kj~_-igcu?8#qt&a>bDRHR_4q`4|&a=E0<9UGv@`ps!qMA`BELGm2GKNi7D5aC3 zlN*$3FCv+x$=;}7CxsW#HJN-hWO`HVDc^A}ik<&=KB!tu0HwhaYybZ>+cbqxkT&)# zGpcuBK#?VnzGvW?g7kpjuXFV>>9TP{E2|ClQROhkO9wsXQ;xoQttH#rHN2-0@`Y=W zdIh`R4l1M_g&t;>dKHWEpd!;&59>(Odp6u=vMhHKRJJCsPNu4}47P1>3!#|7UQ_75ds>nvB%c;rj;2`u zXKUk3Sh_B6hR#SHx{Kw#g_R`e`rGp(vZr|*_vi{QssEd_7IoBDzkhi)aM{ax{+o3> zBDUVJ&(5S3Xw;g;gtscfP3P;@0AL?D`8<8toGo&01}~rza#=smdwXzj&`*d`S}yCLSx?u-u6}gHi@e3-p8>*uh1V!w`^D49>0MVNtA$L#O`UTzE!#E% zMiHzl=!LZ_-$F7-=xOHX=OKT$8aG){@Mc1fX62;!51CKTAMy8HnGo7!IeqR_^_s!B z#=|of*RCr|E%wY=o_`|NF4-XW_Qr1EZ!_JUo`U0H;gX)pn5Le~9Es4TDT}8lP1QtJ zvhAe9>l3|3U$u4EoX)*Q-*z3iPF=8|lu;y(tHzq8?k=@Uo}`JW#=m}fW`?KlPD!;< z7RP0$_1YFaMnYAlhkWXTSQsh%4h5*4fsIm`OGSN)%$HW)X_lHj8y9p0yE_&4C@^LZ zqLmX-EX(@3J78>Lxy&FD+SlGmdppjuwC==Qdo)}@VLF<&{(>;^w7$pj)tXG|lo84w zby=mqol@nAI?&0RV%J{N?yhW_5zd;ZjkZih*;A}4VAWWxI)!j`GmKPt@ZN-T8Xyrl zW84DYhDPGQ=t+ia;V#^hK*1cfu`cp>&GS?PKLIEd8WRf(LM?B-@ZNjz)IDzo*K6zQ z#c9*!gF((3V1Hb%*gc!v{`$6P7=B%c68chvMafSi#{9@+OicnA-SVBU3VG^9 zG2`VeY2>fOhYHr1ybq(T>4QoOKJ+QOr^hjKi6sGKMo_0zvSe4;RYfl7Kc_llXPcS}AGpW75)|60Cy z|6DsVtGD;wi>jw45`rj`?WSzwoTwXQG-+{h#!Dlw+`rfQJ$=O%*_p1PE5IXDnQP4U zT)H&++M`Ia^T%(RyZ%J>e+#aBccMy8k53k-QF5K~sBIcw==HwFr?zWuZl^-lG5xYh zS;KbsylG#iUeRJ^!5ECpwj~`7$o*t{hTilWD8_aQ0r8&K^TtjmI12pTU)8S6!`YbJ zLrz2@=R_B2>G(^PMs`x118-!9vjq$c`God!{`jg(mf1fH5y?s6318oU|_sgfI z8}JcmCoiCmPf+X#9n3F#%k=`kH+5fd0cw75%aM%E$chWo1NdT8}^ahjJ_5n{V*ppyF`0kE&r>e@sK;VLaFP| z?>OIVFOvP~y*LX-s?@7oQ7!1b-&U;MoFWR+!hXl5#~HFmQqOjas>#WfnFYz)j?PF& zB)wSHMZb4HD~D%TDR9C6`o>8}n$}Iqe?@(FaB`Z~0^_NjjTHiM@w;Bp$aN}nvkA3y zs*F}w$~Af$hv+}E4CtMt)^x^w>C4@U|a+Pgp8Pol7_6r{ZbJuyd<{eSEcw^#llA2STH zAJW<^9aZ4yB{qL7j*+C1WGI+zjDPQ#&t{4+#?ytjDCASmi}-d6CqbhA?uK*IgVrZU z-w7L=0VQs-1urZIKYw?C@E#>3a&LMa*2O0#&LgE&_v{ZL8;-9vSb-+j< z1ByHr7@_1x;KCoU$kz+TS5=@n1viIhK9|6Eku>?@)eWbvLplH0RzE(`Pk=vGdH7II zbur&Aqs>_LG5x!gSE20NSBtND{V_1V-(oz~j(10}46p3{9aX|W&_~yl{`H}*M0exK z9UuN0<@dpvLAcx^vLxB|gVuOmLf>Og)Nrr8zoAIDQh%h^^wQy7GDj0pKLz3UZ%3}( zx=WSQNJFc6%di?tx7wak9*;cm&Qwn0C$-QYEgy5^@iGm2LO#-J5;y-V^z5!K?}`FAjuSc+2==x zA%M9<%IEeAp0+|+-AlaJs#-F0iX8sTwp&}T2Ru8&g`GBD&zB6Fmt6jQE$^u*7jPah zB>S=DOR8_cFixm~H0gD$+j$q#%_8;Mmb)6klKfpKA^AaQTzM}wtkUg$sEAfGvaQjY z1jMu|p4Dtju`{1=&xf$l5E@)(trVn`8~Fupc~eI2Ow1 zmQv3KBq}ThxyLI^d}(j$m5u9fKC75HJuxYhW+#T&(+#c zN;1sK_1z(7Pnu3+Rl)W@o*3>}*tHWL24+5$DW3{L6@C}R$y8Z6%8&XDvv@SNR zcrsCJ(nb=b5ZQ0tAyzp>r!NshKhd@nRtqZWQVyt9r%LT(AlCNB!y$ANH27BJ{Z7pz zO!9@(YkC^orJj^Z^s&;zFD6>q49ujepUWLQ7=r$%1<+u2t6DoOcWuTJLk%zR9Sh)Y6srwZqOkC%;=Hgg&yz}3Y$?7 z6VLsYVO@Z{0n9h>?X!K|OD+UtUv@~Ss$XD6gJaZ?Lv|2f?MC(dZRD$QzrgyJ1-H7E zmKI;?;`a=VfF@#|I9Hu8@bYuXfbny(;-1AKZ8$6*j7YUV;145QnEJcQ-Fo4(Ow ztY`biRD7f0#JTiE%ny2rB}=0vfPQYdgW6UhQ|Y`hI2gMi4&jB z)mqni*PhC92t8`%_VOAVv9rcR>r3{iAZJ`O5dKtnX0Qd1hPij7L8r$90XGIM3< zXo>urbG~Q$j=P!4vk+N#Uu*aEcWrx$m3kHy$b+^JStQVpYBsMhWgzLKB84fHUY51_ zC~Bt*I0QG5k@p9f>d|Fyu061b>h)%Z%nHs3zp^he5~JlFE4UF^3>6qg*isW#ODy5r z1nzoYrC!h^N}Y*cnl@#m>Cdy`nzC9Ln4wZBp6Y#ImYpDytNZ#h1rz(ttB34wqTK^!wTE(ABmGKO3o@dWJ>JT=f!-rZZSF_d zC9Jo!Lz?11=!aio!mW=(R@q}qQnHNMFc_yL5S*8p+Ai`O`W9-3GX3PEW`@_;&}vCh zth%Q#r?gzaKAmUi6zqW1Emhs8|5(DSqG#)4Vx1-0=V7L&ar#!r>JB;Z?|I++uZ^bG zcgbm-f()2nFUzgx22Ss14zZ>%){$ojz;UpMlgF}1JL;)x zr0ZUP%R<)|PT8nlpb?RKTU&{ZJwIQl)U-w)OXKb4t2s7CMo?ciRmS`!#(xdcLO4kY zyV3NWO3+AM)4*(1(0M0r!RO%||17SLrh-}=gq$f6?z#(T;ZVj;qj!g3$$ z^MB$TF2Q$A>-+WIV_!YfHe+mGiP0T>W4vzgffXM5rSQ1QxY{Mzupg>VS)5VopyH zC+?3bVPRaW3c?5QEc^(cv*mP*i~>Q^9E=JmG37gx#fU{qQGlttgZb)p+u?tURL>t% zS{|N*~N}|Ue!`x4b!!TcXxm804w|X0DA`-3Gg30ewN9W`vb%qg%c(x zjbQoHupeQCeD$r{YCY~LLo^ySz*ma*EGFt?NY*o!?`fUS2=LLqwab(%=}%E8daKxj zrWXY$i)RkqH*c+xi3Yd$yI>EqHXJGl+q`~%YU#%F^tR-6L4UBGIV&FWAxDwa0h+G` zX&A0;e>N&kHpxt2-aMt8X^}O^P)XeeoTxB53oPw6x^UiU>Wz6W^x!Jgq8eeZBg3zS zjx%}lM-P=?uoN!jIS*@%2{nEx|3X_DN48Kxc0P53Y3uxXxz42dXM-892;0#~aMSVf zRBtv}iJV>6hux*ThGx~$NoJ0|lOna%sh31$)_BnDpxLgnCU5V2sYii%eC)exA^(7S!2Rb;lFMRw{jD3^yq6s9 zlG*G+?Q@l}ZFhs^)xmYBSgY`#{CJ$6)ATu0)`jZh;5ET=rGR;s-U^(!2nzlCH^pI8 zVfHjqY@eW)UI?mB=fO6sMBCAAg)rvz;i&wKtoAoi!OR!$+Sy?znQvJc`@Y{Mk{1*f ziGPYz^o8R3dxB{=} zeAnt*1odsw^y11XKIymeT$Z!E%dCk|ik9YX{3viHFX6)YXj>J# zuXWmo6=LZC;l^P(Cx3!x34x^PZm;zA4?N$GH}R?PuX9tZmFhvwS749E}>9}vF`07srCF!BQ# z^SwDR<^y9vAP9@+yYb`uW1n@8PjojPbaS}+WXXHKFm^WE*x_h6=>mAWyjRsxBtrMQ z!x;I&SND$xE9FLHQ|anh*w~i}+9UQ@$FWmmA7onyGB2=M@J5>Tz$9XF!TxLYh%M;9 zV73s{+bAd~n!t!dHBA`zaa-IqX#IRGRjdH>`&LbV;k51-=k##kDm@O(T_5+g$Gjc} zy-vVFm8{&pr|7=T`u3+ z>ht5O>%RJG$&Fm;%+1Xp->CNEjP_|wQhWHf_Q=)ex&tdE3pFhM94WbW! z*SUcmP>Q-A*=Lbu$dLKVF@-_U7xW&xlGI@eprit{lsc+do}F1MD_WkQAC?6ql7z!G z2(Zu)S7~oK%05t^+x_tS!?Q1Tn>UzjSYA)s`W+)hu}~}O5eFvSKwv#`tLxzK6-m*Y zP9j$QBISF*7oDL(XuJ*9|q^h-*{W;@)FEFvjYR3 zEl99v4YsIeAbz|Zdw!68+Rb`G>}B8puC~_SrqXr}56RO;D%`ItT93}an8u^$+9?N+ z_|ju*I-m&(9innh2P&xeH$%f3Tz?y(EE!oUwoR0{6-(3dEG@--iRH zF-{_^-Tfduk)!dy7y?y*-9hN`2P!Wf83pBR<+>wDx$|!3H_+-)ziE`s;IAY!FU1OdEQ)+m>UJ2SluF~qej&qtw|B2_8^xQER=^i6|mu4-f3wkF=(5u0478I_hb77DG8w!E;blc_lhr}I#NnV#Hk*jzw{GwwEyBx}9(jFcPEne*lHm*H zzXvVmJj$%n=8w!LI-*!#&(P)P&B!e&kAG=INo^2cPCUF)6$!3bA1g~4mlsakoJ_Wx z>sBlAbJL)Imf6kIRcE1fltLtF8O*husFL1fgR^5T;I{Fn<`%~GM-7jRtZ4Jena~J^ z_y~gKEebNm0u=1~52r-Wj4vJ^A3;-Nog*@~k2prG>fhiCSbZQZfYZ$Dwjg@X(=ZLk z8O4jsOSGs#*X!2Rk;>=0%1U?Z6sxrZ;Qsu_`f1DhUos5&2k^w|-PgM2a%O~-mNayB zUeb&(hZ?GCu2yi*aX8@)sywc1Nesbh$1w^ni+o{LtNT@Byw+$rK1i-U&5k&R^Vw7W zNA@TU>^ruB;Hdhn8`?Nr*;*AlOT`3!wg`u5-L3ekhnu7Ow?Jpl)q#CUx>s^i(W$6k zy87Aa2K8Lh2#;K#qNO~Fv(2jUZeVRqDDYU?@YCh%>uZK4=Tbd;Jhs|vgJ|8PdDCx% zyWhT19Wp7b-qPXh`Kq4ZNSc0~2@jwxmFg>|3Ny)3%vCKPFN)`q@cmMGdRERm)^|KA zN*({IIWks9EQ~B|dS8<2_92Js#Gzk(9588Cx@Tw||jMS0s|bC6k|5=US@vH?{neKdIS4CQV~9Wr=6X z47#Y3)%W(iDu3^g&^*dzBs4Z7s;Ex;34R2^%v4>{Tp0%We&kVBH(Qkm`;fdOxJQA* zAVRzwGjj4@9tA_JOTEY_r2-d)d!C+&;_HNS?}Gf0n~tEuNcnr}5=uzOH}x_DEA`V6 zI9Stkxc1e4o2X1jX@zT2Q(hG)cF$2#TUxPvoc>At&g>cX9R;`G9<&-I@zADyrtPx1 zN;pbM7=GL?1!ryEZ$VgJv;1Jb!hu}XU-s92f1JsUah6tcv=sNp8HR803=KaI&XwsZ z4yzbm5)zkx49b-+w&o&rWl196k-*epF~eWTn^l$=Y9wN2#H$FXmIx6LiFj06Ub_#$ zo9G{P!feyc4N+A*CQ&Nq$LZQ>>J$%ArIn{`{;3ptK)AAlVqeoBPEy&Bt4Uq!rLb&I zG|WNKqjY@wx>kxePN^4d$en5E>!%e{gDJXWzc8zd>+3kN_drdu<*RFB6TNzyvHG`E z`|)G5MkE+ue_`oSM)Y(N^Z@qKEl?VH2}uedic$A1=B&>WLlDjA&JN}Cx!04d=YFGS z7#NRE0M?X`ZEJ5UK{fQ|MdulHXU&^e#QdsGC7B`N40eWajBWGelaL->l&>zHOT zs+D6Em^zJI*;U{!)diRgHpo+v+apnlXfAZV3g8*JT#=G*7KrJNEK__@EEHSim0@fP zRVwDfzl`;6NBpmOGjoHuLDL)UuQN)~5qKiUTwKNiBZ2)tc9K7+t8!%+tryV#6hipE zctVxZ^Ws%M)2VJfN`jt`4)33oou7%qRn{uioQ_Cnq3cM_M$(u+bl!ACbHzZTPC)rj z+$zNy7#NVHH5MW12e@ZeORLATRnC-P;_-@TEc`rcMt?n>d=?uP-(UHcMRy0*j! z6*f9n=NOel`5AWD5c+ZD4$eT4mKwIV7plQRasLGa1Ixxjiv}gur^}ITV3Auh1Deqq zKGh>;&s#OPY?ey*$_U*(0+Sf6n|4F`Ku|)L$YZPU(Z!=kv2@yS+&=Q_N8#rkBiZoV zZ)^UVjI-=nBoxzSo|k4Z^W!42;Q?z%W(}Vg!vdcY-*~l6(VehTXS!T)GBmi>erVk} z&>K()65tgz$>pk`tqt5nsxWjzNAj5LkMOo@D+N0dLX-#)1#NN&a&r(+^vUEwh2EX3v52ckD5?=5CAe%`8IFnmLebrv3Oc~y6-Ln=Q1 zRzE=?GCN}BUS+I{=Tn7SqAJx??Wh~kIjdP8dy&&$Wo)>)9tLEllyD&6&|ts`?3UCz zL)SV_ojaL`@{9-g_7@OWTTrtk_k5i5$^fG-F(BzJ)2!R?ZR|Pez?P;^ZiWNMrs8(|?Qk0AtFQ z1{s6h0^gwlrLGrviOut@=QjC&ty^r0f9fe+Rjhu!Q(M-Fe?itnIyaC{1^C_#q=RS; zv|N=>%B?*l#UIwsZ(Tra`x6Y&-tNkJNt7$CL!KH0*f)=!;Qo2OiF*D4q9<>snxfXD zmN28*kk#XD+2;#cP5{$^xLnVeB>;D>D#u-)X<#FA8`gP))bp1ClykM8Hnq2a=-aK?7W80^v&#al?|41VHTk-OS8$pgu9fcNa21^sqv9AA5s zn1N!WutYM)Bc*)F+Irl2A!;+agc2`Q$dGMW%N@Lz(H3%yQ8)P|^6kdgp!|rG6q3oW z_2zm0cH|3B^6)a`h`UvKNh4fu_->ddsT8AcrgNj@N*gh06Qr0v|71jHS#gk*m6ccA{ad*f!;sqGkHf z>EI6ge&`QpwgjQT+!dTO+@S9t+ho6mhC68J(lIbk-3V6Dn7vLDp$l3^ud#Z&9Y6L$ zhH7}|{+O&R+)&+OFsoBj%ZQmh-~?~t8Oc%O zu|^%@%@kCVbB@$3V&x&yv&G+>ph{gKOoIio7W_e1B~PONx)u}Z)ECf+Te!Wp_z#|) zv3ED_)%MR{qUP<1|7@R3%qR~--RYqXI31iz2^@up>@L+vRtrDE(XZJ5sBJl!;qJnh zAHKSWwpeOYuO=bCezJzwepZ^v-0wy}9&h%YVXAJS>sYjv|u)=w&0dSg^js0yr@tCK%+5TFEc zy6jZxh57p)aN5jIZT+=L_JBtzZt(8T6vTEeKaL5bSFMKX%h7E(<}I4fi@$;Kydsic z8aTP1_xM9vKVq)PW_=nuDk|vdbkHews;g@i2u(s-5uQ_R;~$ezBJ-n<%lMv+kB})hqcsX%Ri;n76f#XwYj^MkfM}HQc#w{^(v&`aMd7Q# zH#_%G-MQq@yVn(qZs72=pOj4^npouAJ+G{sE%jq!-JW2e_Z7WL!${JbK5i|Ws2nVM z&6Cxv+We`JoU#4H%`8p1Scwn{)902G-r|lB0Bx~q{{usR_0cxID|s&o=77f~W}DXu zI@n^R(+s9$_hq`+Z?d%xed92g3fn_5zx6@-tML8Z0N6CPQbw$>n}wSDBKg(+W?Z`6 z!}H&RM~|lX_8E&>@)BA*Z>n6Q@Sd+%-t`m8Re~1gt6i2D6f|caoqM)4LD3o8Wp;*< zftX7PJ2)!xK)$YQGPCg47eY7-N9{?00whjHijQ}u*70}qGO}qf7JN1aGjKc?{NWO- zY-1i4qYOLCHH&=EsNJ&4lRbL9tYVCmOusiZ@b!Z4e)H#I1dNK>Qk3=ovQP4{C}Go%Qg}T?517HH_c_4lK(cga}Cjd z;jctKx`&4cMAQ}i-$r}xH?|EHm8ih~HeS3D`;6@wtRBz_d;ta^z@}(Ws|vyd(CP!# zwY^I&kmQ19BLn*!)@zgifsImzI3I7QcktikXc(B8dx1c#TPIqG6sik!1Su0FfcyY# z{GiaU!g)MC9-WhWdJgF!;zjUMTkDW-ZDY0*Qjr%M_}(@4_!6i=i zJrog}NnA)atL3#2f>{6yg_*W`0CGpLq>+Zi-X;%1Qt&rU*0YUfv}jo@ zK!&?*gh><|cFy5L*aPZKVsr_8pYp;|-Y5Pow`R>MkXL?LXxLjYQ}WlDtFaiNB%x>W zDFNjGJ^8IoNK>IaBG#4>w?(u>!#)^b(quM&k73$qfxi0{8aKpkkq6AusL2I%Af>#| z|L*o$OMWyT;o^d7R)SYLyCBgKk8M*=ro0k0FILycxIo#mtEY#j!SGwd`g<(wkim6A z^}5C}MfT62<(0XzB11N0;A@h#2xLC;L&94|GxO3ESct;kW-3%d&pV!cWX!p*jE&S2J8kqh*`&H$8hCrn9v20mx10 zFXevvuCjWD;-a71)1f(wkz=Q15gbs?H{kvy?1vv_87jc~RGl^Up79&};!;~8DniLE zi?rZncA_j=aIr^V{Dy=ogU0o}9ai4{%3PH=jmx0p#}pIu1;@JEwH}^sv4vdjL>am@ zq>{OxdFVoV9+@qhlj0A7dteCXJ&ZXr<^Qw*wH(_a)pm5!pYkH()aXKxl@-yPsl+eE zwlq)YBPU2$2h3Q}L+Y4jvo&Xl4wc=-$gvO-hBNO~*fP2-@Eleg@+_jR#VYr#snU8Z ziqvP-8-zKt^8ez^?TYm(1of@)$SBN&m^~kz45%fA{@c>OZ)1n;NgQ9WGZ$Ul@x$64YY_>i#*u1v}?|_rNy6Sn10$4Z5KC zSWr_Ow_qDGV4@C_08y-7wb*-f60ETDc!Gtd7&QVW!yV1LrE#WGa94n;rw_kQ{sFks zL0MReqPL6Rtw-f!0thcJE{nZXo_X|Aw`y~|$o>C3-*xhZAQWM+iz9vW%9|Hr?XGw} z-Mg~TnUS#6jTw)=dt8x-nL9W%AInTc^QDfmG#>O+Y-(j&9e#_g?aQ?rn^*C>%SW)p z@@87#tY3>IkEVRC%oXxsQQrI19oH!Q^03a5>XdHYvV7!gd&^? zHMdnYn$BKwH+x2X{9}>ADiT5QZcr(pC;(OJ=}aV2%e^f3{jaf6^x!LyTq<|&wQqRr z>4laV>ZrU`EL1e!uZHNmzpU*&AZK5C=A$4q=?M|zRrLF)(9p^gAl_Y>=mfvi>Mn%wu(VN`2^f;Spr>9*!EkGGBvTvwfjN^|;#7>LUgFT`%ngV1!U`@c=9~1=bxZ<@DtfmcB zNTfMPlGNoSu9;dJJfQtFoR45!KDAboXJ$7)py8q(ANbXG>Fv_IJg#+-Hb0 zU|Ln#ixVyM4C`r%v8=!OwCH^B|C2cTpkYM3=?O@8mpD}ahgv9Gnk8Qfn9Yrs8 zcKy-eYi%sm*ZVs!rRznZ`CnDwlEv9b8ZE|Kb&0WK9q zLVpQpDB67Q=jR_G5%>9uNek3910q)%OGSTV7(GRB~{Ds%O3)}04&*;v3lRX!G$R32=88# zQzxV5m=lmrAo!SkrJ~O7JHE!SYloUVyJv*{%=N)@^1}(dU`2?2E6S4&cr6rvJXp;q zxRwjQ_*l87<&F%0(iJXZ68taw#Qt4G2xvC9)(%BjTW*CF(+X_A^9g$YB1|M- ztHp@b?W-3z7*aWrEN(j{MF{2iL+kqfY>F523idWH`^g{8PnkovgKz>*%bH8bPbt+j z+=LQ9n%N(3Rb9taq50&rPxJzsWR4V{1*Y4nook&3b$}?;<>3;3$!TV`gS~l)2h(b9 z#M1uySR&lf^!$72YJU8U-(RPDr$283f#?jM7{|(WVDn7n@Pedi`pwamWn;6mhO_yq zSQ3{QF?#Vw!vIuRffX*6M2n-cFsR-3M%bi*`oa;x6&%&bcd}`fte&%>j7jY}>C0Ib zKK$OG2_`k=Km;=Of0?^nQBsg!H=5UIn;} zm}?0(YivP!d0-S?lCIew=y|X^PF`BIUn&95%q#m^Z!k^66DRlo(NdHSgBTBC;n$DN zZ%qFyjqntLaW``?5PCj|^d4OoT)sc2<{4GrM1;n~&OQhRpnY|59`-7q zJ_7$w&aB&C#!5f=R&DWvw2}s*{y)SLrNqo>Y)mq%-{bw?tU&rexp$c>I!7dMz19Pz zPT<#RQzRHhhL3`=i%Rt5N}M%jPRsD`_%el&dx8jE_vj2C$soNZPugeO%u{&>s zJwc7g26*1u0l8Sz=`a7`Plk*cbx zgO(8$w=q-wQPk5eLo2&i{eri%BuSB;VkcpIw<;xNz3_VFc%s<$)ygju$Km%M_Gygl zfZ7%|Wx*D?^W$ii6b<_EzVd}rUi|doN7^K9nOrazhxzwG$!{%%;%VMJ2yO4y71dMm zofrZ|D6W*-46GdeuXT3+MLx0c1D=^#GwxTg0sXs?OqMiLd0#1Y=9HMvf!Ck$wkhn4 zr%621*F9l(x(KG$R2`p^$ez#GgFy{!X^4CZ}|r z6mQ4NGcj|19#7!WH8S)4ra%cArsB;ic^XQMZ>1r#aV5TELw%%=Fff_IH~-DXwHQBK zP(efajfNpY#TgGMBhl)nvi|HR?U%Rhr||#t>xLscda)s-UpT#oraY1@iJzG-$f4en zjD75&moIlJNU67ney@&(^$Y(e#*ucur{WI-d&N}l6;8iKrO}wCPpR|YcQOP_F;)b4 z4~0w-)xaJ$@ZXWgIB~vG#jC0Gv zr-cGshI`L;*bZZ3XJaE{C+EzJTOKIU#7U>z4y#2cF)6lsLf=p2V#U8zPaNy3E-gJe zBd>OrRLngHmR_AXev^s}T=cYTfx;)S+`z`9n$wgBsjNl(wN)4Y=h$Mvw3^a2IKXe( zDRAf*uPNw-1M94A!(u#>OACG*#;NX@{E~{YWP5`OF?j~9TgXtIISIOlfFv<$*P#=} zNxtxJOz6g3+$<6Fk2^=CN6z~>bOQne7cXbr_?7K7bCyk+u=l^_zJjhhSk9={Ze*L* zV=A>Q%de)>@3bmg^&2Tzfsy*sdFG}KJc$KJMx>{@{(Jn9jQrbm2b=D8)C~ISk-$DV z6XNy_EC~1D+_lNmWj;(5mVOyT!4n+Vh0}L%_g*MNOJHBHao*A13k!Th(x}&_caElS z?(Adr-A$$BcfG&Ti$yHY?>*$yLR2xzk!!mw zlyiTFB!8cYix}q!l_>AWjQBdNBXX9h9We^WP>Ue(afZns+LOjd%VN_Ev!})-eqw!^ zN#%g^Yb0SdhTG^zJmGO(9$IppkpY_N?#jOKM(Xfl<#w#CCLNW27tM@0R)5odrKG~h z+5~w9JJL{Weu)PG(!eO(DiTWQWk-Y?k8tE``RtHjWwmMoXQjI*RJ&~q66`n;9v++| zjy}2mEq2#rO-^y<@wXg%*_@IQsMw>s`FaoUGwez55EZzL^wcDR`^XhB3O}0W$0tWi zWo3(uF^dnK{G^h2hjilsNIr~u8~mKrF-j8F7i-UP8FQpQkiM2<{UZGiK{%Pk zFx9SNqw|AIvCIN7T0qsFZaaQJW~4zIJxJ{;wRUx+whq zWOV^y;?~=zV$rzz_CvI^L}CaIqPYiHo0Nwl2u6v6xV$pu=S}gLkxEOs@#w7!eLJTL z@(l*A#=qo-|6JdHx8QE>H;ez_9ZYsk&2so#qO=oLLC8{{Toowg}`PnMX85h2f7t){#U+7Wrzf1kLBxNY~mBZM-7+^s}R z7w4r+V0&bYou zmmlU|TVQmGT`bItM|jU{gi`l`1oo1ZsKE0$3h)bazFfjY0-Hq0qdSS9*C&7}9IE)X z{SEL_0v_4G#~*;s#(;g~81Q@yA2N_=w<+w5C*0%6ka_j$Ro#}Ke?w+{=TwXdyyv}4 zrD0WFiDpiuEc_1>1Dn=F80k6Lf;G?gaGa~eTe5xM2k|ZZIz}(Wrf;cX3>u97xuWr@2jusTP%KYfDlT9HI@1r<@0YV_K1jxCJj0s!Z+Xz11BLsNCAfBeR_;q zmjEe@jEq7MUWj+{dA(~70nz0=ek56n0+^nb&7YmaCmH~bGhN$>z){OS-4h_?+4Z4` z+5od91$A{v7QD^Y)kiwu=|F`+QN*l;!U`4$qY)+yn12sHKS@u|4n~-LR4~L24Cr0= ziVGoTVJUzz0B9kG08s)$U|3MbT2PeD%*2!oXT1u>|w zJkn%O;(-tI6-j=d1=~4j;qc^t0IuT@;9iWFzYat2kU@`8?WrHp!wV|l{u2NaR#cQA zG=b=Zgn*F()fFcMpd0WTGU$8B@b7WMGc-0<*s5N6XmYao0UzZYynH5*ENHu*r>z0s@Me&1%(-z(T{6fF=chvg9Z>~$EB6o8Rn@15~wLF=Z2kD##@hh;bcrl z@Dy>=yJZw1qGT#?3xVOaHz&esrQmW^e$ngm@~70}24C(3CGgfFfZ!wLC3^na{6ut| z5XO#)i|Yk)Y~N)oK#qwAc(T+f8SdAu%QEKX)O@!?vL>dc-C#5VFjT=Q>=E?DYg{^f zdiXg%_nAi;Mv^oHUc(d-y$^=&q#@hmN1%n$gJsEpd{t?P3$o*Cw_8FT;V(iiR0w2}FlN&ZO1?{zN`fpacQ$X)SrJCd??k5A@%9OOTzO(#t=o?o;Z zxletQ6N6+#xmPmvYFMC`-1hf^Mf4xTitjAzTZbA_6YQZ_4weOZD(G}y!9CpEw>7ai zcC;ELRkTH3Igx5!exGOvYr4o;KvPEgoc8fOeJ;uG1`7d?5|j4AcAq9H#vhWT{@)4U zIaT+XTTdE;!J%imVRN5d)!g)CVV^F> zWpOXWyrg?cNtO~_anY3qU%>y)!IAKwsIZtq+jNVt5Jp`KN~yKv_U)lXHpNn4Lq;Q; znIAMli`qUTl5_?IoGO10~?!?3)3fA1ynU$GIYh?vA74*N?g*6J{{t>+16 zuev6_R;KN4m{#N(xy4kBrd=P+)}KdieLDb<5o0P-^XV&dpJ21EJJ-M}4ywF7G`{6>L}gTK`?_nP zhAQ?fk}BRR9Q;|s!b;U5L~maVAu4_zP%gcTi8dJ|U?pNO9I!Z~fJNOangeSoH1Mnb zz|Eajtv_hSj*ElO!u!Fx7n>-ozXv!fzVM#gHw0$&0JuwaNebaRpF=cwwWC}}m2<;0 z%Gx8qEEz(kUszax*m@zqV+#kmMabwV5Qk=C+@vGOU%90H*Q7eG#ENtMB`#qC4ha2=Hx_LVCBPH|H9CJ5CD_w2op7orc@+&j0#^=#T!Hpnh#Dkk%>ysB&;g) z?Hd(}?QoIE-0&Dp`tp;B49BV5B7wt<{F+4a0scqshoZqlB#~rZ`+~`V2TvkP z%Wr7cDlDTLd!|2ixI3%7V`G^%@1XngLQI*b`Cn5&=~F1}!wtzJ6qsm9Jn|9|IycJb zaN|er`0oHeaE`TPXbV&5CG;V4dSA<;yEV+Z6ttJQGi+Fh^2aDT31+yzvfT%iWI+5O ztr<_Jz3cs&a`+X4L;B)TbgT@qxqoWVno9bsk;~UN9yFRq1yxdSS)HfbWc?bGF9IQ{0GDr4`W~n_J~<0gm+2RZSVHV|ex#8~`&NRGH2Xznrj;E_&uz9%veB?u{;1oCZ!Sf6cLAEMHDj7B zmh#R~{#*VTA;+s=RNrjE0N|)cW%;Mb3Jq?SZ zm$GiSL!%d$8bEkC^9JfgwVXfydl8nLx#cinJ=k1EgFs6$aT>ai0^vv*Qh#EsD2(B% z*TfZ%C3ewZydA=SHX0Ah*`j7b&Pt7Gfvv7K5o0M8gL%D4lH=p!sN z6tvF^r&g{TE)|5B2U)(@C!fHp5t2As)1L-&^Zw&mrK^#0+k#?ni(*`U_4yl&m`t10 zm&}5mQ01BoKWyJHXsf9|2mZQxvivD46liDgL*Z4qCbB%-=QR$~2BCc8A4w~TKRUU% zNfZl^O_^s@2YB)r7Bz#VzFQ+w} zo6Z$$uiP6;V8~yJd!8j?e@uQ9S#EwI6v!kdmN!>G&^JK5Er{SqoN!kzj|&u!cOUxZYSIO{_fAx^r_xXNrK`RF?VDc|Y8=zG1^rtkJk8e@R?6&E3gl%81hX zrzdg4=QDnaC7mneA-G&{iYw?YbHlr{hk(YcA55iiY^U45fI!Jt?^muNCb*CvGy&=f z-{1>wIJh7R0R(XV5n<7p^;dznGDKPr;>e2W!H3@(9`CmWeJ-Mywc+ql;2{(%)h3(l zzg=8H4EQQp-VF_G00%A%2JPuPZb%`{5NwEmg##geKb!>dODwbJ?b zusNw(un2^kRrUwOlK?6O^x7L>O$Kp61dgQm5HE+@nM%)oNC1axoSwZf+|~6bPN!Oh z1I!T0cjm`G99ny=1E+kJ0Re3W;5#}%UD=i+#lU!Dr_WKv3k9rsd-baSjW~i4HU@_s zIYT!E1&nv>RvVz&)K9V>Ad8L+7bB0yZuwv6I)+Q)50dFnkiN;+UP4&oY?h0CV0M`s zfOA#B(4=~U#l(TGj?Rf{OnL?;N)QD14RE9+0tgWD3gBr2{D)BP7l?~9IGn)Y%{5@C zEQ-+0IEdftkB9;J+^suqDFAD4b2zCmXCBx>Kz}Ex(v1e*+x;2dpq#FpV)eJ39dWV4>BS9*|XkrLuSoot(Bd zd;l5Xd%l&G;W-sLJ3G4p)T&iA>k|_m;>yqZLMjY=Bo>L5$hM z;iMNNAz!c9Z(Iye5Or<%@x2~S{|%@EXXcHh&IfY3Id2X-Y3bLHa}K^YEYTrqO#p zO%9C5U*p~&nDTv=j~Pl9YRyBy;i=Aqk>zwzd#s`G_}M2-&>r9Y7TH@TA_FcNIE?6t%;E&Z3osH8dlkr9s^Pks0D)V_CsJHIxbtSA z5iEB7AqJO86F?+2158Z{m*Yp^hyEAXU2GK>W=dFkopi%P*fq_-9~=U<2e^&Rvf9x# z;I#f1P&0Iadv6=a_0j>~psukI2C;A+SZV+Ibp5**IO;;S2LQ~~up1(W4DAb%B6=`^ z7zyH;32{N$7>Wa=Ji$5X%3C4N4`JPVSfcyGI)Tb*PkmUgzUvwaD z0r#*A$Vxd;K~o*z=idSBGB06N5D;ulEiR`1oP(e*_GU`KMFY7yXJ?g^Dl~wx+PyY0 z8vo(VdQ@RLaqCoCzBev@)tKH6lSd;3L$2Gucyep19Ph351qS*fehwW_zTL+*8C zC1E_JHwFV+@My4DnRFo4S39&1#*^$z#-o|!pX zPhKlF`_ZzX6j==(0xZI98wgb9z_JbWo{qY81c$+xvF`uV0vukjIO|pCU+N;}E4^`L ztDkhE)#6$nk;oX#CF$|uCH1Utn_QL}SyE5n4M0tXCQxBPd*kMIx6eacEF_QWfI4+S zrEE?{5;1Qui(PtHnhPNtLl_YIOgtNg3-@>DBY z)NUD2@~mS&t$emnssOm8vJSR93LIfsWq7noB)4yv0#v5fB_FINg~rTF3T;d@Ot)g> zqS-`0nB;`rai{Ip68+awc1#Q~X1N}fS^3%{?C_@yw z-GKvs5rm$zf$c7=*Lsz;aeC$`v-A9f?_&dxl%SoYkdJ!bC30!tJ?dM#<(j>SMi)KT5=ec(N@hl)Htx}@Mn!-HcB5I^4my5*JvqW* zO>3dl5SZ5O-CSp;8XXRpApv{`P#N+udIRIv77y*tl?g#46lda4e7pZL16sT9WbLSTg8Hmn;Al#KxI{(b=R z8V1yKZ-3sikPn$Zz)ma(kaB=r!@|mX3i{m9Sy^M?cvRZIu|jz0knr=z$cW+YWIo^? zr2)c09N-A*u%!)+j&1?rKCtM|{9eU?R+kU>GvtzqHa&=K6*7}4P^7SJ*;lwy1W-GPFfT20({Xs313g9n-INiLWIS{O8K7e8e zz(mN9U2&A>T#6X&vMM{<2XG%?Y_1lJsgF6^+uI=!RNxhlFBUF%49pk6@790KjFZWK z5Bk*`Ah?r!q@$-V1n&pZUIaqvxQq;GuxA2mBu5GLld4`6ec)~mA@AWkPJgMZueSwt zEQle6E%>ZHx`qy}^MH*Q0%tmQ-{$_W5-Fvw{w|8|iG%NMB1+!$H7{Yx@vHmn($X+s zWe-_qmnS)*277@``WW!U=VPAu0n%zzUR9GEC?wWc^lw^s+S`-_*I~A z3CJw-V|Q7|@=z)W32=}Jn+$W;jLUrPcj?DMf;X|fjwYWxBZfr^Qm1@Zn%EtmA=q7| zYmhGt{A%^67bElQ>_Fi?N(2K9cFOwbFYzbo^@E_TH3aS6v~oi5qYao#hQFSmMs zQF|#yDBDb1qf$9+l?J4H26gXQzIVbF@RwqpYD|qE3r;(r7otPnd8cibcUWkhPQj<57 z<y;IB&N!hra8_zy1duW=~$ogUXAq(&M5em|`MP3Wq*2?e<;_WlGf9 zatNKP&nfL;xbBRA-wW1(KoGeI??wS&Clh}XxPbNON$ zLs797&C(Gh1GklFgl5{P3`}z@KCnqVEo(?x@d(1&lc=cj#;!?Rc4YKf*PE0MHc&7{>s*#}|m2J)@&CscC7DP!Z%LU^xS;;hQe7T*^x>#Om++`a(l!CqQPP z0&w9JafqO7#@=~55`X?m2gKlI8qKi)XHimG>I&8xAY5*@JI>;;B?Z>sG?1lCl)&-p zo|f&!glJ*9vUqB0D#RfKtVeZq?|IDz*H6QbU3VdnR}GKL8LDkXE|4vPOh;kjH3n(5 z#Tgi!$}cDgY-s9&uD)=5({+*O?$cV3Ws6jxRj)-s=-R@TO!Fw% zJ>o5`+fL!YII}DyF2uYq42fsDH2eZ-x5#?kVL--6x^+;KhWkwmGX@frwTkT<$f@Xk z8ACjM;!h&ET>aA1@#$K2Nc-79rnA|&V6jy?uj1Sco6Xvlw$X3Sx@9$By zF`9p5c-Xt!2R!*^?YEY6gP9%Uh_Y{IdkIOFoYUsV;s2=%J{C~rmDj}zZq?}b9R80E z>qvQIQ40x|pHuy=O~prsI-@@2qwHL>f3Bh;Zf(tuRDyp_xx4h&%*MuKy)XGa{r$@Y z$OfT?x+fucJT0o93WWdul9(fCRDf=$o7mVGim%{*b#ZwtoT+T5?kv&!KYvFn)AWJ@=@lwyzVm$LE4~DO`H%npYd`T*(AgAf&dIE_+P!|<>srVA676p2pz!qst&7?mb^CS~Se7o2X#9;5#w z6gf^UWt+o%M*L!0Nn)XIiqr5rKA;y#9B)wJOMM$_PL@X9YIKcGbr9#%e7wYQfv7Y)@;MT8zHpQ{i3uvoZgKLU7-=lS1X)X$&)- zWjbQD{LM}@p+)N#mMFrhIt@>bvz({SW@3w?`>2KMZ-dnEWI!FZx?**qUG)bVGKv3t;3m(Tl&?7ovsWD46F3p z4*4%{^rs6=&mB0r+}?NA8x0nkIoIm${?SNvu60nIO~gly_2zv8r`dXVmw~lDZBwiO z^?{k2+=ZfDt+duvnUL+tQM_5NIHtSSj*JMC zXnB74E&F%Ifz9nR^Ensf6Q64msa_TJDOul-0FXzjp9*5}U&yK0_M|wnWg&GL8{I>W61fr;f zWY(nAm(8X^$KobN=Y9F(%HuR7#RELtgM-ErV`P-EuNCtTYsO&u^%gx}!8oti3YH$@ zl3{R4utsfl6tnZoZwjgHe2IVa2FH^fPN{LTCOZ@QIrY$(pbuRk9Tc58*FU1D+F)l@ ztk17nGn$Sc6Z&h+%U5E9DC`_Ui)MA)UGQJ~*}Y!S&cqXm>v4$4|39n{EjxOK>+7ysXETbfHi$ z{POM@hbZghQ{_R?CnT6@iXOoh2^g;RPqv)aAFRd8h)1};P1(kE8Y9FpKYxU8`$b%# zXc$C^3^yj^8%beCDooiEv0>eU(M_>mmnI#M`sRzdp9m`p<5S(ob zHJOVsE7cWtt4auzLWYq6k$;}Bi6OlSNSL8!t?ip_zG+4WsOM|lay*3HnZssY@ak;P z2a)3xJpTw;y!DJuT5u?|fg`vTnROsL2RTe_S}u7lCd!~W{yox<3xGa8fQP@gMv)>w zH)!Z~1#B|@u3jiH+wxm%c0G`ky!SW%7VuxMIdXafXOx0;&>}ZfJr38eT758_z=3TC zYEhME&qU#9>t@c(si=5%(lA86|(yVwTUSy;XxzeeI(fh8i#q2 z%ERBI%3anqpP)lFf^Rwaa@&DyH#2hYD>(mm;{I9uh7?j-^MBlgg|Za5tJTQI&P_`muQOdQ6gzy z%UvQ@oDbAXQ1rmxivX=9TGev5%Vua`!a~a51DF4qDA=EG_;xtn9yU)ZImoO;E= zID7IPd$Q+6)}bp-XWz(8@tXn*Zg(=J87N%{jpY-#BE&^sYee~WX2ql?N?ehuDUdS! zd^8?q^?V{LD9w$vWF(X(lc(`5Z5zh*j%&_M7kH^cxjmx6C3tyCti!l}DW5Flcf|U~ zEM*Ax{m}pHUuNAxSfiTG{(zn-Pc4$6So4nEg3do$D{8f&(VyWQ76&hO$q!aOMuw|$ zij@W>%*~u>q$`qbcD9M#C%)CD%frgX=t?2{p%MrdWIfj$% zm8)^Zs4;)6JWOpg$|YDWjrzZF65+`cs*}9Ub*32Sei7a8CzVBtX(aMU2L$zi|I|AeS3aYq`-xt-9 z+#qJt{_vR-h)su7|C`~#4cCnag%sSP&CIMB9@I!OFI(4`aNE6i_v$AmB+TD_ZCI-Q zWSpE$v}G`8bgFcfwr(NpWl*kV)c3Yz`jw&&d@&1`YR^90wu?;d3oA`ia8Czg<-Df@ z^B3{z@Efee3LOT7k3$&57j5@CD4tc{eE;bq4wZ|RDz39Eh`{m_@nvU&CM z#_bo*7JdBzA>2+%Bjz2VYdBX)~!6?^POm&;p!ae=!-gbSKVq z-=Lbtc%_f3IIgC=7&lqRSBidle!{#X`Bg61MZ?HVjK*?6tSG8lio0N|HYr5(i+h}% zOqcU+^TU99DoQ+#xa-VL?}Y*QYif+P1QQz?1`OQw`hm2%6% zaVgLY@(ZKWv@G^qd*SqEAv3Ds_TI+npmv~kJ>6SPJVWy;e0+L{sJRw?LQSA#%hAQ9 zAaI1RR#dqj=;J+6XsV&UnZ)*EkYT$z*GIZ@BYbo#2UKPG(T2Y|j1E`3XCdNSvs4{M z1teP(X}1PS3*jrm$hetuGcCE2`HuRyo#Y1xgfA@N*l}gYriHCl(LC=NVuX73@?|&7 zw4e%`g^2_h1(7wq`%u#i&C)B-YH9#I=Ln4k>kPNc{_Km?B49HBy;JQRLk^QTquijk0me1nUNYVLe5=rth=k<9RxGki7xIW>4hVo~ z9jHV|i0XwWPA25;*b}0urq%&ZpdUG&VZg4OvJ4}C^nR&rTu%p`CNk2?gh<@Bhb13T z3p%vkAX#)2K=#>FNESq85Dx}!q`MFs3yXOSFinIz)&wD+!+PHvxI}3_S7$JDU%?Kb z&zovyVS%)muEF`LTxzigAzK6?L(|jlU-3#{^g|lBb7W&RzgQ+ae`?K_xr_gypun_c z{%jD>D1iUht0SjtEQCHidaoL65Ea7J0^NbChqkB-B}??BPYSO4E3Vhm216niVzQYm zIxz~z3cOr#v~Jqt8Q-;xU)2j8*z9p$3}?v8h0C+~ks6*{pEmd)!d@kk%v;(#VC0kj z0PUhZ;i`ovW@9A7W=K%RC@r-|HSlx&&V%o+?1)~%QLEv2`ZoplG-1%tB=;1bEwJf1 ziWbcNYzI%y61kYXP2?WrYHftDUHXu}+MYyXis_Ou!JlEiFQFfLRiA%Vs_Y^9WvuYG zbD``*Ke40YN@hz#zB2EBlH`B1WgE&GyBEj~qqb^8B=XlDoIU=2rR9;w#n7Agz$TFE zd%Lt(%Yf~yq<8K>S-Jn}KKaaDqoFjTOolb$k#|gtw_%P$Xq*iDZC4J&-dH?2&NyMNOtNaOv;_SpX;br27!Gm(Il=1DK zaLnxbel_^nHZ`BE7=Zs)FA+^Pui)C=iv=GeMpFFxxRqiDJbdBJ!DS`?HanY6N$Ahm z*w5KnZ6&^?>+l^A2cLoqt?h-}+*~<#nN=1cT!u1|1uZ2NUT6mYF5p!2t%o+p(7V@}#eZRUk@wU@s$SJTA=`2xO%u{UuEmLOb4e=!?n8a*(!L*Z4$4q&`H? zdba7{tVc%r-&f8@r?+I3?v2216x#m83-U)ojFH0*;W0rCclgui-;AxESNAy4?74132MCZ>VG3l7o`IZvMwQ5986z;>8AlYHz;&M z3FW^=p^|h!N^tpHdETweS%cQ&HJA@^5j+R#e~pK;rEsVOhcvZ9mdeR0LIN^zy{c)>m)uXbOTG*ag&yDNFy!L2 zp5>F6m|A==*t}170so>Bz{d>tZI&xQQ$7J%JoW{qJ!B6@2qqwfFu#KM%9fCUlG)C z7UBz`RC>w24qqG)*-Xy&Zy4~RuUrH}&fmO&dtsp|28v0V9Xina*9f8sAPzDRO?Slg z9$|=N#mrvjG}`ZvG1{r65*CE|i^@;YQ&9|4g#HXFm|;{JRqPzj{Co8Zo%T9vmLaX( zK2DcnhWtrulSos9n59|Qoo=3Khv+Pvi;CPsUcKGHg!Nk43%?(3OsU7({?i1`b54sW zy`m#Im5e*jJcJeJm>@7Cbyj55?j1fEyG`Kd%P)=|Os~F`J(M_1(z(Cl~Xc_u#5SMrC0$eXil=5Ts}mgF=4EmX!870P37@&{g1Spo7?^1whb{5?m!Oa+0n))Sgin_YXd~R z7GjVPwaXbKD&>qia`ACgRaKpWZS?4!O$|DF=A+E-em9T>3t6Y&jLO9<4X5Of38Hon zhSv8(*hdVwl1GRh> zN%+jLGmK2)9+5sgJ0woBkfcF@>NMSDe(BZ1IWd6h+MWj;EDim}E1==|v>Yaf3B&(*ZV+?oDzNv3|1e|#9yphcS_ z%^FvU*&tM{X+QGX`Nr9?Fstz&l-tUWBSq#)Z+6RfPf|Xl4%Nc)vhsK-m@VEd&Oo{R zZ+_B$E}i%qKBhn_3zg7)yKAwSV)@+CtO>MoIV%z!=tE1ynunv`wr^IL$Va7M`bOgq zUam;&o|%1{6Q?3Rru#oFfNlFP4!4wN)^q7pVKr-dgxiTXY6CPmXPjT7)m#?El7;V zb$>=e{fj%Bjyeh6gsu(+HXnJg`QhTu&WDL&^qWyCD*8VaB^TvsUE8Mm_MNN$NlSC2e&=DE}NaRs&H>HJ3Tho#heedJ;l`R`<8N*%V$ zjCNXvcsXzOv9qSQ9*Wh(wg`^q?o41~`(yT}MCa9O^+*TC?^t7@PtMH-J`k#6UNoI; ztKi)B>Z9JwsqD?hmR{O2Wgt+WAypZf9u-$?m}V|%+H2=|PDh`0SFu_5z1$8)n7H1) z`H%RCt<4X2A83SpVaYX|$sqrhVw#$+=t0KIRkHV^c2@B^&#=^G1p2h-M5k7Ls;RB{ ze#1Vm4jDrXRsSE$pOnFv53aM4IW4}ye1{KY#NyEweJweqR$OA@(Q2$RQfMw6Nu5qW z7SXi=2=fMEsrYFXlvqyzqlVBvKvyG&cHzmfDNhe<3cY~N@`JKcrC6wW6FL4t+(3vI zgg_l}Rw{D!_4T!IULfBH=Lgg|F#UmW15DfAHV1ly+q>}}Yj>~wY%!qGpdRQ;;`B#u zv52M#&KEA2{QIfVF?u$5e{gY}q8@}$X|AoU@jQME)O~4#82ihrfEI{X=A*<5z=zv7 z&!bm`RaG&F{%P%5)yy7(uKqqgrVG$(55D~uZfKyTLMxvD?~nI=Er0mr!&WpZh2a~} zW(Ih#7I)Msd2)!^M?JBBO)pUYoNq3pUx>*SHe6xgVyUU-@6eh2k;>A4OD=o=!HiOP zcM(oKiUKc1U5bnfil1#@uxplXAHVsl_wO!(lgBWP?{-sbNe^K5`)eg__7}f6#K*=c zOwm*-WYQuN-3l-_TAUai?zyPc?c*J<)BB>uLSC5BtN&>Q|3g?kiavou#Q7o9M_O@S zF@`5imT#AguHAfE95Jh>j3MTck%GZO_HyZ?eHD2~zkX$u4(D^X%|L(eT@QUji)?(< zRSgi3dzUrgw)dT%k4rOM5AIH4FD;!^vVM1;oa`3HmV*o7fO4-tei$`{$$KWPmrpIY ze>9?2ozr_TVs$DeeHyc1Qect}OD(c6pni=b|ApM_##e0tU5)vq@c^hW>Fe(`o^-9Y zj*j7d^Nm-oN%)wwFN0g7&;dXQ6BCk;(vh#A%X;S9(r^P04MF;KIDi%7hFuwU9H`-}mW$Ab( z7cUSQh}!OHeJJ-dCs$z+7iW0fjfbF39lWCY#1DqE?{}cbWb4x~#+x&=TZi80dE_NT zq&IuY8W=HjY|;HomOD{ClUN)SvxMfQh$$xa9B-U^ zjQ7XijRCdB!9?M;~Y0y zN-ICVp_d!i&dF)mm{*=maQ*?~Ek3e5{PiAxV+{9tnCM{^!zN*WVMrMx@aZ)pKm(mX zrh!6s1w_G;a>-g%#?@Mgmksju{%M=s^P=qO={W`6@r@4-`ne#ebcKBY`SuOa`~!x= zK9Kn)33~~^(mOLq&^#DnnBJwo9YhE8tbb$=b8{$A!#bzEjzF?;vsY4ZNj@PR&##`@ zD_nEmVxZDa26fS+ALulOP(mc06^1AEAFYe#?;qN2m<@!6=;EjM#Kym*vMMX1L8uu4 zCVe|#*AZ0W;p{G55Jn2#?7w>D>x(mkhV7v9aR8Iq!Kcj2FaR7?f$u_`ZtxtBw;JEK ze<-A2&CE_K#vj@{9Gaai;XAkn@khY^3v`|8{il;fRKycypI@$DKsl!!l&GPEK*x{S z=qcowcfbM(JJWgJjBJ&*Zh2yUrgsV;DTb62WR!eBJtO*T*jHpinje!wTQuUsgOd{( zS@zb^vdhXMV7$#W{^2zhtwIplB{CjD0tp7^=kBl+gfmuQ_$lvx<>CPB!&NZj1(EFk zy9|T3V!I{9#9F=m=Se-!UN(F3Bh=Sg;_Gz)bn}~<(!nkl9;+;z%%Ym-xqELmlWE}! z&C$uclqPe=CTOL)lShGxa3kG?dQjw_pv$})vueJQ(Vy*cID^e%@ALWF{x;Iu$#137 zc59>3TIpIAP1n%^Z7OJCjbMO6QAptl`9D<`OxI)YlS~<8SW8?yyTIST`ZnyH*e6SO z4g~W)MBGBlp%1G76$WK$oiYX;gF1ugw*!*MfMApF*qC&eTg~Rs!!y9Qg7d|C4#7S| z{x02O)vQJji#}0ty zBWuh6{|05k!`D}J12K=i1Pt0E;rdY8-zd@ocs-B|0nwY-4yd0J?nRy*B1Wd(#%N)}H_Cqc5x<@2`=;cm^`r6U z@PaMo<+XM2zCU>J`Ngab)v1T4z`;sXmn_FqFEL!VbV-lujyvsW*4MYkUXq30{Wwi> zO>B~yZgcxtiI_6U$aY)KZ4c)eG`^Wv=#~sU_&gi;U-N&{Kj+0q#_b*ac8#AHbwY&Gll~1z0_`QYyhx`XhPc1&_?`@m5#q6j} zllt~(;Fbp*x^Cx($IgT!V|9$1IW@(Km9i`c ze;oA(RcYdyGuTs7$>Rl1E-oEiPI7YP7HvPrs`5#?vFw}LFj5{qsJBOnh;ZJWI+JsL zLbbO_LcH0m@5DddJ*Y9`eRq+0RpZ^j?YH2QEbUi(U-z*oKBG3igeROKBqx7VOxJI^ z+@qfI_jy~+1egvb(HqI*?_s*91zbM=98Z1p2fw=bl6ifHc6l7 zDj3vuEujT9gjR0;BmON7LjCC164A{1heK*zrVNOP8F}u-I`RvA?_qmUg^zRH)}?Td z`0I+}(A>PZJN0Zj)$h7~&0TZ1%QB^k!aY0|ta^d1(J}w21zF{%#roJ7Xti_ZEySqb z=BPeb7g&{i`WRj^ue-aor!6NqhgWqtF1%*vyu58XKJNC~g*mIBUi<6MZSiUBq4Bzz zkio(qZeue(vpnb?-W_s}ZUuYkaUsVzBe_sTG68xJdR<)|oG;J8Tmkn6MAZss@hzaM zo`9IMcOx(4&XZqx7lkS+D&GJxtJ^7S-~(Zc$RDwt#B^j^^gOdi@Q)l>tkMqo*Iwiv z&(W8BSU9D;CPM??Z1Y#Nx{cJi1EOp{uBLGS_%DZLlI{f$m4gzeaVRc6c)lx1;K0#4 z>X7kS_qh!+TR3$(rU=8O0qwqUM1fKRSS^Wg8ys`uuKTxM4(Q5DPYDh&T0+z;=#J(t zUc~^IEquC&29Kh6?z$)k>5HED!oOQGELhi3S51E#R>R*x9@6fx48v_rqlzkA^&mL# zZTU*Z=BBGHMpX&`^0DNd5l$q*Q;&eYz$zfU=3Q5CVF}H(fZYj z_k(OY`|=)T;v2W0B{1Mu^)bXwop=p2J6>M#ahoVPWy-$27NghVbz{S`zP_QTzNlem zt7s$nF!0ZFdOx*Cqjo!KLXp2ufQVBfA;}PCfBEcV!%J-43x}k0FuZ!Di7>nNp*@_eS_Vl>Xqp zd2sI;dOeF)K&VpLw=4(m#!IX46VI)C{!CAA%Kzva6I!`Z`syQ2fKygAy%_1PbO1pw zHX9rLXAiZFJI@DEur(6&6)8RCy0dSJ>6C8!x+%8@J%0SU@aV%rmrt5N;x6iV;#~7d zN#lIHalujJl!Gi=S^AjoQl}Np$!2yuZI(&?l2#ZG1}TNQjSCk+w&9WjWpc=K%&hG1 z-%9R}m%mQXX|qw}Bz0`eMN8w*ar)By@Ikvr%Kn-X=6iYU?(%2po-R2zwiuM_n#D2E zpL$?nR|_4Vm0o}H?cRijxSBf?*-LYeun0pHZOsql6`dcW6;tz$L(0-DdqT%~jfdaz zsiAkDU^nKXLi*S{d_!a7n8f^ZDV!T# zaXB0JF3HKb_3msGKm2;tD$K5}QoKsLd2$e{K~b4gv^Sfa(S3lujcaAO^BO(Gu+Z&S z(9@8cHTr>~GUPKDwt-`t)>3#FX36GmZDJ&U?$i+_Y*Jo&pm(z-NoOyO=Dw@_AlNq4 z33vW)8Ky-k7*B6@m1pF}k?1YVh@t1Yd%az{{dVNdy`Rm;C{*-2YwuQ19sMrD}pfZRFk;cT!oka{oAj zf3`Fux#SfBLFZUFMGupsKg5Gm*w94z7>oA$sHJz2laWlN)R5&?ph?&JEu$9`ipnxr z;lwmTX30HX6xZ(Lp2aDYr;PbBU62axdrG9c+;SqUF7_%C*!&!#yY{p{8~RS?w17u0QVX>sy5+d1&Ud2G17t zo4x7k^EnaweL?K?gspKOylbDSz8NCM9V84P!*v;}8On73D_Btx$yi2eN>Riwij?56(O-XKSND8yAUq zaNs}UgQ2HxBcm7Kv*kVIQ65Af^$Qtq!2ra?&5i8Td@Etx%PTA_jEI#E5twi8?&iSA z1L}2#gWo8Sj`8bP+pQyLG{p5qn0RdVT0OZ;HDr#2zLdP`>iEV+K?M8*c~Y)&C&Gn6 zpw>Ir3=emAq;U}mym0$_(1lptZV8{>701l*J~uJnKzXiaLlPQiORg6f- zFd13piQnbLe^xn=)=C%~Gl60bw~NL{FeUE*!T1oREWGd_X03w<*xl2!42lOs_(Kp7 z50f@Z1(Cu38qK_lgI^Pykudf|oCUS%t@^ZB5C(GJ#&)_U^_w zib>@YeeN(vfBZMq6vldQs_9EQ6X|F_27dl#-es;~qO2JO_ggZQG;0!Pm-mMwE4B@l zwX=a$Q|as_x4p=;E2oI+549|n0u&BW;eWOasTZB36u=GW_Z#2hlB9L43#i0le|)>9 za)4@JvRbBn-ay zU2D9glxa#N&iz&e4ymK>bTo8R+d^)f(8f>byO0~t(XJ77IYp-w4Y;Gp$jWjmEV(qy z<>chux9ZzdYK@LDFTkjou^Q55f4on$Qm4&spym7QZo#HFruK@P48so^mAKC;a%t>| zwB$JsjUt;zdQP=5l7A>BV#e!qG&XpdzwM8Bt;EZua+Z!;3ns?3_ZXW#uH<6)QP;c2 zw5=pNU;eS4YcjpkVe6uLE<}oHi8>}Wwf6}K4$>tin3O2x0-q_vgO4&HsS#4&jkM|+tvIS>OT zqQgT>m}QNJa)=4ecrc?BM;FK) z*{w7iWrBUTZYwVpSY0yaG+WgCH2e3$Zj?2+2?HoIL8f2Dzk0Cb%3j`bYtlWxxVY6_ zc?K02;GVk@?JSOqBZ38G0K|!dK>n~ie5gz=xzlF+?PR_k=UGr&Yxv{&??AzK10d}H z<~5IrX-8cDA;+my3$avg_)SVIaeUUZ$2S0gx4}9(2)|z`_Uu`CrxLUW)uJT`NoQ zv0VkkeFJbYC=RqoR&J0#+0Hplu$a*r?+PFuYG{}OITmhHQ^!MdW$K=R)2WJz~4~z7-A;tpgxlbV32anIvfomSm-4sgU zylcIy711hOe0;8waJKyKD;AUXmwS^83vS@!SY3wmPsPB69x5M(vu3;r_`4JN=Yp( za+r(}??qpqg1Nal;*NLQ%1uNtAQ^diWV?nFI~w79V0wr6k6L)!BTz2iR!*$%u&akCxl(h_V(J?T(dwWAIAo$?(XC8Zd`_pZWmiOc4xo}rQ z3beu0)`4634=S8mkvlx{fkr-ANaGvioqPo`H1PZ&@wTp8BL-R8?aXkKPgB1xE=yjw z2sgL?1ZzSTh^#@Y(k{}h3%$Ezus8iyX+DfEuYeOQCotjJy?}`w zH6~_-RRd6u+ew_xH+jIjzyR_MfD5NeO1qqyn^S!Kng)3@A)U>4R?Y*&%*0bq|ABj^ zeH6+^5mN&Y2t+L=V77oaA;e5Afew6S+M;|7DK0`ZRm|y*1XEL-8hC(~8tUo!0-qg& zl#;p~tuyKf&khf_!uxU%MmjG>ADCrwKn#V50ld?Jp_EV>$nii(edryjW+eP)CZIwZxwzEN?5uL)n)|8b^jq1V0%em_^n0K zNn1Y7h}EX^FVk@Ty&2a)r>=Mz2D;~=cU=FzrXy_m)Ah)lFkh~OA|z}>Ln>l}UMx8q zr&6_Jq?jVc)Q;dc8dLIe()mh{=G6nyhWrFM2mi>qyNB(en#c8BuA)m*9?!*`1CFB0!| z4aP_P;LBfMR3NSBBiT|WPESu41hBx}O^%pNs~teO--pb2ECvzr6W|Fw|Fd&&ad}_` zP8;}4YiVgMn|&PKyv=<`c^@+F5l#QIFb#0r$HWjIcRpChrM$d^KweLyb(fLf?jIM2 zUAf$sy*7I1#PD>3o<@b)e~|>g_hc~NBw?A=%&bIwZ_<6JUOdiWT?KD;5)wkp>&w!& zy;9oA;#7KS7pfpn+{bv*@(T;q`jd1eut19%c>9RQg~>4$ozXNkLd!0WG0BDDcYo(r#p?3Pa2F35!dr36(|q-DzexMM$lnA>ldnrM z!TY%;*;|wnx1fG?*)~jM$UqaLo-9lYYumGBvT?5Dfiu^^BF5&;bJtI9w>Eor^x{$o z#_Oty6L$Bh#RA7u%Xo)STa!fm`TTCryLpp3dgr2Z6>Z9nnx$Wac>PQ6^JiP^T9}J? zP?VrSv9Blb2WRcg-GIe+d3c>;DEg*;Z*H2uD6b%peHw|b;uMwTR!_@UWU3N6bg05j zoWD(4|HMYP^vwL#=GK1uwjA@Sx)*x5BdF)Vjr{ z7(Thjo15(7;uMpRVWdesJ3S`DQ^ay+Wp0V$h-OJ^I<;U*%7=mKEiD~LN|wA!D2{o& zZ+5q+uvg37qyFB5p2xpo^}z5`aQb3WQSPt%tcL>U^ko{Cq*Bo|^~p;NQ_FcPQv?11 z&Z?^M<4GYtxdqc#`iZCv%^AesX#Z&K9{(PiEz=FMB4B+qPbp(6_59&r zQ}y!O-{1bWucR>zT=)2N0QZtM${d>_kvi#x(<=?^{(8aRH9zz91Kk&hRfdE{#40qJ z5;FFQ>E1Z`gydL#@DDqdWWIRY!x$^ik9Q-rzjJf5U}Qic!VB09#39tHs-mWrnwm=P0W-^WHlNkxVDjUp(@5q$_?d59(N(W6H>`S}#{Mj|-EBJ>K@epg<^bkX-B zcTH(2qjPW_w;%hMnhHG$(X#UWP|YpVb-XIvLOfwY=<&?+)aloAAfbpJ?uF@M;AoMUdUpKIXm;hT8e1Q3WphpMx=I_cqxt`lSF^6 z-bvg0Y)ueUrihnLj=XqW&e{2keY0UsULJ(@Ag;05N_RR52?=D#$jf7b?sW zG2A}z^w(6)-*T+TyAypn6u)$rduNA*MeTLPw}efsEo z4(ktJ97aLZfU$a6>sB=pagq7X9bCQR*|Wey^O0|1(^K!)kKD+}cR%uFrDM|uOY<1_ zKff@SR_7hRBNgbqhb4_`c1^ouG+yw!r!deat2=bdXQ;I2hJ}@{EuP!oA1^%9wMnXs zB7cd`u=I@R>D8({v+sJvN>ZLV9nlBtAC_`Gj+X)iZ=^3#a|b?Ey&_A%^Y?dG)cjta zQfP{D5yXvqIlXTiRcaBrq!;Y>{1NJ1ao`;)){4CDZ_Bi0#Fjhkvlo`K8O*=!CfUR) zGT#8v&yjm&z6;9)iGHt(xyhhLPipeGG{-$0rCBRpinZ}=rzn+}@g>GrE?#t)BTgrk zGDDG=VKE7bi?5_GjfujzY~UjA?ov_~z6|8$T@K~o?*8;KJ8ynyprP>%tCYEroZ?5z zyaVAc`3~1L3boL2u_0U2Cx>AZPPDANJ9vNOPg@~SD=a*m<&1;>7zyM-gdDx9**2eO z;$#@!j+=+mFcaMz9vKk_GYmgJe~_0aAw7id%vd+zvM?gb(Eo+!oJgb^Io<8C*iOpx zutp7_dp=w4w8&c0N&G_Ohi8(e>QSZEp097g!m04%hzHDx?I)WCAz&3oN-C+nem{q8 zR02Nmt$G~PjE>)IASz-GNxo=@=qU(rWroBCn9m6kd+)TAmxHlK*=t)Bsm6Q*c~&6t z=TU_Hmci;FIOACuVKEpRdy%J{8POFhDEhr8{(+g*xR=lmPRQJVP+V77RKeA*Drobc zzgh|o6cTOQYc8{PPX(iVVRHv@U***^bi}I->oT%}XjYrw;Z4O=90g}1(XgAw3_AjZL^QM(3zLH5qGsX^~ffG7Zcqa(U`0ExC~u*WNL z)>GYtxf(*TdL4@)O#6SQgIU?Sd{_wb)jjOjw#0#}nJF58uX@gNaj)zTIE=p*sTFH} zHoXnfKtLcOK+>8Cx6nDFT`z zJ2Py)NIH`DVQgl5VjXlPUXmd01H|f-dAV!i2LGVh;LHZ=Sg0~J^5@+W`i+ld`y*)p z;H-vv>19U&#O1ZTk-3QI06i8is1e{1D0xAkW)VfaUVwF@eT9JY0gz7?z?&NpFMyVj z_0<;zm%vGdPsL^R?}7I|0(L$F>ArzD7C>6uAb_sB=e^fz#`o7%o=Olp2wUz_827-C z4cA$e?A3K1&NCE+l1Sla`MjL}eVv`!3Z$n_B1vj0kOK&fgPEYiYgZdaVWS5z_)7yhshn-OI7JqZ_*;XKEi}v zocuI#bd3A^*Ao)nAQg7(#}5E#hy?@$;5z@^@VPP(v;p{p9U19cS~4MThr?tbt@c$I z3Cn;9Wt5dSo{F5`26XQcAbJpXU{aEQP_6|3X&2%aHz? zr^2-0VxA`;+Z5L{2z>k820yif^!86vrevGyo9V^q!Dj{|EB1AG^^$Cl9>pUk&G7b4 zco`*J#@O`^{mOgI>3}UBZ45q^6jcapTSCIh5RStbvd3!Y_E}DP2L^ao9Z*>e#AKPa zMS)ELi#7;W&Rt)$goTB%MCw2WfUInYF4*?Dkc_=S^*J?BOJmI{GL5Le=Wsf9OeAF( zP7H22R_TfLtp(?q3Bnaevj=6ZQw~S-Ne)|*DJPE> zX-GLe*>=sQf<$rzN_TA*lnWMW1Nk{7-w(w<;+ynae}0lE!_#8->%&=)-e_?p|0iz4De}CAnLT86foinZDbbf6dZW zpT>fem0d`9UC7zfSN`TT;o`XYGpuJ-7vA>avn&Xj|Iy?cG$t74xZm}rrenT}8P*6J zY`PM4_YdWF!V;4JQ}yULb1z3AKjMiUO~x+d+#Ub4;2{0#;ZctnaSY&t>c`8E2C zx<}2@4C(~wDYt$*kCGAaIi6Hr9UBMa2_z<}aE(;I9>(XGp0W(~B*MLMTkKYAfZh%9 zug#nflg%JkyP@7TC+ESQHr-Uq!?REHq!Fa&P9_fY#F5*nMdj6?NwD6Wpil3=?r2Ba zDeww&Yk!77*7fUT=PE{8{F0*ppo5$ydQ=7w$%z~`e3W(=Z5Yc)1_H2ttBCDpqUGul zWXBA`_yHyrKrW8kGRCWb%@BrY3RU=Yz(CQP_z>emd3ofvc{)u`WQelSWz^6Uk+EL% zt6E(4E7{$jq3W$J!neMlH5Mtk_@1#HFHTn7+|sMELN|I`NH(RJzWoGEl!r)9!zOlM zVe@*7smqfeV^}^#N^`vd-O@|YFQx|B5|-F_=mZ3J~W>_3KiK4Y}j1rJ5DI8A8&%_WLCa z!nyRCEQLk61(MajJUqn`Xlh<`OL)A(RyPr_PM0{S;a0KTOvB2bDP^5|R!quu{nv)b zzjWfPX40n;*Vaq>+tSlNV7Fd8e2JM;@LHH>5QUBv7i})P%Dks|L&4nlF}~3j!FX2f z;0B|OR#xlO(H9;Ptq{(ew8QtLs<-VHJdUX5$z&dnxpfyg@g?QQ#?i=>nd34w*3+ay`P7VL z&?|n?UuI?C-LX>Z|PuN>F%g+`u$>p=2&<_&M=|Bi$}mD;YzanxcvHT%#=R zuOOZTc3$+G_wMaxz1a9HJWhMB___acM<>HicZFtbX*?`E$g|AW>W$f7-iTwoegpq& zs?8HD6OGPCzP3Yy-xpC>+^|k`Xz#K7dM2dG=Kp{(HYVE)op~SS)5dlN6$@{k8fhk# zb85fst;y#84$~_~35r*gSgK{kT{=H=x#Cocep`g(VB0c%;k-5(7Tt>1F7jlOgC88i z(0XMiU1a*)V4HBLOthA0gNi z>BurS5A(~9P}_C(7)jP+qQQMSu&j3&0)Zp#^g@&@F+#StaujomwG=d}4;BJ3Hcrv_ zo+sdA*Oe(_cYii?yBor!PsY8?Fq|jzM3*m}H)BCkC-@+<^K-q3==YorIrR-fxAgm^ zx}iq$`O0Hf*{lXJS(b!mf3#v8Ro9k8>x&d~DXMeal4KGM|7o6If6it1?K-EMcdS{6 zJC|ZPx30*0E~)849!GaBEAh;2QdP6}?2?V?j4>}#CpGe!E#&E}O^0YE3jFRmYhIqk zn5upj${UK=CY<@b`G_`n?NJE(b0^x^^#?E0yS$lMUR7P@-zyKM677Cjl1wow&RUus z_OpC*m;z6OP#u}%NPuZs-D}kJJ^8o@sLNH#oh$ofx!1;U3*n@|RSL@B8QXFDSRj z&J}%gsvk)5kPq3Qh*DU;(>ug;^KTeQ^4#L)PwDROM*?uhdzqO2@%;ZUoL|Bn6$Wgc{^MFT_Bc0X&%KDpa!2HVHp3T z{XiA7K!)>)sf&Hw=@ZLXDY|dcigOE7L5Zq~Jlb!U>Z5v>-~z@s$NPL*-y<<2m*mps zMEv4D+t_@KNin2AeQThpdia|HCCYhJ)JFfX{JohS2frmOw7jW`A$@xK|9#o7CUM+{ zRdTd&ms6C1AerktZEz#iURuYf9nbXz#0C599X6631=5p$ahXLxmdLlZi_g~@hDQ?WS*F@A?w)LJ6;o$$i7`liE3GkN`-*()Pwc;v`!;c7vT3R#| z_mxQs9vH3)3plv&I(0h3MMpjL)HTBLUD)U%uO??w#6a`TX~ywGp=}wgAYvrI!M{_q zvSiBVOMDX_i)m9FxC6}TvBMr){M)pZwZ05|x-B8sQ7d<%G&j6kB7GN=72_kI!~fxC9Ugc)nnRO-@*ei>@*_!9@7D^WYUh$< z1jV$Aw-$e2bS9#Q)9V{yZpO_u&6*H%e!wb(?C;kZh%B%eUkEXMXs%mY!FeNP| z9nv5nAl)U>NJw{sgmiaGNOw0%cek{ZbV*8gcYM$GJ>U7`7!Ez|&E9LR`;$*SqL3t62P0A%_q)+KZ!*WhGOXSQMjyM@{J_7dFi<=H(axa@EhWu z+)4knPVDO(s>g-ne*Yzf?JnPyxi2tP9&zoX-8p2KIvtUL{@@+FccWY*%b~ii$}V&` z6r65zeBk}zbkr;KL9?U0)z6nyCby!@4tzf39r7-gF{iAwSo^fiXYh|={!epGL=t2) zi(g>8S8mS9MB%R}&&DiPFoDrh#Ws1;9 zP(${l_s!Dzpe_*NazFMu_6W$+V!nqc&oYUOYYtiW z#1NPsSjh(8NBvJe>G%8G$;xAu9}mt*HN(Ks~0WLfkQF)2GWKE*8Mua6S74r z8&Y1W1{v{Dv;3YB-^#W?MRK`xaCTAC!E!w+n*8gau!fI?*^D)OGYKr3KY3rQYc<{ zq}dtQ_poMm#u76-rQW@0Yxo{D?|_U7&nOd-zPo ze4>Rp{bMMerpK_Y>w63X^h5=J^q1s_2>gMqdzUY7#dmjA9&aS+KJV{!r{rAi*Ov=c zpA{0^DMwPve#!O28mJRbiTnI+>elVtKABC;$+x}2;M<)$hp%6JtN^t`k-Xy!9bAix zi4xx@C&#_(d-aQHJ(0pMNIm)}iH3EDmPU`II@$p$YTJ|<_fibX5wDFh?iVd^xL}QJ z$YRpgtU=DA)7BF9=;yl+=P$2Ljv36>r#>_j6BFc{rY?w6$Nq6d;m|0)-t^!7JT;bD zXfD_hRsKcF;M5qX(>G7dD{C?0b#HGFJS4|{^=(NG2jsIaj5tT#xlc_`i7o$lQDB7P zSJRP|&d-6a*zvVMYC+vBGJ@yDo`ZceSHgVFv@>mivBxqQn;A9ZUrY=_#rw&wWOGtK zVf$xR8VNi=B4C9?S|Fwyz~4Vu>Bxeh&mO>m9&&0Op zT+~N4eSKKWAGVNg(~B1R{ch(lex5HOZwP(;uX{=H9bl*$`|_(CFCRofIl@J1r| zWz0w}bQbwUa(rya%KK0zirLOpsNMn-X`=Jn*66e#20lJ=YB4XxQVlmMP1IaL5mRS! z++KZzOeAlX=G5KTJ+u^xGQa;V-DW zkK*$*^P+!4i`7!LFgL<|Yt9(3VidCQrXat@!#5X8g_M{$pR7M`Lj>hTr3~{&uMA6F zdt~W&e)XWv)KtHv0^XewTQOAY6*gX3gV2RcXe-Q)oWpxh-Ji>t(nAdEsTlsF1w^>N$HUUuqBY6eJ zQ1{76rAXB0y(irYJl6Ap+3TT@uNUc}1sPu%qhs^}}_pW0zE0)vPpWoc}76kJ~ z-Fe9}sNRRV7)P&9*uQs!H3|rBj!`m{SK6N6<#DZ1rj+B}qh|Z=+v8mp1Z%ue7?;~} zEZ!F^Il`>^%M$u5T-uffe~3&~*NXr|2tLgHexih~$UzmXz>}MM8N6!g2Zgxk)}Qsj zvIb%X2AVTrxt`CX6QFSpe7yOs3IZiA9rsHCnQRynC$IeyO8o+D6xZI|__Hj(732)` z{ZXhErC8WH{OOBuF1NA*CRymCOkY=hN^fh!Pw>c^sHY^rNM;Kna>~r}AZc^{g<@FT|_iEVg?>QPeSUO1}3@HB|(T^gJaS(cG z7`FC9TXMn(hO;FCmS7aP%LJQb?fP%<-rKAvRpA8(2*k@7f;b}O*7Luy7EHDSftXZw zbjgF`L%_zB!sAe=D~{L&0+O!4MHxp}3HkbY1NFvX3*UkN_5XVTQp~)~+16^RtAQq8 z#|pcj)oW2_4>7E5Mg_&Jt=+7E?K1#9(|o~af46SSt=?eKqzlu=>Plf zM*GGU^QPrGmxsp7R*Eh((vghAY1uiuBjIZ4^BX;DxNpu40K+)M=)WY_+QKoi+Hag~ zttVQH?{zpbr-*>0B<;SChA2T1*4|);{-iINqD+E#L(VNW_5JnxbM&9K;l(e+2`t@6 z!{s;#;lDQj7A40jtIF|nzG`n#xsH&=Ah!DYLvvYy#dj=sd~%U!HV~9g9Lh=JDn6xw2sFYcKl0$OG#xa^JDBMaYrRXANHb_i!#5e^`7t=d}})7 zJcv$QN)-2MZKL(4G#Q5e|m%D4a=y+hGuN5|A zOS*6MMH2F3Z$VMB2(}kW5;kwl2>J5z8|NR9&hk;?-xTC`hfLa!79Fn-7f2U{sv=%q z*X%E`IA=`Wt&OS%7S8ZU`g@TC{~7E2(C*!-;Fi2<&`Q-JV31r<$cm;1B*X3KI4Af61E zk2r_=5Ns8str#R&bUFtA9l-w&}|ZLeEKF^`4ga4a(kBSx_j zYlkSDFeq}!Rz!DYIVjW`KK$Nc=k+M33kcJ&P!bW@M4at9pu%* znBdsSf!oRYc4e^g-)vlbQ8)p_@ZzuhMi&h~A`>{GvIt}VOtihjh&e;YBCyd>k7lT3 z>kX_&pg!DhX;WDX;bI!pSrO^bNdvP{{t8tM1Z)RI~=sI(=6ombvjcrH`lxxZ)5*^IAK+r7*# zt9!9Kz*74zZK1az+%Ml!*C zkH`AjJ^Jth1!rm3kyR~eX8%&;G&8yT3hsduCGlYQms7*Sg!$zrzCW9B3njMlnBv}_ zFEyv-s)mhG(;sUTSY>7_3dB`abSBO|W);*EnQ5X;4k1fPsqFKY?Z_SQs36gi@7QC? zy%pb`je)W@BDWHKDQ*yj_URL!-e;rsr;qhP6P3u9uNBg9b1G-lw*#E{QWBcy={Wf& z_orEbjzI6(Ck*|3t&5lWkQx}jdblsdO3R!3>o*G@QnYPz4LG;eNF7=h}~dutNiqH zG4~-_V+azx;t9DGrbNi;RSm2^VH|K?^)bg^m1j?vp95# zrt5mSuNS#bXB)Yn7F{v^HpLbMYiJ>ZE-{NtWG}3&$eN|U< zVXVozWLqA}Prawq=e;-4=a>OsrTKdw2%1n{6e)$XFWq<%!4p2b*N{JQP;n6Cz#DR#(Y@o7!EY z%d{pYE2|<&?w?~^koDhM&3{6eF~A)H0b$bD=^La)5Mm^NtgwNt1K6{3 zK{p9NEt~=-1h`G*ue=EPfI2*Qdy)~T2W(;pUJY7J_SDbkLeECYDdzwFhi8fg|9l?8 zWVXMPi2r?{ui~PjLJ8FGs7+`jm}|_&wjfN}f`TAmdIAO#kZYk8(7AN`ZUz!y5QXjP z%DH!2gPXXpxfvLHXQ=W8*&&oO!OJ4~U6U7VFm?aDBmEKo#1GM&-!WYJNCqc7*t3^Z zG7Pj{@l+In3b=!at5G~WA@$Z(=`<;jwHV*#?x-rr30`8z(D-|b`EryMk%KJQ58A{h)E z`>}t>_;lK|nM*r;9TeaDU2Bp+fs#M!Y-;t{}A( zHI|1e`JNUQLO5vMm>2r|lxMp0>2v!RPw2Y0aIny|zDcc#k>C|&cUUv~MQd`k2`m{K zo37i_iZ#c_ws{bu#xPwUTax95W8k6QoPLX(m@g7P0&AHM{8K7CFI!wN5lftwXIi6# zJLf9EAM7Dj-p^?oOy*p@W@9!cJTf*c*NZA*?WxJ8PH)W%H`l7sltl1O>& zioD{Eiti}N`Ij*nyTRwhGtsrkoXx%zZRWe{gcHnprE5bZ(5<_P<{PiP@Ri`@&VsHP z3T$4pHwj`i#rs-E*}Ef5Q49hr>XkBaGlx5m&$~4Qxfp2m$F$kuqTDmn!zezXghvHe zRZQ=xdXBcly-|Y2Y23A5juZ1~rk&ivP^m`7$3Bfdx<2gLEhVDk%Gv((-8{d&02hU5 zemv-tI{|5!$=~|l96^vL3BsiN0P70;D&Q1D10gv=a$G=Vg(P->i^u`MUler8;A{S! zoZs;z{)>Wwjha9;TP0QeaC$i9JHym?c1Kr9I@P?78l|dYra=Z6SS0ooXVXdi2ny3 z_0I5LbOIZPt7-l;^EU9LUm!}d7Y;~b(D7E~|G15S@phs6C5b0u(4IAHUpFdI<_yz3 zU@j?TQ1!Js#ljmwhe_J37?Thni>PNgN%~>Ovd_-p*tpwW9MAb7su7 zK0~#|PgAC}u?6)GZ}Vf+Oujkt=+}tEEIey>Ufj6_pYa9-6>C^{e`2jJN>ellc}Tu@ zXV~4eSghkCLA_{}vf9?<7B;R#w`|^<;(-Zdn{s|l6O<1A2Ar_|Zwp#Y{e#(F4NB#i zBI}B=&HUnz5sm~Ww*y$@?>m-fc*Jz;Qk^SXV8^m?T4W+b@e}ICoP>WsYmyPpG23XyN?ZB|Bs z9aID0?m==XcC9=6=^73a@&uKyayD)R zP^7Rk@B9lt12tqFwnHAI)9hN$elbYWrMxqO2OfM#Fdj6+r9-lnckWJG<^S7-RDJt5 z4uCD+5u6amf2xbb>#yBl8i~Y&goHo@ra%mn9~%O=1))D*3>Xmpf>e2eu?kG;s~|;V z0CHq^I{&?SjbZ9Qny(+Iu*k8Iy;hlnN$FwkGzqKtUY(Iq9|<$>KEZXU`=Va362`y_ z(R6h=Z*mDcW(O6L5V#Zg=&^CO?4f)%u8i<$v@T|*BxC&zk30SGPqPo{;wK$o6zE#U zZ55f;aIpOmKIK@4ifM_xl8lgBjL!I$1+M#T@z%cC4}+3iKeD~>ro)e7;c)YHWdXGZ znNo_ry_3+qEAris0%0P(R6ip+pFwUvmafxcU}$BZpSMovbFw zGNH>?fWvu`eLmYZtkalR5$50`bQDgN}G+GEy8 zbvF7b@Rk#XZcf&dG=XGotTH^suWj(ys5D7n$m`n0d;2)2dc~K@g`G#2w4r`QK3~Hy zv>^VRvjw*8Qjm}PUpJTpN_JJE=>h=dlbG6UDH1k74G3xr}K4`>989D`(F589Jq-o zJn~9YtKkn{U^wi)lA=q=%Amqh92y<_h=m9jPoG>ULZ0_rVsUFWev6{(O zVtE!qSsAHh_!yZ6Z&Nb(<;g0k5t-m*knyfdlj1U2;MyIfiP52~8bLLhIOe(zh-Sg#3;Q{DMYxYRde+1-{p`{06ED(I+?mZtiU_zBwerv<}QSt*jF zIu0Mwl2jU`eySA3{>uqK>?scM@aB-}3B|PcaUm%BMsUbwBGeXY(ouBpH zj20=F@-?+kWs=zsq&l?SpwGv2BGO7IpSUMD%n&6J$MS8VfhMeH4?Qxv0m#_=7r);> zj2=IrL7)~$9(~(g0SNPTmNG)N0bt;Bak<{w2Qe4H+d+AXf~g5K!U*xari0(mj3ZjP zswIkLs?0}dj7TJT2qCV4uGd4nkM~n$=S4;Mp9=N#`Ox87`mob<%3@JbZ*aZy0-WHl ziv9cOpwAVfZW`m$7jTS?J2Yo%8Qon-mA^2`<%#Ay1pkoGZ~3B8d&pBf)%A;3qf+-8 zC2ZUD(SO|!u?gon_q#*o*F;Q}+V(Fgt?45eMJ<7bL8}7q{jYS2S!!Q>B!j=huv6g{ znh+4J^*K&_S$RnK-UDszs>vuNKU~DWtWE0$w7dokK~S91Z6tjbEO@wufxKUi~NHUE{+XXhCrp##V0@MYTT~XtCWJu@b{+`&(P6< zFD6yiYA+X>@6Go=z39c$^k*C(FF>2tCgObCewFGZrF6kiFHJUv$iL&^-#c+@+lz&kLt9l7m%;Ul$L^5o@ zHA|$EOZ1{R5*NnUQNSzvS*=msd@^d(P4c@&>(Z!D^=~@9=q{J2t;LVgRqr}0mdxxt zAKzq4Z5g`IYuQ-*i*J@ghGShujr$5Eg!%LpSfADIL+Ge3>oMhp&}-Cp$@EJO4M+icDq4W zj|}knET*4Hvgh3(0^P&)^V3Rbuc0SMBwVyZaCCKr(4~jJyBNS%dR#m5U=B*PN__*8 z7P$4y1U&<3OD)rBf+M5)MhJ=5vwIDsE}eh3$xh2fmWda=mE*WllT)j$o2*w{U$I-B zr12aFC3tl!wbKt=c03O}=y7ino#P7GE_OF~ysxuSlSaaBv>F+flV5MqwGpoQn?~g3 zK)W1l8ewjDu0?2Nwu0t@VaP`ajZl%m^}w>CCD<*5J0jm|-IAItaGz7(xH?4lxP95a zoIgk;C%ZWQW>2Wo=5yqq2MLo&Z;?Zym52(R2M8fzP-w~kQ$wvsqca>*jZ~JGr)KU&7m-H|2S7a)dFGCOQxMlm%xYLB@}D*HtKVUH9DK>J1*he!Wb)Ce95llj3PQ z?YB&lvm$ajTi~+#a=&G1Lo$_=CQ0bDZ2YL{CS*yJ#ZkOkrk3|I%q#C>X7xZYX*|6Z z?s?+UjTv9d>>C`1NzPKe6;o?-(`%BBFN^#xpZ;83y1Qj@#HKy}V87+3<9a&9FHjz< z)b+6;BIG!^@%&42?3Q*rY^^36!RA44x0XfyS$Bo2vguHXbK#g_u}3`a@5;cFskJWO zjkQwweW#_(-g(6A)7_mFk%`x2`E~lf#GN1t276h>MXk~K^K$jR&y-!;DbMnqXm=s@ z7sEwYI-K)9Gdia^Q*AD*n?rWyeZKx?^wz_r%KO5J5zZEMA+wsX^9AELcWdJP1_oy4 z5Lf=E!kUH8OlXsnlb#oOq|_<0h8nmaoB>+T&w(M$4upj4|3+}RqeJTh{=x%*DZB%8 z#+BY_%4x`_x@E234_^tIk!~BFuU04uMsus<=I8vJsw&0@g=5V-6L?StVNpI!@pC=Q z_tITO_|tR0jH_c$Xti)SlQAxQF#NOoz`uC9>Od!GUPZbj^T1=mZ-XK1C0Uzs z73aIWIpET8aYdh6qMLnz-p2dkp*MaA-qaug{f}o)+%4wlg)%;&s#lG6*~!7MM(?)M zqVWogn1Ix4lnDd6G?fTp0X7sB6-KZ5;aF)LY@$wc9}>P>D9@^M42+tdisS7S;QT1QtQ#SY zTe%imo)pBO#a3ZcXsc}Q9K#hjOo%O!u(mHu)nF0e>TQw#fKkq?3`^r9z$Q@??T`@o z@Qd-jKR4pTJ+BF6|Lq0+&$J+0>r7d>M@9#y$o?nX_$%a{V(@I{;LEjExjoO?lyV%g zS^&EfO&QmuxsoEPvP%j(dGXdzhwUF8eV0?W4!(PKlkAcOHQ49HW2S{Ph(YhAZG{oL zdgdLto$6MG$39Y+=n(i|C3Cx=bvxgSRC4o$mdz15H5Qsg9N}`T{S;&A?it>fCi$kF z`lxdlNU_JGI)j{#a(-0wLPImB5o%fR%AIa-*q_%MruRc6{Ch}n`n7iQ>L3Bfdn4+! zts^#%kjCn8X*!;1CF90V8U465A9RylRd$UcbxeG+q*^Bhz6$sKs8rSz{TvumP#OKf zwVG*5hAy^bkJvx{V2|@1#a^*$Nsj z0xJXyDR_(GWrYE$SZ%SCez<6@)UGqQkT97~p3ha;6E?th@CzoU(tR-@J&i`?-SmEV zeob_4AsT70rU1z^44|>PBY>MB1oE&9dPGhkQ7WOQze2#}SiT0X4eA8xQ$VZfP-A`B z+yq!zu4jX^w^7fhLiQkLHnFl&v14A>(7?vRvdSy^?+z-H1nz+gtA+^T>^8&VP?mh- z;|;J#2ST3d>Y^j*(;NxkJ&t3_{P!=8`HC4up(Zq5VUj9ZIrWpz?T=w>2fhe3;KXR4Cd7&Da&AVL=1mq)aQ&fE^qyr!ymT@PvqF>6Q2nW& zC(Wd%`yEm(8Xe89dJn=C#;)zs4ziz-hS=S;%{&zC#IF-SN-@LYF_bE@7WAT&IVjD% zvam6dAu@%xnER?VOyH+1f+?XfLf-iX)9Tt-4_N}ql~uw&zkqZ>eEPrw&HtuTaN3jr z_1N;0CsSayu{vs0iS+^HeOYT#u zUeeE`vRCF)(`<#jCJ0`cjM?=XIni35YR-_lBssdCC@oC8X0AR)k_t)Yei#uopF@+7 zPj^nRvOVabD`-oQPPr;zr_5vwjQnf6aYLsEHB>asWB(9eLM28)uGjaTj@l`-0`1g1 z`4z1^eZ6$ka4m^qH4}`oY`6+f@wa_R8H6$toxt4Uu_2SR+|AiuOp=z9t15RY*?hgj z?Hozpa)Ga2=gB%H<5i0Zn`nqViv)a*14%)@i%_nJuguKTN1fixwyAPpsHP<9I(?}s z!A%iOQu?aN7*r~Oky#qficRyUq#l~;@DX0e$ij<+&YVPPXr>rG@BZ(Fdv$msB{>?& zrwSX1ZT{(Eg=!3GIwSB|)s)h7yF<>l zJ3kh(4yNfgFM}|m`Y(;1k`Tdjlkd1SPMuL4w4b7&pdgZi))vU2cny%1{u+_qCttH< zx@{3W^*`T`4v&nSBKVvjEH~T&(9SQAI6UUCggn6=q^gZz)i>=^0QM+Zo2ehR z4QV)>Mk^VnZhcttEBH5e^vP4ibXGGG_mksWRTHVz7&Yz{mq4Pj5KzZFX{{G z-HeDF9J079nOEN~z1eg+a_;{Ug<<#!RtBNcSrAyBNg(k(QAE(33NdE?OO^to(J#n8 z2qYa31&rfFb2{}Nr}a)BkA1T0>NxK1?p#4I0mP&Kyw^%A-mVv6O)++NU$AU1m86MF zdmh_9A08e)_+h6|q+GqwM^i*F>dK%2=!4l*s6f@wkUA_qO@+(wb`Ml#!;F1yW$~KH~tis#X&^lC9t3` zw0v}u=f@oeTu@j~y)yY-vyR_4cYfh|dX||fPDuuNqD+jUc>XLYHjWD91Uyw!?svb- zhtpIh_2;A~Op3XFMOKO0^X4|Trpt{p8wTb}WDQ7vIx|1u3!*-A5Ltm~v7jnSF76;M zk=CjWHu|yzg$y_L{kvr1G@0TTjzP&Dnk_6lgu(R#D!Zu8NAOFRzVPP?1N@C@jpE>i ze%x)EP_aB|1!=^tg9|u=D9M{Y7x`y|gbqUoQ*b%aya>Y|1o-5a6#AVE z+%iw0RW|tK!)CYH;3)SR>(69Rxj5CVlu&UbH@Cb58)k50GI_+DP~qQif4^oRB*u$BN*g=u$K?O?qvq zT`_E1w?~*;mwFKHP z_;G~_9~H<>%U5I558ZBg!qwt=ZXR=0(4|jL-rnb2KCjF@cg;b*|9nUd1_7OfI#Z!H zv!wp;Rd8kqf?H8J{HN^GYM&_jd?K_dJN&b^4+q6kjb>v&((ucbfO}0hKTC3+k<|P? z$4FM^CIu(bN&TWR@GG<}Bk$E~HC)lA4T_2sZxK6R+^A$*lcJa1(g9rln^T_t>l0P) zeu=|XqK?j8pJH&4N4lO+nD8)U;^;KOh=6fpCIm^1Bycr&oaG+9 zq@sN^y@_ZfE@Oyb)ZjO4QLj>q0 z6|kZd{Eq~kzmQjwZT;arfK4o<1;hVEiFA&`unN|hY6vKfz7_jpy?7d0fTCe$^^iQV zEL|Wgm}cOZM8B?EqVbJXu|FQe-(uSMAw;jyqeH?`OIk`{ipPGK*`j?Vt}|PSu0}lF z4|94u()ykIMxfHy>CG3o-z^0(U3@c_ER_7~5?Ok!P?qi9?#JpUE$Eh*#=S(l>6=p5 z3prY{$n`bP4RXx=R2C4Qj&HTuX;5bktpNr_gOx__cX+wel+(=a#q;gecKWl>D(Sk?gSCHwA^XK% zkaA6zE+VgQT@8c>sIH;02GVAK!C~F4n-&cWUZd?^%Ww!MU;z<3w(SPW9Cwaa2q__u zw2r%yj$a_YHV9+vncqx$HB>enc{OAwV1X+u(EG&}IXXFigKfrh;IDlbyV% z*rClvP{0oA?@n;X56D_O%>RiTc}0S)mH>Dq zJvyvNUks~~tJ5Y&_|}?%L*E`8w9iB3J^eusR$A+I+i_bq+04TOKZIA|3Yfe+&chw| zs*sZfUtBn?_JzaEkxR!Ag5U`>WGZ@E>bQ4V^yaZ-Vj}9;+apo`H#r?J!ua_v`_%;i zLqJYL!ztnoq!_EG2M#z#%jRYi{FFx+BO(9T{O!SP$`X!9dXkS(QRvL&VDPtK6@-0%6aiZS1Pj@<_Mmc`VR^_OYtFsy@UYCUB zzY}w6kzS(hTdI_D(LkybjyqSCJ1AbOB2bn~EB;QRI&C$l&1IDMd3EkJwSKm)rBa0^ zjz$g8<)^Ik^N_8Enj;(;^Z#O@i7QkDJ#N>@{qP7##44fpoc+oAvRM4X?T0B=@R;bS zQWoNN#`(U`v(15`QPONhW{J!CW5HLPh~H$tuK2m8n8rzuq$hDqM_CSb==9odk=2fI z`e>?{yFQfblTMo{IgZ!6=*S3cXd4Hvil8+2ky9On=tW(irmA{=A;c*TUL$&?I^C0K zL0VH1ToDB`#rR4hxsl;uP6Yvghb=WG9c$i$5C@;uN5% zbZ4txQmJO=kgA-I;w4HgA>Z{mftShe5b)=K)PmMQbOam<+{#8f zBu{5~s(R+t&pXdA?t7J|w?~|aYbAKTm4w@uS5+fp4r!Fnl}qgP*84zH>;yh;nH+`H zVgM$|CJ`e7kjUWuijGY1wf2HQn;{{N-QCX+S_&iq`=$NX^q4$}q(6$37AsVNDd`qu z2uC5M-H@(1n|Ilmt#>`Nf?a@!0?l46wD%nmT!&i|2K}RRkXuYmO^vLa+$mAVDUr?I zkoNgi6=rAioZi#B@1lR4Y?x!F=uNETIT^nzZEXqsoXyJAW`DCWgPmrL%hTkOWP^Ej zeU2+yjFMwfCuZQJQsuYN`x7RVgTvf_YP+%B4C>l{rHJt0D0G5U6^|f6IHOrdVGpB9 z=8uCD9ws#((ZfOS2i;Lq>@<~OHup_~m0ZiqO$zaOBH60wrWe3j>zyR4CM93`roK7G z?E2;Gd;OtZEGZwdK1qd_-&Fk3A{D`{oD21ccR^IGgWgw=;M>V{6GvwT+&``^ii3?uKI6?O7qqIJdGanpN^Q~*MfxsUrhOI>nys=nQ{{`LJpc#u@TN|Dj`Gdxcp6%XY2PJ_w>{d^lkm{u zO~Q66hfz+88(;*N{F*BFMSa8WmqpuN0>!3iWOEzNK%9~i{l>ud)OlhU&w}hw}AlhW1T2T@>VYE9;geDKgpG`v@KJz(IeameO_iSBmtD8M;}x zUl=C-RI*27RnquNMeTL|5i*nvlJy}6ZxEq^buWzq-J2zTef&RFT;kWh3pS$~m))*=$6p~Z-dgAh}O7oMi{&_&IA#h5cKBVtQt0iMpE0lru z(@gO#GtEa`pr-#2U0>2BdG&$nK6j5hJeb;Yo@1r)3rZ@gONn2>u44p8p6@-vOTTRG zU#~Pj-AlTeB#7FoR*_S8e}pdCX+MIQzePvU-z8B`f+u}gMYyfgyXSyVBq6Z&g@vhO ziB6Yem6y+9o@;+R&qo#o-CcP=0;&g6#|)uPEi4d1 zT1{8(W*Xvoa0y!`p1^3D1aTG$|6RTWhGc1ie=5Ee)0e5Wm-vK)>nM6RFuxyAv})KY zOZ#%S3=t}WC0t@ojAQpQ^bCH-J(fg|O$hPt?SDEHklImZ(@P0rJoM`R^)ed6-`s;a zcPOC=t&*PFKLa-GC0$H%54fp{$6N`@-?`O@KI^BG%X`HYVPEDbuE-_NQ&H+#s>Mp` zw5>UPqlk%wUdd&M-?=a*%E#;s+d>js)KT?AO@Vu55e-i^@lLoi14&W(4jv0Ns(9Yf zzKO9;aC*B?F$W8AT;PXkkxUs?Xpp;Cxb<-BSk&4KHgvy-5mQVR8VnK#Uk<9Yf0@>N z2$XS|bZL#6Kn2Fd1p#Wr4I50tA(Ud&n8Pi_A*=8bxa&1xEO~ z?p%PdxTe4?bUq@6tRo#~wAg}si0hqho2Id`W5fD67z{_j>?Y=Ho$zGfLuy$v>!pEc zDXuX{hNzG2AQtgO&x5j;!oa4DF|LyF)#VMpUw)gOKm{drUW@bO`k-jC_DH4Wb#e)n zagBz!OH|R}+oU3d+;6Vc8099a1WR>`T;)lLvF+_zjJTfQ>ge_K!;EUP!1f|QXV_$= zz`o9)OpzYvXdT)<7q;Yk2UcS0+65neXgrqMXC`KnXN~0@$^-^HhLx#~Vw&&wFZRRK z#a0Nx)Lx+8R%2YfRQ9qSFqsWOyX~(d2>HD~SePnXD5(y+*9ea#;MHClJ|4-Q6P@}2 zo67Hju#3|P73K4*&uWWW4RTmZ)>Q6OjDc;BFIFz0e|%l^)Iemj)L7vj+@6Wnp=>`! zYf(BIF-mbvwb-w;c^z)1_W9Je zSV)35UFZ|z<7*zqC;zGg{(x8;>-!*UEC|MAgmrr?Ya6Ip`0^lQQ)mq?kN|{ftI~f%%KX8O4f}CKuIaX73CC-< zrnx8#3&`x4r-&)K1Fk+qklObIzLqU8^I5t-d#rXsS0MS4KJG|hhkt;)yt~MIz2|+O zs^;cjW`gGgz1}=$U=GuA({VK~%?uTbKc7O$EmSJbm?01%uzMVqCmjoERitI8t(GKpuGEh>yA2`x36mwzBXSCj zjr48b&zS6QdRZAc%$7*$a2+hpG=y5$eED);Zw)0M(DrOM-ZQgN!@1|)C1_)4>AV~~ zXtZda)PN?pxZhy2z4$V1cDWX9pVP*ptvp!0kRJ~cY2))v zm#&B5%-bCn}{#nGgh7sS5$xDg@3@s!*c^&A)JRvY;WJbeK_}d8oPa5dGv+7n*$}GPnjfgLDTZ@1uV;#$& zBM!lt@!hWxQ577aaxLmD(h3THi&cBO4ffMYdek;#q^y_ z1;*}s#B~cZu6Uh)hN(8g+((KF{XV@_d|QM>k!UtbX}&XQr65_RfFu^;&Yn{`h59{s zPkP=YHa(-11BQYLrVrW3%Yw3cjdAcGzM@OqJ~*{3%%5+QL)XYWJZ;q9o*vhXEORuAMktJPwg|rw4U9u zLYsWSOtwUsQ?Z%(5T2yAAE>3>>;<#@SkB#cxMx!IL#~~;EHQ&eTqn=%G zpv1wvJsjA>*eCega!dB_G&1{Ai;_E&aF@J@#$JC?+K4v+JZqeOc-8kl*a8lTJAU)LlJQ*?CyXx!8b%#8q z!t|Y7A9Wl$_#FY);f50r1J>~QvKcOXv`L=5+e>9>nC&>Y=04>XN+g=8eM(D}VoX00 zmj*doeNQ~K^ri`ufS_9*V=){L_#ZF)LqslX0B86V(}z?`mt#=t>4o`Xrct|KVn%8g zQnBa-84~=oFP1MQiQc^Jz*ZQW1^tzDlkDtznEVuRwok|2c|xz-&$7cFEDKV$eQ5u8 zm#Lw`zH5&XUS5oP&WOD#c9#9D(Io^bj=G5HCwIxViYT?VcVTRTnAiF&19bAFC_(<; zNCk3g8?>3?qzkm^B8w#u9MfkE2C_ORjTtdCQL-`MYhgBQIP3;^t0$ z#5v@m$fy|CI&WtFJ=wvLS!}mNF!%1cTgW)9#I&F)9i^5T{t03>Eb43CoLUzrH@_Op zZrb(N-^6y8{%Y9D4Bieht}T0o&Bwru=UhpAPMdK(mLYT*T59@dk5N6ZWf+Y`F06{v7Z^JuoQ1t3s#VESU z8kVK`Uw>CBvIVmQ{c*=D$e#gjpkmq|f4)JEt8g%T=wJRPaO|XLohQ!C{kLi|HOs-< zNkRjT*@u0f#|j8Wbgsikh=hdXTU69}4!T!}-b1h62EfK#yoTw_6!5?&I!72Rh?o8N z5jb8By!NY2o}V7ug;$)l&3XP^MT{325nFGos$hriOKKrcdG^%sA#o^~@`=Z zUfM28PI3X>|Gf*S#I3hEpB(-z^J>_}`6`)6`uh5AfKr9rIT%O#Z{7EA2?SE#r=TMw zL%`$e2SO>^yLTe;QP(l&@W3!)%vy}Lx;YwjP}=-|G+kv_6z|stL?om`Bqfwar3IwB zyGv3!m+lVfZlrsur8}j&yQRD9o%Q$rzj$4IaAtPmdCs}d9e{sjunP+VD{yps(=65s z7HgzFTgPtH^Uh8p+qzG2ag?!x4i1i%^WIYf$brERj=#zPWZwBQysAVTc|A(DFSjOv zJVV1S-d}<(fM!ZBBMz%6i45Od@zC+BAZwzM1?!@r5l#7@DLz4N?zq27`%xO|`jAh- zy-G((OJ-P9rTe=$OfkmAUZrHIG6Lp7vfzRkNrP;iOfyeh=HK@!y`2$~mPh(Y$*!QJF45xM;r!U74m@2_y4?x(dy(Qa9Ht=YcZ#u3_+ z(1?Fjb+?z~Y>?8_Yy!fpkmo#?v$qDA#%HYZ(E7K9k;w&yn9G@qaD7Qynjj7_`aPXT z_Cf|Ep{_e$ncG5@i`I_}Wn98Fl!$o&KB`7VgbhlGq`2K{yq)GvS0qgH9tKKl0^AAd z-YX4G@rp7@Q)@Pe6paB^XknNbMQZ+1@jWJ`qbcfp`Q1_tmvBBlT;oKU_>|L6Qy951 zpMW(W6l7`}E!Hf?y^d!aDtcepz$rh1b7Z`YYhtv(_w}I{(bkoe`IkOuwMJ-dPxlg{-oTLNtZY55Ue`= z`z#qz|7~|s3RuVijQ8Pur4T{PxdgGmdslqI_YU#C8ycb7ZlZDb$nAej@DCNM$8qje z>aS1vR|Rf9Ba8bo?005YgA>mxZKqzNaLW&1oG5#}M^#g|h;DDWEyetRbMm3ou-i{9 zJN=b`AYd%yve`k<)MeTIU4L{`buie6r{|M|DUZi}*6ux`=VQ`vTppuC(VKaXt}7u< zC7+|az7h_8&>8IzQMQH%{1Pm#IQ7hqxgf_(Z-#bP#+tx;?{!RN?}ogXk1Su-F77^S zHAF_+DoZ`&wSh0}@=$wrvCz`LNi7CzVrYH2@fGYnuvk%54 z2^arh1?^Hg*9&<=u4 zrRSSOWurhcY%|FtOUTKfQ(h8g=db7N5Y_rsS*}@y_4e!nySuTr7s&U42q0?~ww48R zXlpO?_#6R*#QXax&z0%vp3^n&g}#Aso|#o}g7)#T{!K+&Bm;xv#Cq{NJ`>eZbBxX(tOq9u(3~7-+|-H7s2hjNIi(Muw`}S*AgkWADrtwL@{if~+HbeK%38&XB=Y)?+ z1=(YVv05B+c5fmXQjX`ge)Tu`iXYMw(mk~-3)3O?3r5;=7@Y%tiHqEy55B9FSdAQ? zAD&)FuH|<`kA5qgkU{vtTA3jCO84#={<<+wWUssWyRLEkj+6pa1+2I1XD-yCQTsBe zFup&8{#d>fO06NolLhLZE|QzqM8HKt>Q{HyfBp(CSoNnE4{ZC6vdrhad@SHk9-LKG z`i7Dm<6Juk=6C*+7DsIxs`R}YeFh&w>Q!ZLlAOgj{<^Ey-YCrPLa#KwoD-T^lcwuH z14<1I072P2^Vj$5P5Nm%(T5cRG__CTi+ya5Yx(m@aSCh%o9dQ!dMq}$_2?Y z_)2e>*(-sI?+IZ$Fo;%*E%iL8HTIC|XG0_>5=I1jcraQjfQ>g@4FKp_4WOJ6&sI7U zQDyw(DJOo>BKRfbVTt0O1E0GP$oaun-hTq2a?hUq?5ffAVNPUmiKVx(t!22Ci~PXe zyDrj_J|onGUGI9F zv3|m1UvZ|$d|2B3dvZb*+kd+K*(+HVaB7D-D6a@IxBRa5??YZgE)boL7UaQx1ua?t@-HJ{WF){=9@(9%G@y(XhtB8#%SBHBBke#L_<)ZH ze|u=cJNWXv`jRR}*$E8UL?Ig6vM-micgw3!%TBp7lR#;^G zdY)XHZeS=6WK~OFK2Su9(Rdi8wp_Q~$QV-n{EsA^BR`L*&oPoZJ37()1n^aboj@2d&cn70 z;0qeTb$t4|0y<+65fQ;j{dYSV7*k;q;$i^9$3-z37l7g;TcorxE=rmQxR66RVt|Kw z+T9&6Hag~n)`o*^kCOXWoIt=A%IA^xOWL=Nokvvb)0sS@P$N?)NDWXOZUHuzXp7En zqUT;Bhu1SV0Kc&SA)U~azFnx7J3w~;(iV=0@AB#^UmXC@GGKtJyzy1_6Afi`>~4`; zMocBdcbSG||-m-q;XZ0 zYt_6(5S4O5ttkE!`TdT5xuu$sj(#Z31R|G*X>1uKPK8wGgnh-0_vNcghF)>uoPvEU z(TBfHJl{uX4VL#mH`E$oIlkp|t!2@G_uaxh`V~>=+uLA~WMi0Au{*m~;CV}FUv0*g z8_+-#BS|MgT&x`HP$}Vb(p*9*CEF}x^J(|u&ddx!v~W_H?AvIoimVFH2b>XReEG>h zQvBktQ{a6eb(Qob4LV}&V<`*YcQ4Pc?e0Pc5zI?y02+0$h;ruW$mj$Y*mznqDWiQ~ z!WyBQ5D|ILrP-x@VDELg6`_N!4#t|2~d#uTksGDSEsofR$J|h8794YVKT4xfrX`4dAm$ z#||wJc*L6Zj_rk1$C+#L^6+iG39jB9k-so3)=ElN(hUYG7OJnMy^>^z%-VaUW1Bf zEy&`Gbe)y&=zX%h=8O#!8|kQ0ZN(@lqYFzS#rqX`JtG?O(n=_YMx`p!XbU$NSkz16 z_LAj2ctFn}4Mn4#-G*sOk5?_NE~POkCb~f;by0CjMuB9>ODsrPZG(Chx(w#Z=7zJB z#LLImozGT_Kx;cdLeN!MR)2uvq~*R4Mi6YL+`j(v3;fN5@Pa@b7f^S z3wj*gHybn51wJYNxK7ZIS!Vd!yxADf8aQwEnJ+ilYJHUdq`i?v{8KD6MBrcUj_mW6 zEL1@ODYH@pzA=CT@X}5C*g@*Ny3y|Q>JdO$j=31UU)ul+4jnJct0m{n@S57pU25gImzl*?l(zVJ$xmMLPICn%gBYaUaPD)}kMd=s{jLv6L zp-27DAF^&Y3TPjGe?X^Qf=V@m^Qg*4o(8)j z^w*(+$MfYX$o|rwQzqfv?%kno8U>E+=jM-0RHify<=^Dg6PBt<6pQ>U32Rh8Nb<9T?NQUpw)x4$ zLsR{^1W0Ricw}OFaub`C_gYf7TTST|r%I!QW^ecM=s|6N|I<-T+_Y5i`|5PZZ&{a> z*$%f`w`7@xE-d)}&Y({7ac6=>RMz6ko($d|`;~Ox)lz3DIPz)X(c+47C{6rd?d+ku|7eRhq*Bb2^OnJ5w~7qZhK4m3E7 zksoK3da+BFr-}~~R%1Krv9@Upm+90t%?y`~9TJOQT--8@4ei%Ga@TTo8d$58ihn2k zlfRvcn;4UCRQI*2gPh=fJ z<&onH7v>kXI^UbWpcFQN@|UZml<}#RsoVUhs)o@Pu?7#f)bUb7=0${OPG?>4Y=`x; z=!SG!z3KQTk@=~GEK@YTgHCXhb1a z2>j}8FT3+;$D6x&-8)<~B902nQ{*)uV0fK5^X~2D=H}r71ceM9n1-ZryTm|qd4Rm` zZnr;NzEEN3d2}RotwCP|4fx;Uv>S+3+6S#C}RO7n&{?F&_AY~c0u|8gdkNB*K8md3vRGYkl)Q#eWp ze2PNsIkp*=(P7lVKH35r#e6NLyM^@Ws{4Al%)xSL-l7+D??$Se%e7r%Xuh-eTMUtQ zCzMFmz)wrJDo^sw8QG~rBBiA>1mUN8^Azdu`_%=0s1oN2;VJvrz%YN8G%J=ob15@Z zVB9H6P=W=S8--qgL3i%0Odcx*yNNnUWSDsMpDW@jn0DVeWpa3-nS0E3A>{vvkuv$y zbdTSDx%ExpcZEWbl3jAA#=EboOvv6v{o-b7Mi}!-!(yW&5VzYG1HJngY}KSqk#i(FgsV}vjz-bEmxAJ{r)kP5&db&;3z;1 zOU8hXAbCe8!=rnk3^=m$3d7cMqv6cfNPgAfP=51+XK z^#wCG_gg-CyiF*{0}6}Z4X-{*LuHiD{k(Tn$B{0gQ1S?Xh!0Ria(C`c7Jth5*DOf? zgS!e2%w^6=e&2?E~XZO~rDt~c!l+6N??!+H&s830F)yu%|)u(aJuq9vji z@;=Kcc0TX5rIIOzTLdPrlLcV8eSqGzH_s|48<}zh#zz=$5LN$+5d78B5xcYmwsa<` z|I|}ih!Y2+S&8(Lq0#Y*<1HyLGLp*i)utc&S`|MogV@10ZG6Lj)!d;*XF%ac2|%os z8LyJYVO7PmDum>m@fzXP(={kCRNpD{7f6im2}-zO`o1&P*|gx(raX>xuyZif(%zR4 ze@%T8VU+?ORY8n!T?n@?k~h>Y7cCz-XMb`UiCF8oRN9mu)n=+1 zww%-c&pVd1v`jry@nKIKx;oq83|n1NO^BtLhe3G^2D7EeHBiBB)^Acx6J9tAVGt$R zHxccr{eh^%37~3lD2tzK5jYX1NhEmGtq6Q5y{^pL7H5k60SLYGI@4N>h_s&6VP4b3 z9l*%3(jKBpB5->gMj6@nyjSk_u>BEnTrJ-T(1-b2HZ`+xuDg2AIy8!Mcr zl+i0KvcU0arPl=wx`_o3;WeWdH!-{`w~+ zh25K+o5T6)-WM@L?4KUdV35QYnU}L*I<&V)y z2w|_fJ3Kfks{OR>Kew{7B~qE(qE76O@xtq7O+wjkyL#hUb z0em8*7{**rWt07?sO+k$vJ*(TmDkm{fVsrD;f?f=!X5vV{=KHUa@)|rQ2Efv{ga-# z;+%L_LD+|I5grF(Ht_tT3$t#ccB3Ohi%&Ug>8UBIA1iTNnE?C_>NtmJHSK(@G#MYt zK-aa&lk+Mm!9s)IfO`>xE z=xSZ&4p-oIu+r8K{6jUi^~$6ju=+T-*pfd z>f;W(3*f$s-VUv%&Z)dQp%i<7AKNi8fdvB;wr!xRB;)4?ua^_>9z1~b^m#pb#aJoo z(yVr-I|tfiizf27kL`U$kXZ(wz{2u!sjX)|K2qG1_+xONty6uoMzx^DqCr2++*RS@ zGj&O^8ND_?940dBw|UVdnJ|J;`J|I=4yb}?FYySg6FKa!Sz4!)_*^ZMBZ(~^=YWu| zw}F~{m-)bbooyB^gUr#&sljL6~NCF`WtHJ5Bn^hYAe`oGQZFGQ#<({MkMho|Lc@VUJvF$*_+Y*++eh zmwj`w?t)Iu*INZE4aXl5zoIb2sc}T62P3zG)#0i2jTZQfHlQZ*ay)4KEHvw(gUNUr;-xWI`X%kP*(h2L1w-h{W(x^S4*2L8aqj) z1rIZL6C2L0LzblpJTkmiXPmaLZQ;mLGUR)vz1$BSMi9b1Iv9#z7-U0{-q#$B#pCqk+H^!a};z5C|6G#Tn1mFE6hs0FS;4sGvxrB2lEE!J~K` z(;y5PI#4!KK`JQSQQg67IQQF)AJAmTo#WyZ;>ZWGt&G_Qn`sEK#0y#?N+3mt=iJJw zk@;qr;6+MB>8B)&ICIm$#VK>;gV%U7#Qs>8iuxvaMYGcvGxmd0JU7iVrLQ|>?vMQ- zjqR#0vp4QW8PsJTAbL1^+uydCSq7TxYx$NHM^oDscvcaOU(Xzy0GtD8UYz?D1?hUn z8`4}IFm_naEfkq1eHtenpPhZf*P_!0(%v`&8Y_Q5AB;bG5x0iIuSAQhp*fA%1YK{x zELkNX(RVS(mrMr>k%RA$OE;-x?#VZlOF$7Mv)LGpj6so^r>Gn-XvE)&+-m{0HAL)( z0HQ_H!0#M04Q~Ug8tOm=^1R(ibD8wm0vS5CxIrV4NSwd#iL4}$05iQo9?;tCLIlME zqUkH%H`KL-eX1L{2xvrC(u}2&)DDp}DF&+bCc42szw;421=gmC1JR1*I|R;Ddi#Pr zqDi@WBQOb+bd?KB9rUKzev;gY*98uZV22jT-z_ytH{kQ9lVcvfUlv_#6_h53Q~l9c zD>@z(b2iTC+804>M@IRRSe_y&pbWW7KGFlQM(oTOmz-*vu5ok>hnPta{$)e#BlHU` z;ZRnPVP6nSj4tO$?=qX;(hh2f;w4{sa-+B;Rl0x~Yta3!BOz{0K5+Ykp)*@MXZMc| z$nLjsthyMsl`;jr?*}58F|D19%fh(M;QU!Nm<7(ppVP;F?dD5w$|BMa!XAzVhl`_Z zkZX<=57gYmm|TNWf__SJZBCG<{3Ngu?_bjJnIVG^2?(%}W1HPE3^HBev7V<{)Zydv z?wij_LW;rC4sZ{UKmH05oonXU<56p4@?JvCt!DbtvU@A;#iHCk%dYMiZ$S05SFi&dM}KqGc#0t+pcO{< z97+T*7E5f20(Il2V$G$whoWnIF1^_}8zHzijPVFm&?p$_dAY6K)grI^UA760F64)9 zQ)?4*r_T3I@-gr>zl696cjql8gvThcoH`R6RK_{s{({<+*cF6+Q6%dT8VS7GILNPo z$V4F9RXL+lA`c4?m9%w$9|yoT`%^THjZ@S~oCgO7?q^}Txj8w0H^8*>-U|9!<6F@U z!6&RI*bteh{;!lE!)Nw^{HqfR0leb7+sy9J69BgS04T{oO)&|KrNK`N;D5FfRH?(~ zOc2pYl-2#yi{dtm!&c_YAw@0hb zmHje0aMlI_VVIAHuXh=;G zC}@AN_`&t|<2_k*IGTm#0Ff z@fMCjy48*{X0M;lIb(m>)zQ`0by?nh8xh!62?|seWe|s?bUu+Nl0F7tNJ$r>N5h2K zPm0Z&I#T!xF|jj;92AdqQBjp+#AKXj8O-AqHPB6k7Uygop0hA%D6puD{g^f2p*n^f zB9l!$E)=~^V62-wEI@z_fV|$1NLh6q-m&X7u>9_#j4cqQbIBDg^KsVZytvDh=HvF& zHv!OaVEF4!E9LRr133tjm@1^BnknjnH!8uvb5(KrkXENm#QwJ=QdmZ~C9AHi+%Ub5 zW0}TuKGwOKZ1J5m!)Vm!!fO>2Q!JJF-KnLj8JiNkVK(PH5RjWHj3!q+CuC5prjvQ| zjq{C~l(9p|#sWE+Y?-8jguotdaYWAFYQ@;N#1e_`H)*s#K8va~W$fGx~Xjv+h4HU zx`KtBSsGG2bFmj9Ntyja*VFI55;Cnkqv{GM9rq>kD4STMrBQsNbkixcj!xqnV*A&W zm4O2oV@g(c&={#@ULqcJP_retd&CMc5z8o6)`7_2@1|dKmmRB?;Falw=gySJqA02f zL$nv~aK`n+qjtKN2N@JqtvPk9-g6b#Vqxacp$D*XT@G#=ayxXV~sc&$*@Re7II zouEZ2u_qLLGfTdK+&+XJtV5nX*|bQ3w_dB&J-O}W=B0I_JU6cS@qF+tDk^K93gCqs z4x~oyjXNEootFeRmz9J+dyR7FNA7FdhE4as6O-{2PJ~q>Jy;(!n(iZm5jY)PaSePq zIcd=`?+FKQznt%lUThhjo|<@;{pqaprAli&BDZcck6b8cKO3MyF61|@rQWzPhxRvt zsZ{lE*zwC_mzjJ(=R?apK^wqUt!Q#=A@SOhK^~1rg}Crl_l9i*(JWClN`ExA)5E6< zn2{CGaWO)aSogQmZ@&^1u)=ydJX9e3!H5ON&5D)36&NS4LZ$0~dlVnTEILYyE)@`t z%g8v5Xg(4dCW+M9Vi1aFM=5ES$rSD5-|>t=Av$Vd&H|LThRhD#b)+!?7(^@R27R*Z zdHzDG>`zaAH9w6=PCP>7+U`H>H;g$I?2E0G%n!L=nR^CpG`Ms|`*S8?%SkM#LF{4? zEs4t)cXB#qUg`=ec&E}>WS=h@!Gf7fZN6fB7dP*pb&WfFu9wcFY@w! z!2M}LIN_Y3xFy-KbDV@Aa$qr+j>e8~|BPYUQ3O3hATrp=XvZkwV*m5mn+?!4k;*|~ zT#P%5go6->oR~%>AS>gRZTr#_V7vfcM@5ft@@Nz8_MozY%@|gjPTxXE*cOzB43JvW8}lW zktLT=Wz?(!rwkt-&rIx_h;`Ei;3zuOLmjXB;+Vjy46XLh%KFQG(li~Rfk;mfoJNCWi2vG--|6q;#H|(@} zqnLx;Y`-T&Te81emcK?9bxTf~(q=JGZUN#QzQL5|%V~-MvIltDGqdF;RE$wYMMlh1 zIwmKWR~h0o{X#ho#Bzh&F}iX*y68~rk_tOu!;TFiaSe8A-XsP#)dV2P_{v{^Olx)< z>KX@)+!+Ss+@+*;4;Y~z{O|n`VFW&Oj<>_m@EMT8_Q3+wox8k4VA>h#w2P*nYdFsb#ZPFbL}-WdlT|n-6O!N+@LtxZ%xQZT#x}o}6wj+_ z&zAI>-g)J8h9dDcf-5>|%XXJn;MoePUHt z3YI(RB{$1K%3S@UOrw=%6au{2{kJ+6?bYViwjsZZwZXm}6Ws-Gw@D7X%oVY+{6t^k z(Gv67s*VE7{ELIdhZNyV5xz#^n)J(dbIao~$Okv0P5AJ#kdj7Pf%cX;o>uWT5sl^Y zk_DMY@;d;ed5BnTG#S2^ab%@ctjH~hKUC|xtl^p`$UR7G)9KV;k?%U*0_1~G54mlC z+5v3_wg6&|R=tf6kjZ`l=<8z)`lf;l|J4qU+FOux(3hoaj);pCS)G3cgdSqAl-@E4 zBAN5*!%ANO%DdZ!%!hA4-vEtDY_M5}18lne8zTSxe?6e+u!?TndDrt_jdRS0_`}n% zF&r^KfCz9s4ph-Js#dpHY$Y%qtDkGEFY!qzxT1j`tAn3mu42kaXRk$-zkD*a%(igxM^{?V#(Rv9|e0X5-zc zoARvXm1(ML)DG9Gj3$L;RC?pn{qv5rECr%WHR!uhSElEI{g{h&H$rCZW}s|W;!Ypr z4*ZcITXxZuLT^!=YE6gwp|;jM7nRc~sy0veB%gFp=7#-Gx$$D^#Rs_kB$(gnf-mmM zZ9b?S(wJyLXU%KD7J-YI1(}{HP|F3l_6zO|_j7TmeMl^wYWeA$L8L7JVjUs=SFGv| zAp=cVrKXCWbc?G`!cMTWSh-f?ug${fPUHM?Ig})a)Qq(3ov;k?kM#{JP=o85}msXP` zV+z`;0SU7%_PNWdLAf$&jmosGc(7jz62EA(5M^n`+V&-rx%w5)hmUU-Lvbu15oIIN z7i(h``o4-K=i3*G-S*O$FtA*ZKN;gs5+CgclqaxFh1AM+Gva+f)6o?sMrybBySS*Z zXLv{oWuqC2+eM=-Qq4KmnmE4EGu(N_3o0mkltBm&AtA;=jWM4`Wbd=9w-Ze8=edBI zZ?-6An0{ksn#rCCg++po;X=zcqz43v2#_@YH4O=NRygmu`qs(|u8qAOAi!Nz0Enf` z_&0@H(@dGE=Qj)hs?pfkC{|O5=4DclU#L9&z{T~Qf4PXAGglhE;tRWULw0RuviJ+c z-#cV5u>$h^wV`!jErUlR#Ue_0HW)` z!C`n2|LgNgoYhRN3&??oCD3I}KWG->sEr(~I>B*O`ztCBYV9PtJeT}c{xxEgAg1=T ze44jKe$Y_05H8;D^D{y~aZ1>m>y2-^q%H~>0bK$*J zN56o2bu0lfBTGQ`D%8StYv?^IUym#iID)be4LO%kWM-P@n6^B}t4Ft|gsYyF5b_%q z(PA-AVP*k0+_OprVrz!E%H!Rr`0?;IlOLwpH6Ebbb4^O`vl8~zrnLFi-Y8F>y#9w} z5E#P^+DINI1Z@DUIn59bioEVKcq*9^Oc=p+jDpd$E9t-fonO(2$Fniu3PuowPGWpx zO{PBHg$Sihnmk753Q-S3Fn<_ zl$AL{#=4-E{G})2Rp`!)1p@jtZ8T{BMmL4;8TNjcr?F*nm{qimRJsU28A@CNZuh==TYMQ4?>7b zKmW`E@_9}CW-p4EoSTS_BBWI$AY!gY912FTmh7zaRITg+ij8TsV0bPL~c`o)Cuerq}YKH z?qTX$bXwnmyE7yIZ#FQf1x5N%O+CbFXm3aiDdhNzi_??jm`Js#u#ixsTkwN-%W;Cs z^Zy3(5!-O~d4Ni*t5aM3_FIPhbL#z`9luWpiuKnE8{L0wQ{1Rx($;oYK=S@qx*d})W(MnH;{^*}HYN#A>8oX!F3HX9J-7%{t?qV1)!cpKo2F$`YVO5r zo~PuK@xL9)&4=VKr=)0EH|Q{AqEA1%p&NHyU~)Ut64sULGJ7x+bkNdqx?rH9_jGvy z4ChWGpT~JOprUO{OG~ItPyPPs(?(C2gHs7zs4hx&x`)s!PboeD%5fjMDbk?Ys5AWE zDo;Vh2u$O`99WlTrCBW{ks04nGxa##5cUsAmA#bavcX;{YKgckUIB_D*heI9)0XVg znbKc%`HXgz^EUhg3Sj>M1&)Js{{Jcs{Kq6*wWiqJOs@=C_YG{HSQ38sQ$NxzpuCwf z0wNXuag3pkd4K;>KisgZ*tuo&0YJxm6T9BVALwrkT*UczM6KBq-TwbaWFpmlAZ~j{ zN83R7<_(Bf5cO>#IE#I9ad8l^XvqEfTP}FE6s^>mcDdyCq4Sm`{p%Vq5882VG{3blrVU6`6OE^iwvDKq&K zfqd%x(hv*78TD{0mc^pJkyS`a9_MEnhSAAsx@p{l01(@`DY@;mlaz}=bOahGiu{N& zpi${@3Py=p5&*V2=5(m}%@wYMe^?G-h7{j17{xrUy$(w<7W4!~2uTfF{{UqOR$BES zyh}~oiQ!1t*K11A&MOnVI(m&7bYvwheK4>7XPAxv3;BYkxW_mX8?J8S2E0C9qUCCv ze4SxwGKv_is`As?P6jDT>sQ z1Dwg4+9rSU;#ljFjWxAKgKK2NcbA6>j!*nnMlB-L)q0(8)a`wQy1gDBH1vO@CgQzlC1C21u{*sD5CB2@DHFa>1P>Ifr zS7kvhyCARpGE$jcx{5Lia~grF&KGxrHa4!*2sv)h>^pe-iRbr{Mm&meV)=G{7OH@p zdTO5X0ho!<{ICo;TLHB3ys^)%fHI+_mR`WVv`c4SSL;)DAKgb+Zcs*bN!u&JDJcCg zP{TYZHotTaL*oK+@pBL#KIt-eZas7Tf(?8eXJ@v(eSM%i(HNP6Z(h&Mj3<9?Z#fEN z?mRaCRrWSq`kyM^)^%H{1Ng!gP3Go$cs_fW=~ zMrc&%T)X|6A}ZaV49{G<+Tlooc=L-UrEor%8r#|t{xdv<+joRMWs{|{BVziGjlpIk zk$q^5zlf*P>VrN~1xAi>H^@~pFg{&fbh8F+01#WB5B31xJF<$4Z*5)IOU3T)Ct2XlAQG75zhUlD+!4Ma3aYB#CNz zifS2hu**K=<_YpOj2i(C~P@nj@p1a*B0I z>~;>-^Rz!-IbvHL z9rToh0m7jW5@F(f-_~)8P!+Jo&{lO#$fp+|M_|>H!&AU=wm+T`4dO_9q#@DYEs{Lb zvfmAq;i3Pp5JZNo->6RNd5{2o#?hCvIpw_wc=5BdrfFl>3?j5qV%b+GcA>k%4 zthVAjU+CW4NA8-1t8BQ#NDZfTrV6jEQS_TrPgEdp`S9js&6VUB?SXq<&5h>OA*TKy z-V5j>OZnbv0F@uu2)gB^c1Z#Kc?f_fLjMH#6FsHvjUKm9x`Nj&`il=#N^E3f69p9G zi2!-@47ju207zhe?_jVENMrH}M76^a!{ar9sXCzCS<7l{yo2myE=_kv=R8m6DRiDl zMO3EAsajf9p8J_lYd<$KUL+X!vOh015Pxcg;f5dGBZrxPf4lW^;mi1{qBVM>|K^z< zbNK32`;AvcZ(pYN+qCOziIT_hf(&F9s(9(Mm)6l+a%SMlN#8w_Ea=t4y3@UamLqy! z4v_&Wb=MDO9}uAp&?`S*wLQ;5NB_Wx5sjF$8)~Tp5RJWeT>xqjf{c_n4X^-mXWn*G zIqxK!IFGumba_32UvSCbb)WWC-;;OJYlu3CFRzh_(##Wy;@je|8o7D;}a0s;qUpoECx5 z85e-e=+pbe1*mgZpRemuV|BMD@+2Q0M_;(xE+yN#3wWPQjjHSb!4V+e%BQ)KMPgqi zf<9uKRG{K~Z-qp&4dTLjTJ4_#B8yDt9bFmn3?0pU#nd2{j;?S&A8D6|mM$qlN3dST zW-)3kp>d0{5&|sQPQo?8TK3h7^%?glb#XBbdo;xwEDgy;bUcaZwU+WjTR)?v$LGB_ z7U1YoQ1`Y73N#mkgOsRNKdY*!C97OSX=kjjA!cnmHMa791e;9&4gPkpadl{Gw63AP zdKjLXnC))JSMo~BRRSyyoYBdI{RJ7snys0ltOOv;#d*^?eT0XVX(rp`Vxu#D7I-xSx${ z_%Fiz;%_67akIB>g0?A{`Kl$jt-MY>sykniiAYq4Io{dp0Tk4TGVmDpr1i-_wQk&F;#LkS%cVAh5-`RXmZ3ijz8wWz2QC zwWMI3&4_jQ3<&X^{D(piPEmPr2U>AItAtPpt0-}NOtqzOVB@q~Z5qRQ=MrYOQI`4qRTlDPfhaxG&IiZ z0c*3{{}#V`;(t6ifq~^pxP!~&>KapdMDy~kp?R)U1y&Bv^IxOJ?>YbqhCl7-6^F}? z%xXK>;u{ffo(TKffUefRy1-14{7@3b=KNBBKT`?&e^Yh z85fF0RbX0)K^n4l84ZqEEmr2QwZ0|am{*BU5Hm5z*GC~k3^<#YW5DwmN8lIuC|EBY zMzp)&zmS?813OVR&g9(w4%7NDYs)_&DE^p4W4RCu6TKam%oV-R5w@mp(Zfh5T;%T* zIoXW4a%c8ykE}3d@}(kS{jgpnQ~7hg2{ssF3Ny-DF)^FNT#dd`iR3FWI=Aa05Wszz zWG$bmTykY+=zsfz0r>|t)^Ctlq(5SS1+hSo1e2ISwD+aTWzn^lJtSC^VQ2&ZhvHF` zXCCYVY{$ejxG3RnhC7*b6%~$ zORUTQx2ZRfNPYoSS{8O)PC`B$E#+f3e z|C>hpG>$S)QimJ*sMxQ0pW_u29JtYlE<`O;he3A>AQn6T#IW>|frvDYZ65R$*GgX{ zI!ykL3y^E=uKCK4QocA&5~B+lLi8LpuZ$4#>1%*k&7 zsfbt4=jV;jw2e@};B6iAzrzA#h<`A;<7X%@3aBF$N~WP10y^M_V@3NK{#g)G(Ddy8 z5p|YvQMKXL2SgeHB?M^!rIBus5BAl(2I8YaM|cH-bdyGi&m zI)uz7B2X;Vw^%}q3Kn9}jP##=Q1IU^THk1W7@Wk0*EO^0zkqdOuu%Ad9xi--JXd&% z2b?zToA3uar&0gs1AyP^4iK`O22U%7V-fBFcK|j#_59E&bK@DsH3FRaw!5=4hI12o zX7@O#KiRf@*Mucze-tvvdcA`2iTb+wFS!p}NgK)wAXWc?00y6M-!C6Mki#!Fl)7?n z8i)(`Mcz02ULAc~SXi#xKvttm-F~{i&cwyId56(DME!Inuu{|#+1j%y!PtJ+Zi=2( zI$*Q&^Z$2iELJ zarNlBvghCt2-*Yp$m6+T8uUd%I$)86%&9-c?!&J)sK~6SVm8qmuOm?e@|6-Fyw!vK5J=8T%MP}_i_}& z{^y|@RUW@Yq8_%DkbLXnrnwH?|8CX9f;({wyFYud_k6%Kg#Q-!Vr*v3O<#X-r zd{DZcl(~ExWB>COFQg^)NOhg7hd+CB#K%FGiSchAgLh%Qf=T*~MT=ozn`*&&>HIAI zLcP??Y*iu|GR6X)BAZQgtAIdDS7JPW(~XiTBwPBzI{J=k<<%mWFCH%TGJmw9EksFT3y}zXkYCVlZ}hd z59DIba+chWE++Pd0lgEDN7km?f@cBhz?$^?3W`Z}Cz=^`dgFWfMYDpk>-meJDdZEc zIrXjnFDc3&ZDt^6lba^!`OC&Cyf-g0GixVqNx9yIEhD7u$DR^*FqTo(I9KV>5?N(y zS%SBbw)kb7Yrr$}8v6Ots=KoJfeC!R?XBzrl9eS2$Y>13w8)mtEM>zR@fU(ZTB)<_6l`)MSgy8+bRKQ6#IX^E$^KuQS@9!sAA7V2$8N|iKo17DX zL@9yglNZY;k#4KJFO*i?daMRZ_WNRPCGZ0!L!LIAQSCgs18!OJ0*~ZOez6pFDj-OB z=_Zvq{v9A#etNt*GXu>1X@ZRhua2{W$#VcVJ}}+j%vU>+h`*WsATcW<*z}g>+jRsE z!^0)vQhI5Pe97wGdp||$Yp4QzMOq~NcchW8qpNW3#wg)HlwU*yLa}B**p!5XqM!F;Y_F7t1&KflO47Z7oUxr{6p^FNF1dmFy8<_4Vb&+|O=6q-mIHsTEfK=e*o zY6cQcm!z1ohrHSRvHE&i9T>F}6PxD5l;jcYUOPoOa=Nf}|N0r8MteoLPR}A8+*2*` zD=XjZsO~-Tt_9I}{yYJ7XUUT6tQ9$~jL%I5p1f7$S+f>37CGS(gfIi$mvmflR8tdz*Z67Q z`t};0+B{P^HMG*+ksci<+?=JC{=ST0)cV9Z)M_V`Blrhn6$le0Kg%h$_Df9ZZY>v> z`=-1ihNgGpfz}N2oL%`vOM38;VuyvUI*{v%TQ>+7XW31j9td|G%J6H&iYW3!(z8}r z#RldRlaRsi%md2l{XB|qyLTd+!MiVdkn6V``*wpZHXUCf_EQMUHWno`YKxn0p<7&0 zx9eo7s`=*ERa+bixh0Ke^IntvY@Z-6wA!qQ)o)fVurrAEqk#*E3oEi_`P5mSw$Qidv!xR^Z9bEoSk}SsD$RHnX&!>w8%2LWvT8Ld*k`Geu3=t2 z{cYzDu|C<|ntJE1U_~k7v;u2Cz5GPliYwLkc7oIG=vUJL!Zy#8XsZj z0jES43+(=KyT|do{^3!N`5$C5$#(PL1%eWrLiO`fD~qIsmMr}<+7>l_xs{qhGx03K zEVwL0^iAEw%}BF_dNos{hiwq0O*NLwo3i}f+i5<0li(Vj9EX5g`IH>kZ z$v2>nvYsyF(jw*h8?XoH{)COm0!tsA9A8)J7$THp9&kAp{&>QJ@E$m3C;0~D} zxKjJ~h6B9bhc#bs@wA7=$HI|KK=Bkw4)XmzAKL19b$Sxzdw&%E_NuXwPZ&tXJ4^Dt zNxEgpI^jRq)4Sr=<%T!FYy#m!3C?DV=ZXJ{AQS?iLvk10Z!B$IhL~0P)6&q;A8_Hq zYqiIRyX4Hw_NI2N(o=W@9+2TaEO>w1T~k-5%#d(>JJUV_m!1NHsML|mNja9J?kcAF zg@p@U^>O|5e-}Fl`gbwya;^U>vM96}hk$DE@GmeB61Ttpc85coK|m+tb4leBh)5ePY3F zP@aGnbs_|CaqGWtOv0ea-|G06gH>L)iPQJ?ZxIH;isO^>gb6Zp+XB6H%=%gjbrlRI z!=Om(yi(*s8=s!vU{&16l^>-WsWug*7_J>SA)vvoI)(`Kw7ME_(1zB0>U)0=Xm2G5 zbwM85RXW$e1^GZAp;I^~9$kawLB|u!+^UvSNb2*Cfagk2`NLCY(Y&$G<@99BSFi=LxxHj*w@I zf!hMP?SXXq)XJW7o@OOz=C;&&Qq>&=`R{QaimQzONuQ55c{K_9WdkCy$yqNqiaejG z%;HumpKIun;_@e(mjGD_M7Sy!tGez7r!2VifGKk-3skYK8MB17BG||FG!&O=c_v{G z8eCbV%!Aa~2}H^$^A#?7t-1?!?L!c#)XJ2#IJBxr{lO<07+`pSm_OzHhRht3w&D~~ zamw+7@=7c%p4X9`{Ozn_2psblkp2v<^L8(qOZASsTw0p~Pf6N0PY*6a_FVl+)ZZM` zHwsUfcYA1UjzDC5@J*4duGrbw;6VVp&MEf1LjcdKsvXd8kNQ5IwftqaQ#xmEJ4-*Z z2OwEDw*kN}6sr_Ad^=e$%jk%GDOh`J2YZPgXluX@uC9)gpkBjFb9gH)YJPx+Kp!(P zqgwBZhry+nJsrCE{QXexj8UK0(M0*Jj&%(F@RZ)Fjh8gn9y$AC<=*!lPSH@aT7}&h+UTw=U46tVim!b(!VrJ0))9r)- zdzFKmCN$f-`Vso^GM^~PogT7`nwR%9i>QTy^WG7bPp!shz)o8q7!Faoi7ggqVuIjB zPS0?^p2yVFU_Ng!99;U$VND&K-#N;JO0#31Ol3owsx|N~Q56Oj6)VxbwGFBa`D9cymc>l1X^-){ z8Q2EsThq?=b{U0Z$--JRGgXY$}tc%mZU4)^z|w`s~MdKNOX%{flKwU z%T*Om_Y!3V*{9`OBukr#ezI`53&j>~0*#}kw{nql&xhh^+>7POKWp|d7>9BS2om{6 zs3!CfaN$_(y}`ov?{gJOlIFMHA%uCG_fe^i=ayjf^3z;J7GJsL5U%A51 zDR5Q?+-=!M?)k-CXv9TV&+9}IhPa=e&esrOig*eDPp5J5cC;7rs{v>>^fk;H_3<+ znalN3x2+N$Sx$QhPJE1Ba5Hy zeBtiinSFg5C{LGqCW#@N&pj)`zx8H^rL5#bi+;qW8Vi9}N_^~vaWByYbCQ+$FgK8W zYx%e3h_ump!0ef5ja)?9^XLKNIgS#kO@_^CEPxGgx-eJ&V##uosjqA`abag?Wg3vc z2wYL7ynUs&G$ZwXn$wS#_95T^%j$-CvnqUl=2V--s1ffH8)7jN_qoOUZ5#WMhTMcu zkra@tqWNyi;_E>^@+kFmzLd_-8rM5DMZi@QzK!0KDz1Zhd5&{?_^jjjn6gwWu;B|` z-&ly&R-;a$M|=AaN26e?CsdGTX8N@bLt$vcS_i&HepB-V-IrC?>@PfTxYW|sn;ZC1Pi1rYV}=lA2J zgu0YQ2lL(thAiT5@4WHWE&t|}mu^*Q{&;qp>Lj)gotNN_Gc&EaZ9zl1Iem;;qL1A4}a{jW&qs1x6{F~^wU?1K3j}T|>J%6ER>1~1tSU3luc_6o` z2O7_c(`fzUTG+Q)e*3h|9K5&pS<5P*&6W88snlDGyoozRB4y#(cbfQ7+`}DplQoKP zeO5Y*wZrYucNt^(d+Vik-i+`>w9hmz;UR|E!2TeU-=(4;)bmOB6c6s|eTdHF&5mph z^t?a7p}Ll`Og!p2KdS2;fULMb;4NSLd2_Ct_B74of^J^Ie|Mq(L1FOy&JRy8kvQ=Ji)&CleWU5-ojD0&_40!U9>dAt&jCECZ^!8U z&?ua>5ch@dCh6%^e_{c0OECr94`4hxz46LADr~m`=vz`!Q!}3Mc9{L05g<_D8MgHZ zI!-oglgr8P5B85A`l1js3>oPwETH>?f4-yZ4+Mm8SAm`O`a=gbYNhgem;-Tj+Rhnj zoA_UAq@@<9K|aPgDbRm4bwtWbaRnMq8QQ^gZ@_gyx-79WHk|o^fPW=as_Q2df9zSxw#22 z`kZk!YEFUlq!#B&smi>0HW3cVQcFe?z#;=FW@5AgrZfGave7II^2*Qs&$~FsqqRm$ zE;L^>fRA2>=53XXtJqY@c8FT}9SUD0%`|N&?uJgxw>@OB2ChypvU25HM$c=QS=2=Z zZiRb#n5HBccb{Ako^ixA2)!A2Am})qAf?rgV5k%3k%J6zslUOEe$P_9YiQHNV?V`EoWD`Nq*b@E9ib`T@Zy7TG62=`uLp(aRlyfVN8SHE}Jp-4U-O(q=sC#Q( zTwYey)Bv%#ot+>5k#!^NyaM3#+uN_w^uV#OtvguwoC;3-1+obHjoIOa@ETl$2jpBv z`Gov?`|6qhi68cVsG|ja*MCgqL}#YX7$TC^QF=#Y*-u@rP;*O1q`ZgDp9?ea(-A0bWt{Vgmh+Pv zeHvllmeBHiO%A)_bFlkN!wb-vb6O{$1Kw9@XG^(pZy(b5y|u=HMdEJ@>{<`)dhP73 zaQhp~Gfd&&NoARlhYf}Gzf*p(wXkt@0-5AyP-k*Xt1|{ryK23cvzz&z0-g)>?tzZZeMhm8irX5pW({8;LWeez_`&MTnYgs$Bk$yXJr3NJ%z1z67A1$`jj3rxi z9EoxX@|-CHJ6#fkN6NshIAlr(0zCX3fA66D()9F0nVTISp<8AOLVtfgGXyaVy^EDm z1me<;d{^ww+S?2G-L;@dh6Vy%<^0S|9wgyrq?~*@*|N*fm0=OD#%!Ibx*k( zB6+}sdau-zy&j@~ZJsJ4eg$6Lb&br3uTPW&}H zKi7vW()5J*f>e3I4alKMYTeife3s6g#A&g9q(nwjdP?1_S1WtMTw}?cmKLQb=E86h zFV?b_@2SHr@~x=%@EMq_v=L7)hxsuto+j#xeGgTwZItlsYk@0LMdLcq8Ue+V2o@Ij z1;#r)qxXgU<7w6bZz3;W)j+ehip5wT8WDT^5|}Tl+|F2%hMNbmrQE$ucv)i=%&=LkKNWo$s}H~WTJ=^V{rC0Th>;U7C_K+19b?~@Dpyb>(WINn7$CG<5s zp7;v?c?i100HSl-DBms|cC*oA2DA5Ispw5&$kAGhW3|4&P80 zmM^(|fU#4;sP~~05WfthIl+lF-^~YtCk%y+tL&j~X z^<2%ki4-SUN4Q=4Q25fL?;_TnteV+%ur+Ey?|LWrctZEVPIpdaOIKf`x(Bv0$gZpI zvB>6;08u%lJ&Ua$1y@Hdf>3Mk!Lu7WTExGrbY`Fz^EsGB-QY+)?ohzHQPu9FgOlo+ z00I8!C`eEDhYnvmi~hr>p4z8V5f*ptX?NjDrkTN2&3ouoB-w>|wGhnXbC92e*3lu5p1e@v2d7?VJ?PL1bk+&kM^#S$UnJQEFo2^+#UTeEyN(Ms^&j~7`hiH`6$hYZ*lR{O24uNO z@T|D|`SOR9b;U<`G9GE)8ZfS+gHOB!F0Xf;Zl(!^j1Gn0`%!p%`iU*&+F>@Fsis8v zE*&&HWCrK9?ECIam__0Go2v8ZX`&4Vkw$r~Jx%u@NDB-yb|c0Yz8~CVr}sHeI)eU} zIV1h=V<}nuvS)_~ucm+*9q((@>E3NgRu4RYu!1dy2B22{<@~C*--6&q9ysL_os?c^Tz)A zc7(QZqT}Cka8XyA8d>n9wie zZs@-FK_?0VXMTPIKY`7CCDr(^2*qMm9C{a+gaSl>i)MLiFI(1zNaeNw?GtCd0_V$v zg+3r^8IHri*QKWg-twZ;;-}t?_1nMgGnW-kOQJv**LAooy#^hKGv9eq@&|I zwF1pLGPTgpCF=$1*3C$}82KK}UzwnR=x|m_trz1(B#iHpLnfh1kp7oLqa*JXo(FxG zFpOyv2F=tlG0<}H*5Ud~c*V>m6HB&LuqiYuQxR%22E@l&eh9z=jSvCoDdTsdx5;V$b4j&{4s%5yy@r+R}HU2|Oq{Ge1od4%HRM@oe`otlXFX!+l}6dHqQbl;~O z9fRaa7jl$jR3=~IPRSC38v~VpXi>?z7pHzFbSsIKTVrC~68T>(KvWT?B4ZL=?d*%= z#m{sJl;gRVXZg+xb?Gm#sE~o@YSeVm=_4XSb4!YE%wOtzd2Zp&l<;M2hG#FO51hy! z+#$098jKEMU9|$~o@r1YW~AoD|K140a-JncJn50V^?=@LB}&pkM)Jkb27<7#Kh>(| z#%8bCQSq0PDH~#j4a9QmZ%$n22-RqNMj#D7vviP0vH@rzDFLi*McW`I0(yf8mEKpflhd^3LpAtUUk3^P z)z{2r&GEUFZn{H7cVVf^&r|K6z=auB$OrbxtLuavFlXZ~dBY5;;ttlAcTr%&k*fx5 z{t8a`Tw+QX)Fmupff9kucuFo*n>bf&d~KSQsV1Nz9-3zXZ^=@|76e3}R=-zWSL|b~ z%_6M5*v1o8ccbWjD=tGk@yr{!`A*jcfA282+*dm0dD6iQ^eZYAvQVox7FKc7Uzwno zwXf?PseSim4HqaauH66qPm@8e;Q)>d`)H0Dq&z~ zCPU4*)X|@;oHsD`2Jf5khf#-5@cM#rpLe3!OQkg&7hhZ0(BkGvxys!* zy1!CMQg5IaPh4A(a3O-h_*F=X$C<4w!k~nw-SI(W{gU0ck4wAuc3~ZIg-PEH-1^a#bmD%~%;jnrMdw*ENNEn(KET^<0JU+I}fT${$nPzNZ z<;W6sp>Buxb)K0b^RtnO(_b37R0D#Q8hu2kjHelv-$Ng%_%U^cuTIh%kh9ec#eSe$ zI>oV01RX>*_Qta=9+159Gmklu%a!p*qo=K|#w=?rE@%A+e3XV~(F6qufz4BmoGhHq?Xud4AcrjjCiy%-m6 zC(*7-(v)(QiSe)glVK}%#A3eMFGT(h1~y)%W@hg2vIQVc!&7-*lakVqNBy5Y4-O|P zXx8=|LxHF9!W$9yTXv6h6hO|&ue3DduV4Mf$CZGP5^`WmDLgWSw;j4^!yF8VSyCdL z#rH9#jx99Ny#1o-a+xtD6$vlDi@bJdy}?BbLYK&4*%nij2r;+A4t%SW^hE|eCWKMj zfQE#28v0l3_*2e@dRrP9rs@1yev*in5$-!u3r#<*-F;^osSnt9rmP}Q8~p&FDd*NL zG8JJM-X6@+gz6j>C<4J`-kogJJ0k-I~jIFZ+Mq%Jc&_>s8Nu<39K z-HTY|vdcnw>X`S`xKc;k*8zh78bu@oO=8D6Iz$xBmv`Ng!uS1tBJ<40BO|J)4~V!Y zGYNILV&5+N%$cTH$_@2HkDu!tP$9zUgbfktlm!TviMxntxd)IRj2#*s z)*V}-O7z|EA3sm*`}~PmZ2-J?oBGus4@8K?Jm{SIiYkY%PQ5o^xv!;H!rA@B1lgos zQ;f-*odZ25Fw0U!pCDmqZ%A*GPLmRjK;2!VC;4egDgroCIO-$i>)zmbA_=x|+^;jW z;wa9Vck_5?%{GTPLAo<9x(=)YZO`m^VdKJwZ8ggcmv^j(iE?OXDAV~J?T>ryryL?@ z9PpU)+(NVAk3Mj&Cp^y&?gnoGLK^pHb0cv5-`FNLVOjR9^_YWP=PV|5)jrk@UDfhsX43uiUDUyKmwt zpiW~vJUr-l9@I8{3m7{L&Olpp#42BFl|w*Vt1b3!aJjU4o9Me&IZ~Ifl-K9ld3$jj z3pcr}<$QR-)GcY0u|onc-YQN$%n+@%BkfRTCQd+VzXYTpjHj` zMbf8xC=GHTLw2OE_q-~E4?whOyRvS=&cHRau$oL8#ehvYy`%rW*s_@tv^x zmWLt!F>yK;*b^ZC*X;WGU-{HXrFT`F0{<^z{n(C3;He0IX0>rPKhu_o4Kwx=x8;46zb`3mo(&i1UjMrr7X z;bNfmUXoAMQ~I69%8id3qOovfX3`#g^QNZ1-U+Ka11BvN*&!J4Yp$uzlgVObLCuv1 zhIiJvtAc!;DKf}Q6!Dwm`_2wZV@YQI^%h58Y;>>-T4ng6CK^;EQ_rdz-EGRErwq~; ztD6(PnhpKFmvBg1j534r{@ti3Ti);Dk7)85XS{M;9j<(Q!3qKe@v$<7i7A(Vdy|Xf zoF)C8mv`XfoAl1gDTFyE4#0mUJ|JhsKwMbPDyI<^#^L6Qk*VQ2ynV?e~onN#$aiaq~~ac{H0eq4QcgjPE2XsR&Z*VIVM+ zol6$GcWG#d?IDmPkfcLClQs+a?1z|ZB*mv^mUjpdL!{SJm;Fo)cG6^hKeU2$e3-3L zaQ$0!3m~5`Cywk469%%L)7tUz{ekq^YRYcP!!$FIRid_`+*7?QK<>m}L7H1$6F zEF&?;eTCS5v{lm;;M~J6e1qIHRT5geh=f+Ug4XH$6}`EM4youb5!!W7onFi}2c~L@ z)iZ6%KYdHyC6)_Vs&UQ>Fd9WSWewSn{5U$SEJ|er#};#{kOXA2n(*|S9t*9mV6Cr3 zgwQ4=8Z&vkFo^`8x43y`@>DgyWQvXbm2E?%`v9<6-F9{~Sb)cgBy+S7zth25CI~5i zVxAO<&B^p#U zZIc74zu#MgsjmCFaftMYPHX7#3;Ohpj*!d~U9zUZ3$o=pGdYymL`gvI?qxWZ?xrVKc+^P*7 zl_X(CPpzk_xs6152tR7@l0(5~1l8%brpu@DSiRVdrSQEv24f+#cTkWQOh)F=YrHQ( z_SZM!7#x`Ne)+k#l&Nk6g(2c9; zUm+`V!r5l)a*r3jP6Si24b3zJ|6~Pv{_V80oNWsxXOm`DOr}$_9L-|g=koi&KAjjH zGHkVhjQp?)lzdgQo<&kmI}OyCQ8&qEVah)&+k*LZ%d*boWn=MS+9-+T9We)<>UXYh zKAvI?Nlsg1DuyMzUTK}-isFKC&HOS)&aqzjP&UM@EMpmgg8Bk%Cw(mucF+uM?5Sfg zuD0mq@5L8wRWk|Z<_XFb3Xh0r@Nakq?3^$edOT&vn@2`96UJ@mHXTGcTW9D4U-5|1 zhG!-nf6+)!!k4tu-Jgshp2g!GGxfmcoug(}$^CtKwC~oyT)Eb$V0<-i)_=k-aCLy0 znfplDMO%4-r}**{J?+=_sQx7@r(#_H{j`*mb1}9TB@qfhC^@kIZLmI_vg$_arjOK@ z0J>iwm&K)L{3Mw-De{U=A)9BfSSH>j^OSJ>rlPE=4@GxVmtM5VrBmCr)0{vrA)R$^ z7wp*I2q`4|$nrE2djPt zc@RZN8G(GxhI!n~Yd`S(YecbGe^Dc6tJTtClj{Dl3ecW_&*J#9zTF!H5QT19SMG%1 zn)?dhC!d1CLZE^d?t+i|?tR=ukBf`xA6Ic6zXOL_pdYo?w7pPg0|bwpbvBYamDQIr z>)Y*dyd7IHl6ZjK8Xof(!Eet800o(K+xOewUpojtob|53OH>cyMa@Z{?IA z@uH#3$k(!%#-qad%Oz;rurwAf$c4RpQqtKMEnLXZvxUy z8p)T(^Wr#8ZJ!>cUoySByL+@b&mA)PoKn<28CZPZEe3Mt#7awXzbMEl9ofqx@z%*L zvBZr2RWlJolTR1))5p9_3t^4@OdJ2MRavGAbCQ#*(A3t41d^CNxm7Af@Ghxvx9H;@ zMAk`_`Y`-6U!}zR65;$2<_r*N$rwv_iH5QL^*`o|_Es+XV*1%eF@ ziTlIRpE);q)B&zJ-`876GRri}sWCARzHgKLG4wYrk}>;~B#-EYtv97KVSMEHAgTCeR!(Rg$&>HUk^N7>P>VBdk3%LOZ%HOv zXbpL^{uq(!pl{nRo(gU{Af^+JL>XcHZs)b}#_O^=^Doei1vn~U$;rfUGMe7)M3Upq z7?mW^Dn$Q*0bn6jg0c7yn@|Vf1y=+CvsK6pTsf=&dXMa zaA}a4J#glPpO$-!NHtg$fi(Qb5LWM9SqW-9+x7?7nOBWY4x>U>$3(s-M2il6WM972 zJVVMH{OnR@Bf{MDj^*tX-fvxMKBlkc%^q>Fe0Q8GjVv==K{(%N3^z?Nt zQpT{j;kvc6c9`5vb?h_GIX~AziN5Bw@6i%9Hb-^PmobYMJq4mrE=cZP6!8o%33-P{ zMgrT|m32meopPyN>D+q3(%r6eE)>Eoa^3$q=UJ)%XEr|ac>7Z8>q;bs3-gVSCj3pN9}jOU>7!p_HOAqv zqFNulw{vjd%WAMZbDZcZD;^>8tsWR#Yc0DK_PXSKSM%mpH{0hj>PX2BlK&ftq1$rR z){|brTqViy%yf8dOs<b~W0%+!OYd}#-hN&`G&5pKOV7AV!NVBYab6thCer~8Sr&crPki{V5i zPo9OIE@_yAT_8XK^KiLDCidOr&W4A%Bc_nnif(u&ofCf%nA&}=%toSb#@_)m>wORe zUdtRcXImN$d#%uFx*&->$lEqhs-L zi6>*D@wejJM~OB%=6`Xf%580L6BNdoXnMg^GS@dKo_J>fNGU>hclSRH8;;OdeokFd_zDGv5JQl?1o>B03hzxE3!CU4u4(3rjBCzO)8%I1CVs`^;*^(YuU{RHTm-xFG^!w%LM7xfTWIsZ#!BSD zPV$g}mAtC1@e8Q-i{`*c}*cA?C?P3uOqzavetFt zBlxu;uUM5KjlcG?zYlKC2hcV1*_FaT(*iyf%WhuSC{9FG24~X$mpM4gi}rQ7V?N~i z!3R#wd_2Z^iUzRI5a@b0#UmTM4K;GzaLYG8HH9zW2DaNQ#l;AMhaxlExnsg_PS)`H#iP$q7zB{pTTa)K3`Q{#RqcB^r@JGr!W)^8qgXY6s%W z(7?9jrDmu?**`yDL;QyqB}9}!r37ES&#$hW;Aj&dx;YiFA8id=?!QR~(7Ym#8zS&X zY1x&{{sHWhANB^jlDK+Z+ds~PVeX6*(-#w0v1`nPX)AG;Pz6a55m6gOp(9(mE8&Bg;70qwY2jLxlSGf|jItTQg3R)RUrG|AROG0axapV* zsh*YduSeMsf>udCxl1{Fl5nH=v}XcH(Ng$>0gw&}>gyVs4?;pha6=-n6)>C<*fy-8 z=mGGe=1c8P&oA)FWT(A_A*sgbhjgA$BB#k?9j{oTsJ_Nq7=)OZm zYjQ|+y!^|EvI_!w+FU42D%r)EiZ9pa(-M-Y7A2?GF|xn&=7k?ke|T|+w4Fopw#>6p zHdvC@2Uf00LjHD#Kh)Ylmdd58P^-o1>RWM?d}s(k2en7bDu z*Bj-@fw6Y?kdae0@s9(aWseLGm?X7+G?)r0z&>87xKI$bMU#j=Soh=ttW8C>s7Y0Y z#9zr<1AZreCGAo@I@V_A+^G{&ZpH_g*v5GZ&MTW%zJAU2H@74vWV9HIC9jh~HzmJU zILEky@p+|Sr_?e4tdsOIzgi|cq>t)c@`HtSnm+XXF;r+jrh8K)99Kd$^HLOFnps3X z4nO?-!i}6<6EKA|UJoNQUQC8Kg8b4!)z1gC{K%)4L*fPFKXV8bnl}98N;2n!egKv8 zhtJ5I3t0N4y83S>N3++eI?_u?28#9x0<2_<0ZV0(lpaZpYM*>>M6m12L8a{inRTo- z(U6f6Eu>EIU5i+P+LoX%vE2fFXrHDURksL3Ei^@mOyxJO?&9|nY!)`1_`r4ZeT1gK z2OXTSC&^E2R?PZ0rO$LUP3`fAE3s)oA)5K_Ye1N0Zh7|0W>-B_{T0EG&&I?Vfr}IL;i=NVs2!q0#1+N3I;1S$~m39uHkPax=l_0@k2_wV0O0jSRv%i)0mnnR*I!2XNOGJfokv;b@nPjD zedXz4#SB=wbi6O1@cqf_z)F8(E7eZ8&}kpg!@?U^npgB0BU0|qWMvv|Vd4^;W&;6d zk{-1~+{32T=^qstt8HdF+CRsPTdwY9O6ay>3^bz1$+=~rqP(kR;#ZF4UyyJup2Nl* z$1rNXWN>w|4)bmmrmM3BiX79{UZ4Wp2Po~WSU5O%dw&obx*`Xsm~=}`;|4DeuB>x) zwWL@9?@j5ZjwTve;Xqj{*p_Cxdvlg9A4^&0#gN%-t->%RH^D`Hb(Rai3Taq|AD+i2 zXzFQJxnvx3S&)7!43~7ijqVvtlpdU4ni!iNfG1TC(QJ)<`SSs6vlrPj&MYj|H_hIM zPBj}d@Bx5Mj{Q<#v0v``2fDrUV4H0f zmhz$WW$+{yR{*hcl~Gkxr;Qcy3BtZsx;H8g!+~Bcvrp_P9+@iH+^|P_b~-A4sz4)h zDD0(}(=6h3w>UUU&!l)cN^d2!jjc7sCWR~Y#w#&o=Y0UKPCZ}8ANkrBZRX*ROWuJs z4&F~H7Gm8CGx&aLx#J_0vq~#!!&CyPofIn7>i!)^>eVd%S*8MtNFNtS!Ug&pKu8*p^wt8f75>6KjX-Z@z20Z9{?{)>B4tLPb|v@N$v%7Z z`cF>Xo$m*9#4=ccKG`;N{oXouKPVWAY7eg~XTPPbK)8Rn(BoqOlN!L3tZlo7Dsqho z?8Fu~+H^FsR<)W1IkD(zth-Udjue5de`DPAN7!=->xN6M*hYhq(`! z;Hq=r`T$w1dE<&k$0hdbztNY^3wYA6wj<#W$@ZFCcqzSmSvF*M+d%CoH>Rkb{4UXaX*Dvzm6Mh78@AGj?*9@DySrX8K z@^j^hB9MiujpU+EjDIFk-B8hb?w1|o%lF>EXddeIMS~8vVX35hL&_^BCs?}YN zWLLGp6j<#8tMYSpx>_?qa^gGdn5_rNj-d|L){q>DOU)RU4B4?4BzBtfjZAi=4x@JHs!*&EkP+0Qc((1V08;<&823d3reAs zSogMh9|5OjQ;F^m@J9FUjsS341_h@~XIe(esaQFESL@EziD0Nwa=Q4S=TcuH1=r=bxF|VUr*H+E%I!s6Fbsn&frIQvZm^Zi z;2$aMUG=|Jn)=hAy#-6vrEM^OjgATK6lBmSCqN6DO$+@#^Ky=*+%(lRSEl-KEctad z$Sq4#zwU^nO7jy&rmds#VCjM-r|tp5#L{6-`Y%zt;1nYj8?_~)E{7u7u#wlFFTirT znd0UY_4K6im&NKQP%<6v@@5+rD-bLa*k*wVbS~`u2BN4;XpPO)qH+Cp(1@_9HUa5^ z<1YVT)2$$3)#8j?xjPp9OmeWGv06}y8VVIMs86>ZY%^H|#&OAu=d_BnTDF}c)#7qn zy;sZqF}8)$I4?3KKaKTG7iV!>OvVyXJ3aNg8lDK)Vtiwv))L-LMfU@NMJG${*(X#V%kN z92OP^Z@tpQ^~2GF!VsP;>xHd7{U?5k+p%E$8(^ic)&M#e5Uvzxb1lFz`y?k*Dw1N+%uNG*SrbT>`6+$ z^TlHGVGfc%0@I%nmJVno3Vibc2~&ewu8XWt^@j6iXfbpcwa$xm6?pI9_e z_}if-pu(#Vog6a*iI`eT?x$15$TBLZAD1Hi%VLNN8gy{cXBdHs*=SxRis`t)G*zp( z<2UqB0#P<9se&!F2p1xB2rjrF}5v7lBk4_nVCE}P{m zj?Xq(XmRuPfc#Zq%SPb=-HkRDAsVl zE~gQdlrr|Pjbpz1Lzy>{Lam$msVXy0YWBm!HZ%{>muFVJooMwNlGAzpIyluC7z1rK zP}QsA64Iud)6{k{-^sU_{P^XWao7$z9X66)O~Yr&&mU8=9IRyMJzeQHlOW0K%+;uI-EN2wlrJBzd9sGEHJzl?GuNpRg>SY4kdO1eD zqeZU=)6*>W^^^57+!0V{M*z0c9vuswfO?+m)sa&R$vaekrzh>aSS5|#C*?NxV;m1F zySdw?M|b|K-)NO?w-+@;^iOU0V}P(=&-O5h1UOX#j!bt*PZa9wvG~@`rxxq@WF#Mb zqBJ1IGhJ<@0M!^C5Hk*sq{9R}a9BPh4l*{2qNr#NY;G4KHzmKJ%M*efy?dfjBL4iT z7L4veB9-o7D}xY_E1WM^mqtFTnPKvMuv&=@XA6&5q3?@>X?HhNZKf$MZp<`ge#83h z&&FHznWm5HnNfo1@6-C3*_pPDi@*iHrhN-dl(BV2=|$;%)4^)iv2W5Xv?QnjhUjtw zCj>efqS7T4Hd=w0gB)fy%BDBUk~!N=y|G1vr?5lg`+lA$1b2Eq1CgyLq)oG`Ax46b zG|620Mhy>bH_Q*&car(Fpk}9z#4g7(*>a`cfL9}Y5#$qKA|aWkiGw#ugYXsZt}=F| z5waL*;$pmbmTEJn&nqZM!f(WooHCP|%pXZ z#;^P%2UVw8bHf5nDF(NueNEIZt5r&AeNmcL@G0%7<)(>k&nvzZhPWy6o*g-y7wShu4MK=M6oEd`$Ls1?L&g9>F26X2y(It2#0$bq7{~njkkI#!*neqm z;EbMnin7@cuz9_29{~||CHBdTZ9FBOXIG6b>dH7-@Z+Vsf+gT|6T{&CjpapAZ})TO zk^Hse^N`F-Ce4loP=|~f5Fv`Ke@`B?m$ekw!EM2w{g)R-q7c9rv6w7f{MeqpE+fSc zJsAablbS7%-S|Na?#IE`dp`vF2L_PQ_^;jrAkW`PJRXOGiAjb8pj%)C0Fpa8&%K_N zxt|wd2ps`~hrv*ghuVz$#sFSvaQ_vrQ6i{WYT zLrV>YS$J7~3?*v=Y7dbZ=g}$HH#av|BmVrIO-uLY{HKY-NBw}%6Tl_Hq5klcoj!@r zovG7PD<&HSA)_UJe-L*FDDB}9HCw-^Wh=ONr15YjR9JDE|F$4|ZGEl2eqQWTchJZ5 zHL~u&nfV@fxcbrAnjsNpWwl-VD4$KkokU-MsVN%YzkXvk@}SE16TN+WgEoGWPIEE0 zCoa68-|GUEm~@6j^Inc&!A_69p>D8cryRUFL`thP;5Hv?)8IPQe?vbNX%}ZAD$an@ zuRp%N+oRZDOCcfvD^#<5V84vo-c(VVqK7CswdiR;4TD){BwNl-ohES{ZcFzLxexjp z)K1Rrc-Cn=%JPcdwAd|FuA|U5#Frj5gwxEvwA?LKK;Yf0w+@kQFto7TF71n9c)f62 z*5ij>N>by@FPi`0)SBQg{m*gLpfdgb>RoZmjd>~|Kg-jY0$Z6=D7|9+^#%kF1p1+^ z?e&B?x^4-BNK<6TP1*7A!9K!iXfz!61j`%sj5glJ;+|%KF!Z;Vw-EN>>TY6?|= zQ55QTHhOX3B4!e;n>EBjHa1Q>?nEs|N6!F*(}8)Tn|9;myuEp&9TmL7u)(35x9}JKO186uW$#2R^k^s zmB+T%rFYky z-Nnjoz&2%0cC%%Y&?hz_C#$4gXt%oV4uL>&rs9ZC(l8V6wk%eJit(6fq1k9H_WKSa7M~;D&i-YC#tHd=|+rL1Y22$)xi6@vf6=sP2I8Y55SVS#rWCB zNzN@9XH0Xoy#_YllLm)nQ=WZ|&Wo}FRxDsr@3c4YbQ0sXfzdhXwCvIE1c%QP_*{~L za%urE)2f)XL0bHm16)Ic5d!HBc1D7v*0qo?&+|)u>Z4Ms|!s^}j^6O+>3vA`(hXv(M^qgs2O9uZbg|m$BJdi(0R=fMI#IS=y0k%`wzA3@ z+NUn+ayd`R^>sQ!dn#RtVlYsBMtz~`1jI1U2Y0Qvj=q(8uHZEdmAbv+ss05zVreuf z+cn_VFpb)=esx8(;O1w7!Q2*+H`=BvgYf6gpWX4xc-A*0@#aNSI*!nXi$deXMqQhu zk$Rdh%)hYx%fP0*96Z9BkLVR)pYEPLXax|tT+lG5EkS<^D>d%yp88MMY9Uik*XMxJ;RSB7+8cyxA`R;KVXfZS5#Bizo?QGvR~c zB{f_Z+>!s*f^#BikVr@JQ2}t@H3MB;)t;L9S(Bom1N|4e0Fmi98ei3k;fy)Wk$9%&(McV*0=zIikC?{-Q3Ta0@pQZOh zO?vAgZ3ddj2csbFj1Dy-vWHKf$sFuPcx?sQZ1s_e)bQKa?lCqf?Kc4vL0k2+P~$LB z$HHwSOSF-yd(Wcq_1xjHv!?ys%Ocbdp1G!tw!-k*jop)6Me<|T^42>*@^jKxt|9y2O>|G8oX_tI5$azZp&i;!*5REsKt<9aqw4X% zuRTn&<#ZKEfqxDs;Bo=_YN}E2RU&6LkkXdEX(a%>1>zWE|25tn*A0v*nHx`(7o$`AzWbS zFKLkCNmm+3f8Bq1!M};xAm#ie0+l@RuZwDd;@eJiWTIrFAafaZGwXhGpoe*irk`9GP8TWfISKee!) z27eDd9&fMjHU;Dy95{fGG(JfmusPP?c(JF9ABqqv=EDFGm(&~<>^8qK{PRU0H!y|% z`HO)Z$P;#-AQpg9%^6muU4_mMdh*Ur=Ctw#7~4Rz?Fj9e>q&H)9*q7n@3RKLDF*PM zfhVT%lbB~|+r!Q2qSB8XnN+D)Q)YDw-43m%M1V#uRqVtS?LRS-9vR>PJtZZ`KXH%< zro1Kr2UWlwRYm=7DV2!F-g2!6gV_B_``KTOTY$!-KF-Yn09AiU8GxML%Eg=oCDxd5 zN}9m%xy5xX{u$yqoZu+yU%4Y34Z9KnOEMRbFSMlm&Ybg#60Pq4cA z+6yMrR=sA8%@I{1j8>r*7S6Xa-dU%0*Tm)fRa>lA0F0Xb`8$k;O2p)|!v^ttdH(fT zU?-_tm2gnBrIof9xFK@_=Y3)TW>BG*ze3=PH}LS1^Y7q*(IQf&8nrO9$l)K@0Ljw! zi9m zL+@Cr<=1TW%`s8V)II{4Qzgo3nfMB3HC4&a^eN<1bFhq=QlC{Ns9lNiD%Qjcq-T>lahCiU zkmOwT^lgQHiWJfkPaZCxr}?wF7I{Q@8uD+-C6c6z`}nYJJ#R&k8Yk`wiS#0g?{AD# zRVBg5*IUwSUxsq2E-uEo{9nV_^M|hHvzKAVAH8Z^IH%Lkcb;x;o{&jr$#011^!bMH z>IXn(CDtULT>$>CN?K+-J5)Fciq+1W2`5?%&2&Y;W@|uq*)W_t7O0{VEeGkg^^#MG zYYyjXMJK_S*zcdF(jK@jc@?opl$e8xp*3U>S#YJX?JVJFs((9?)oeNua+?9$Na$j* zo{?`&L+>iSSIl&KX63}_@XH?g8Vj}8H*CZIq}G%pj7SCD zI!Hu}BSSCht)<>2uB!dMax|PApYdt^p3=L-*T08aqLIy%;AMveCP_6EaFirI7ewWd zOo)o7ybez(tyW6zpD;!hF2mE))5{jd1mrq!=bArPSXF7{6xC@KFnpp&(Xn=ot~B^) z5Os!%-0+UUM;JaNykN7EX8+l5cpnq%zf)poD1~-a{|uH5d5#0)LAD8Is}PvpCu)e! zZkW|%qE5|ljgiPbZ#`$!pT>TMr}FpDfzDfx_{J~$AUuQNTE6^Xkt=g9VOvMKU$vjU zSe{Jy8JEQ!oqla6E!LyOYTg@p)>LEaCGX+WtA!>{_v=D<5=kf8SX^HAw6r7Mh#lwd zh{rD1MCH%DA&5uQKBXvpa6u_&8>AKuM=B6(*#}@#1$jtUo0G+6Zjq|OfFw~Q!dvP11jbM|!w*U(8w5IfX}E*A?^muY~D&OffUU9p6i=#s{( z=)uCQx;E~AzpEA4u-^Jg!Q5<{hi`gs>k$f7EyP44!G%l@^suv~UkN$HivCpB{irJ4 z&@CbylVL0`%w)!1E7Zs)Iz{F* zEX!ppx$fl=2>LNQwm1p>V0%^6{}Lb*bzJHjofZ9l+;@)54JfQih)7NvMlUUxL4-6h z+-XP0?3)hVu>E6S?eotfU`|8^Vhj$@N4edvs{+WU>g#QEZfl1+EMmn0XTfZzZQDcexlkA1wM9pi&7ae^BNI=&1 zB5k57_Oq)OdTaW}%a=k|LKxgicl?MI-=zcZ5zs?x^@D6k@X6loT5mf~ax~J8?-B&o z+rg3cLp1~gE>y)E&4E#UdcOeWZhT@KM%mpvnvJWCdw*B9UP4J|=Q zSFds!msAE^joOAFP4;iTF}+Xk*JhyYkpWGpkyI$*Rzyg3bD7avhQL>_U+$2Rq6=M} zU(1lX!iCpb*1^-w5SQ(SOv*xliMZ^gqVR^zTuV-&a%{U9Ui1rmN^RHrO{TJ&8*dEP zi~w$mIA{(3Qt^OH<6z5X#YOXo@{%DdAceKgRky`VowJ#|{sBIp>l=*s-Ejg$XB1Zm za;kWfkcz_G%u9TBgCLA?d9Ee8p>G2_e;@K%?CT@LTRh8MQhNTwFpYl<)PZ(WB+BkD zz_H|p@(K8Re)L#%X}}bxx9zrcIL~%jQdv7t?6y1Gln2S|Sq|Zq!K_A%DmRrU^LkJ2 zRV{&=i-`V{4)^^X=_fRI^!EZ+q7mBYFR156ei23qzg>{lEad@y@SUi8(e2YKV zf&oS2u+Vps`R4DOL07sC&U*Ku7s72j#&&^%k<`=i8iz{~q}OYHjn9wOfFwTwP5Vw*iZd$~Db zt`!`N@viAN`CA_xkl->2tdx+EU6C0nWL;&YdyaR{ zh?TV2Xge$O{IcFV9vn1yj&04AMTB-qEpynvqpnibR`b(>(7}#t+h@12S_)gN=2i{f z5M)~Mqq8VxMW}6HJw$ryF02Z=SjZbcmDD8^JtIF8R&>uSt5EB8a6LhQa&q1{l7_{C z6~ufgy=|HH=EtUpDDSgPONh;N@fKNDs4!uanLEYOpIQAxM;D%xtEs8+EYUp-NhW?J zy$K25h1ueff-_%)r2Iytun^cANb`A(1^S_G>*m<$?AGFYuZM`)MTB6#cCAr2ky__Z zbOS2{T;0|S@QZ3xZ#6$3-lAHV@v^VxS+afsdfR~S>*Pan1=GN@#0)+`A2@CXb;10x|<#(sLK8L9~XcikpDv5q^Vjz zlAE;b_qA%gZ|>+Gu~@qPQZVNe6Vh;Mqn5$6-?G}Bpofo!M*dQ7&L8`HjmFCYi863}J z34FLa+m8PI7+|&kr3_}pQ%S@QON|`f6yXp6POT0zSGZXT9~m;)G6TMSogyw>_f06+ zv{XQ9z$tZe%yi0#Jsj!_4myveJR`&FSYGDG86KkisD87q-fWb}(9duP_7)LHJ3(!* zQtU2IDmgJ-{hS#-h&?wj(D&f@#YEoR4C;@SZiULR{qjWRt$V#%x;=dV(^m7YANtZ} z(7d9VQIb052IAp+)M0t~yF-L@@i>wY4b+BTg1@>q7@EdZU^#OuFgsm`re%e0hLl!pH@9v{F^Yxl?Ma1owfz17w9g|BuGpyBrM zox5t4%|I$wv_woXv$FY83j?cX(Y~F{`Ob}nk03jd3X~VF_c!@ z*&uGaVMYWJj%_pVkzji2AFheb&$&P!-SmpKd+6oJu3vJKmB8pm*rCnoVn@P}-2UI`**{Df|d(g7dV=fPL2-2Fb{z5MnMJL(u^yS7{dp-dj~7m@C5!)G;m zAjs7Qs`H7;z+2`9Lftpa2-Ork$Eb;j$^}uWQnidE+3pN~hG;Ioe`jX@-5&7w01XTb zMS;>}$v+&52RUUeJ)@m>{V)ohGJz|>b8@r8vO4H)5ounXW1CRMQ#H4ZO2v=wU8vc( zNO2-=yP2)9?_5>V#N@YaQU~<0;>#pJH}?^*!huJC>0@R-8w#e}>ORZ;TEaFJlS;gL z3$;s$AN5u|T;Y=@`tRb_cyj~l0cD7Ab&ci-s%K-z9i4>F7%MILMmI=;{2(WrUaK!- z&cW7d;v_ao>#n2w7lsgQ)6p~Ui1wLX@K7$6=oK;Y9B=gX5#k@ZzrpIe?3)XM(7%xp zxLk2T@8O~2FP^~egEgRQPbkD|9P9MS~JIj zU&XBpXH9JPdYv!SwUJ?(nhY*Z6-o#`KQg_hMxm5&O7hpl|oB zi;MIyc{GSYz~$%eD}u`ppXVADFEVeT?j+@Q2pzmURCLP`AOW~QH*3!*qV-zzRl4cCh9yN z9pRsTPtewiG~a=eiIK?2zjK{0<|AE3b{5K(kQ`yA%Fmmw&VzpZyqH%tcQV$gU`i?8 zsz}DlO+Kh&@LO{_NU31281ozD+hegBv&>}EQ)!!Uyd~)sRE>#jTuIeQlcNKNR?%iW z-r=mnngS*L_RHAyy!sXiR^4mMG;oX*dDYUw_blDBiu=%S^Ecmaa0>2od+5|my7qPU5*fw!G{Y;ogrnXix?I0Fq2`MnVI>FannxPR}c0# z){9`t<*&8dP0S>Y)6-;i#!t{R`+`|3Sz;`fw#YZ z^EZqJihxwzYNbn7184M2%<%GHQUkg!pbwd&)X+6-j_`04%u69-IYJ5@1 z=lL{=N4U5&)TkK9YNJM(LeV$fI3M3blFC6e)QiOAWLYdR0I0$XTOwN|shKh@=I3F5 z{v~J2^Ld-Z>mr6RRIIXr4LfFs1bR z##)Wov~)BBVt9J+o5C;o>^FlM_%%Vo>Gz77ehGSa`j_&|ON*B}(;K-<|6IhhAW?8@ zk}54j_tBe*hJ?HDQ1FpWTSaez1TXT;0ZCV#9(Y~jIzsNTlO|yj=on*ASTiSDcBibI ztM=**3zU!@@J96d_7eDr`9QE-Q;4qO-rzQ%-ORSXI_4q)`C}&-*8h@FjMe*}0 zb9eaoGgmZCC9NN}rbuw!FF2T={8=W;$oY`0D0zI^c5!%h=|Rd-<82V%%aWz{rm{?~ z9*=ln5V2%Ujzzth_7>OjUL_866(fz@!mR#BN%PiAq&a8O!RcI~QlNy+BVGyAKWtKR zJqz&H+{n1jd6ph1(jE^z;C1-77(d}q_Js8HdCrt~uXE_P8?|j`RIcisFfS7Ledf2> z4x5(Vb|iUR2p7O|lZLy|iiUyucmHs!e?2nD{PIibai^@|@<@S6YIR&YJNyBOtg15HSJrRunrOv`&2~raag?KXO&^#HjbFi23fWD^ zI?`-&W*gmzx45i#-#oBE`J?3&lXkcF1M}FNj~i+t2AZ2$%w%MbmPmfod>C#EyD6RT zv_`{ER({H}wErAiR`h(8Gj}B>#7ZC_z;G*8{&*7pc<{E53M<{9DRAvk#iZ1*-c2rS zS%@B*B@VV}RJTV(#dM?HyTtUP5ra}DLU8>#ZgYn5USjLck9D_ z!{b^IjqeHe34M9m-z*6mV7T{zZ8sLcV?rfHaXYnlENxv^ z&p#&>M2{gba)uV5X+Ua))1*^;%XX-c6a=^vdA;$sa?y-bR7@qQze<`ynL5v+yV=C~ zq2X3*CMw8Ao6Psz&Xl4&wH_FBgD^NF=f*bpg%R*j{7xDE4MwzVfKrO>JQ-g`;sffi zUAt9|En&t7vvD1%@t@pAH%Bd4gA<>PPFb6Pfz}DxiD&}`>6QP5CqYwG z+J1k7tCzR7rvDZkfmt>GSA0xA9W+qVGLBA@m;T?hZCltx21`^ggwXqcTgD!lZyeg- z5o)nxYWN{e<6%~)CZqVhXFjEkr0Bh8>!J7Y+!o^zf^&%JpXG+Io;h#ui-$)&0hbr163np+0VHxQsLgO8dx@rD`V13v&5=agD+acwvDs-E|8d^`yUtj7o z9&1)w(`~2Th&Y$MVcWzRMrNCXb^nX9eT#$daEn`_{a4;*LuZ+sz|nRhY_rpS73C%r zi7pT-x?BUCiA9*1cs~V*Yjw_@ z^0~r3&o5_$>jbZIqZV@1n+t!X;M0KFy+?k#s^SmV$Pk@_iQwyngBCvmQmbNQgm(VY ztQv$L=3Bnu>|7e;pW^{kc#EB}xXG<0Bx|{D|OQeItviG4|!1I7;@D0;={wAiQ z0fff6l?V5b$vgTc0T14X{ZIiNUj+?`824Ua=Q@x*{CRjQXzVl_&21^`u$TQXFXR<& zb;A!eP<6Kr9~TD`6|Z*pAI^nMn~sR+?wH-i5Zu#0r%t!N$3HGktFNs%mlDhl8m(Ks z&KkC}ooM$6lrJ^WOKO0e=bzHP;+MIWGCykvL+8>XPdOIZ$Ml3iI@;>oh0^iiKJtTm zvCy`=Du+Oe+-I~QH3I_L(}%lPJWh*vam`}z}AZ3+p=)m+@G?C9mGUOYZEPsLQ6M;)Ot*} zyurugJUNUa>6aX~i4`*}P<$Vmk_B`BN(WcISa3D!M`^QuT-1wxH4V>XevJf^5+e>( zR+Gv~t)`hwMVes0G@vZSN3j*7a4G$|!@4`!*Nfn<{vdYOyU`Np%j>$=rvvp2*!lf%1DAlC$Av*qHYR7*fQ$M4@AL8nKKzPiq zgw$GV*Hg(rQ*eIaz}Zxu5a95mO~l=q!vN9W<%7Y-n%#)Xs@+_@nX=LFq5Vh~;^?p) zZaM+amJW*nVymj|e)vOzV_V=nMZCbNQBTjy(>a0IUngJ$sIyt zD+&32-ON>A+9ySGZca_f!D)5g+fuN}42U2a zAAWpoOg27b;-cJSs@||XMDNyTzMB{aHXP=jS0_AzC|WR6P?$&_^e>OR%OZU;9E zO{69>NUn2lGJF+<(4>Q9hGhI>KjwhBm`eL6Rdmb?zZS*N=##0*6wRb-#7+{r@HJfD zks9*V!_z=y%q3L+!Ymc86F}A;hbBW2Em$xf0WYPHz$-wg#;jp2s;b&Hvq#*D0PaAHOe!jr;2 zzWL7Y-IdP;`|5cT3O#M#1J<={CQ9{`uLdQCMT;U&A-kce7B)mLNCEm&+}YkVOb^79 z7ErfoPc@W`qr$$$=%OvJrs-)qto@L=r`x(~$q%x!l2;7at@Q`xOv>BD$uxa-ym4DqjoaC%JK7%?z0j_ znq}b@#pSVenn3n4SYKep?0$7aGIKZ^B(yVm-ClL&JoqVW{*8~W$>o5zzM`2em@2h*a&c8=)VvErfU)L*5Hf`%$ z9&fhHa4Q!qTf*6VKD`%@+uOH#;TrBboP{ArSe#zdWOa8FV7=|BXa~4kuC7512Y0G2 z14t9ET-@vu-P@82Kr81n2O-$2#S1m%qu+El0s{K z_-Z!~Vna-5&YmYeo3SIBE!lYQb%G&Dz4MA-3nL4xS>z34Ab-30>YR_c$FZgF9giHv zFNx$O?&(Yma_tMWsjDFlpq^B$Q_@w0@8cm@3$-yS;hI;@g2lV-&75FXYRedM?=3gg zh+wz(lnCl77;6MyY&7YG@Nd8_1D`ANG2|bVpQKpe^GPqm?0<18{c+(;4ColM!g!H` zwZ0#lFzI=+47YkfeEm>?rXt*ALzVRI{SKj!lgL&hXk@zh&(yl(KC$^2TC~lS{pVVo zPq$hSY4SNm6Pesb|D|B1cVA;1I9}gY&ZciRq~q&_u2{)Wle0$k@20~iB7Y={u6J=y zyXdao+SIV~Z(RyTqyAK}WX$xjiE1*1jUs5KlUK~>_UarXb_{M|7LF{7xxlHd*013) z!$j4wl)+j^ln*3ei^$EK==OC^=eFhZvX26TLUIzjHI7hIL%&0JYyb{x$vs{B7j`{2 z3rqm)OCKa_BMV}u%0aM+KCUWsb^O&ifhDR-JojDobFv9=?o27Lj-Q(rm#o}Yrj^mR zK_&QSHjGZEyJvUOmpV6@N|e==Wv{dpCtT$-sYv6iG%x?X?9VEe41vUPJf`#hoI^l( z@w@Nc^`YRy-nlNyk+|4vC=MeBPT#&dcgc({N{>H^`GR{$SP3mw(D}NB!W*E<^b6$2 zF&DrBN=Oy{;j>8|p)_0g(j~WVw7zP2{RCzxXKi|av)guw9>HvD$ zZb>x%EbDFyXM9=vE$rmhxIn*Pz!%whKLxX|w_dg%c&oC`*II=c0UTu9kwrWb9)~+8 zPieWTEQTO<@s8^%yto5iAPe#dSy5(6+`FFoP;aet1LE7(}%V6qy)lCTr$x>K=DhKgE@n zg0JW5G$?kDNU!M;feVv^Eo#?sfvS9qy7*7)qRbWtHhUR*`I*ytt?se$e0FUcuE+$s z2k;UnnrkkIfZsB@5ve48P4rdF93LTtJyu2;j&Y}c9>8!j2Vo9M({u5kZzxlY9u8_= z1rEkgpwlgKPI)patc{frgy659-dWQU?p3p2QJ_ zxTqYH)tP^Ys*j%vF2*Xwy;Vwr!h!;sBKvXP>bBc8hWxDj;{`@)15s>5r0mm)bw_`m zx49;C0P%(?3$e#9U+{5Rz^|Q(9uU|_vBTGan&WU`&%!m_RvQq$P=%0hP?WIw38g~I zS}D%*mfTdE-7%_(=e^jPb!Y#>{6hZ2{8lx`+AIv|a12%8f3iESZdnBB%^D-TDNQKF z?zMqaK|2Y_Hlo}{r0ZJp0vb|pt;qMsSlzt&dBeBoKFOvog^E|?8h z*Q<`D-x1DfxGOiOFzQVfwh}JU zlqM%EoJdzI%eP4=UT5WWxaO*1rBN$A(H%w42=Y!?O>TT(HEH&fM}tjDc3T?7{d3W= zcR8HKuM6^wk>MkgWV;dI>G-|J?z}PYR@SE9@+0dq-lB+uo3jLPWJ2}SI@lTQ?AH88 z5bT8noXuu)yBQsQzP3qw#Bw_u&3?q9Ud4aA3Fh90{Rz!>*Fo;Mh&)7|XP)Do)RdT% zHHKiaW}wz!%~f-bnNBj6Ch*rAkh@73*+>Y)bB|#Pd|QMn8d5VM-$~A*vMG27?31e- zi*I77G@==$2`F=DdRY8)(3<%#A#f!u2R2IvKX9Hd{O-}r+}fMUyD7h83IzqbjGE+k zO)|(gu?aSN;*24Mo9Uj;H{@$*Mgi;^v zIW*VS@>zY?3sdQD$-DcjiIZ)8{u8K|RAGdaQ81O&SclinWA*S^m%b7E; zbg)EMz~(WLLrfZ*Dv1A1m`Luwr+eE1kB^I#@6d+Z3MXXUpGTXdFZS|nwHktwjwT92 zo0vmzVU)MthfX3I@z;Y3n@M0F$#{d7$gyR9KyxFoFqlRz9x-&M3~1|~xm2dnXqo87 zmXbk-XRFSfOs{)g9J}x8TPl(gAk|aFW&9m%g#-p6g{chQZoVUb_r-oFA^;3IQOout zOr5Rstc4ouKdHtPS-ZT~r2Rq{N~+lSDIeQ-Hox!HS#IeEMG^%CmgEL{8qLW{r}k5r z@6RdP0oI0_pyJM-eU|43WV*soZD%DWCq+e)7n}|Xis-wF7c+TM6bwb^QN59gt>kQ2 z%X@4Cj+98fxHqj*dCLCR!O%>w+Lu+eHp-%+*h~BGoGz)66{|=(Dke8J(eoZuG%Na* zc*Ok9v@3SW^i3}M?*>2m{_=rRPc~JrJY>mr6(f9m4dRznJOn42w)^X)5u$m9 zW6met*@S6?6t6c~SJ2C3z8D`nT0Iql9X!ukDi@%$H-gPC;`K^9zCENk9q|u>`U>Pt zBE&qzk2zGM39Y9&RaS-rBFvJ8n1nRiGtO?TsN#YTo&l%=fRQ8g^O zeS#iyFs}G6|JCFSMJSSIgHWXK%VYP_TYi=ONWAEWpPoF8BD@-3)HrvU-IQycXdqCC zRM_sDH$?Ockq=X1V&5CdXjpGbg^x{rMwOLg(X>u>+?YyzHb_F><`>T=Ajq(rgxC>b z7;G{^?X+t->)$aoesTet#VHNbI=}Oixt+`V{rsx1#MkRn7i_q6zmj}SM1I4e_n|X& zvwW1AIqI#2{X^~%35#_=l7P?0o{y2Mm|4kfMgxf|Re8*TOje5!=@7(Wt1UYfweP&C zZ(_mHp&O1@g~`J9b#)180v*%!#X`7ZGeCWB8pm@93UESxuSsPM&HssXv{eJcT;&e= z^ILbjV@o0u8Xmpc_@(ExCqK8b;;z*3KGU#d|9?HVmrp&n98S9b8gk?p|BF$SPcbT| zN6!@JFRZm*t@FRCORYQ{T}2~EnnL&RAIxhVi@6z|CM`Z3K27oFp8xjt_NsLlaNq>i z5LM3BTFYWz5A8k;Trvtz1T_-Ns&&vdqC?YiFwAbm3|a=w+e)AwF-cSxI66ukPw-Z$VIF$lcoN98&pf-AAyZeLR zkh+9`B5mUa>Dqe$rMjg;h$2fwg9yd6v?Pk-qq$j0SrClz==U}&KoY<#0w6J%ed0%a zvpMeU`Qj*=KK>~>3l=Wwva$=w>KpFS4Rlf|&F~F9 zda`uQ1%y@Eo|1EHbF83tfAsJ=4#_jMM6J29Ll%B&8<+Dc64@sBjOMsVCI9Z+iDV?8 zPC!Dz${@pxhZk{6yKJrL?=+>YX!Mr;ffF(>H`qrK&$hO*s$$amZB{m9*W4)h`VQ;Z zi-7Pr>6NrGI{cT8Xq8xFDUHkg3Q7(57peV&LMg}I zd*S-uvMTE&UAwnxib7<3^{mG%N%hg!vYDr?|GER!Ha*4uW|1V$@Sf*g7?+ z&kSKwA}KEu<jCSGA$D^?%mii9W)qXH?n zU)>$R?UGe48I>UJ@aR=l65UT(WnPeY9Wv#(s_d^Ks%LENm9enVpPCU7?v*--y z&OwT>LQHB~8o29Mr>|xz8ZKz*pOrVXwqH$4?C>hm_PMt<)C#d@g=m+|sJV$z*ti0_ zS-P9@)*n#-Y8l?dyl#@kba8R{E8wJg)sEu`NDAQ*5M<5m1NOI9+i4F*#x?jj3>s^I zM+>8X@jt)=rZ12QH)G{xu+~i-ZTxWe#2`C9vTo>~_A>z(2`}N4EEXs$PT-BXHQdm6 za{?)FFyFLEvSg2^a7}qOL=yif?OW?jSN537d)K#Go5lTjUBhDy-*0y{Fb_a!Jt8NE zvijHdfTC@}m6KV4cq!NzVA?UcZ^24j6p;q0)gp^iFl2+w! z{}g@KaY!#=O>1zciQIE)W$6+oBe8ln7&~_<+8j2X^R2AX@iT>0c)RDEL-glC_@&JY z^~CoCe{M={+Z9bhNmmZ;SF`&%PBoh71P(dXofiuDhzg!uKl8l?b+0Vxx*VyE60b29IFTwLirQx9ztxYD+CrEo}xG^6hevbCBF$w9Cr zXnZB@VnnSu`ca}%Sk;jm$Wevjqi;a3_DoJQ!!y|AP`R;&@m3pQ zn=6w%opZd%ynXw$GlAE-!k)#Xs>$NjWI=@rnWHf<2Yz6XGb#j*wV!~*Wq~V$Kh>+D zh#6tY?&|jnaurTk^b|brt$k$MblO|9(n>OEbw1(T_j7d*w#nUI#b9ywm|{u(w;MHl z&fPUVVnL_D%wF7*6^$6>O0f=A^(g)v4~uk2KoDXR;EdbcQ0Jmh+(2^WX?}n6eb^x} znFm58R>6|0FRqEje---KIfQcMoOCcl9v3dBp*3MO85c9C!)}^5(#8NSo`d1zP}c@H z2WwO$OewU%=!f~wyDMZ}UFN{1DU3@{pCil1l^vPHPPePajroZ;uBCW3(cmDBVL&r0 z!lX`NgQ>)6JvA9xo9cE%exQ< zj}*;^bVMiCpVw~NZndr@Y*Y?@Np8MqW8GM6k2K7Tu5^D07YvFcMd3US zeZjC$3p!ilpVz9KYqzISl)T5Qlr1FZ(Z%4Uk((~) z*A?d$pmdPK;oAOXWTQ}67V#h!#GarEwpF+yZeAi}6WOhPtr0>MB-_OR8FK_Y2d)az zZm8Y&VeX+G55td6q)M=}GuE~yp=`Df>0fx9PMv9Y%t7D?f!Du3aj>uhZY5G_NO(KVR2NA<1CFCE}S zuIh<v*S9ZI=&cWREMej0hcN zn^v8pKKAJJyc{fM{*TGokj!`1#>nC@ScrCh&UTe$0tVvz;r+eOXE68J@ zl{oP(8fc5fy_+woyWZ$)qS9TCM=P3d!F*wp_o^x#`af7g;fw<;@U0IkMNdnPV+Yh_^|l*sq^?+ zHJaT%Jao{w&LZJu0~ zo+omX6>XY{6EDp=OEyQJbAKCJNTQ66b}Oz?&QM?~JlsY{UBbZsx7bisMs z_bp&Pq42830fu|8NS*67UU;;0H&KKo78dPlQsSh$xZLh-3UOOnE(y)c9L!3Ep1+hC zr8=1&BXJRHgAXW#{OQ-*zST$pZ`Vt%N95RG2x@55l@XdBPhu-CuW z;-*1I5$>vj0Y(9L7uD-4_r^)$u6o%8%c~(9$JYhQycW!qM{`0K$WKQEflMzaUP$Tz zoFDOi%{?eNixrHRwvD{K;#Zs=Ze(=EiZ!2wTbeXBEYXysB?rX*wJ8s6hXB92z z{;z3dIEzH zkkyFdY5aDNPFuqG*~-w&3s>VgQz^#G{haz0{RIUFHv#ivr6a7on&K0GC1(+O2Eqdnc7AI5zHkLuR;g86 zBS`BzN$#WCL36^kD z8t(7$8+0|;`hSe2h+yOe+Z0%>q^1@?fW;S^={~H`PZvnrzhjxiO&)T3kCAqPdl`0oeLrt<5(YR*!(TUD+hk7&i&ROY-t);oN%{D;`AJayqCO4J%zn4I%9w znp%IReTuZ0y0EIWk~Pm-`yGur+=tov9qJ-cV#tyf(mW+-q(5snK7hZt%BMt0E1D5r zr0!}M-pNRx#_=q#oA_w0z}YA;HbHXcHvZ%Wd5b7bc~{ zx^;vW*M0vn=U<{u!VO+H%`{!(2btG-#P_E2G(l-5VGvCs?$Y)caZK?nbQ0gpp9y3c zhikF&arl__1E)N++FAN>3&wq3_&+b2?zRkUA{Kz~v+1K>8L zWpn=%PafO~pYq90nA{Qb%RgsEx`yC4nFS#B{s8>G)O)ox#FTqQ!lc}sR+ZswaKv;v z3jN2}yKMG`UfB{&UzU~_uyzOX|K|mjS|ZR)P9e*gL=Q3A;+*=|2-DeR$>$l&oWQMT za0ignzW4lz*(AAl^ho}nkAKIhwR2jN-x(2zDgPIaX7cw;c~V?q{1`U92T=7!V0cIm zL#6+J5+wRj85SV!d@bp_`;KyXz4f8iPf4C<@58*D{v7gs-~gQbqibt+evu@#bNmUM zcX|a5Z}L@#qO=kJ1gB>&M&}2sTj{vhkm1Osc339=%r2x+6!Rw`$uIWl?r3!V&xJM# z#^u>>R}h81M3R^)gZnM1}8(5d+e#4lJmbqqaU zkrfgS@*1R%N9HybZKSk7C_qZn^1nSyLY@P3%ERyeaPD}VTmRm{&x8GY@38`a%O-)< zKN#KLpc>C|d)6e=Zz$?)>u!!KYz7|IOQFY*qCL{vR5^C2blcj;w<>zZ2)Caw^M8)1 z%sQOTLR-PxCgH0}vu-x1tZbo4-%p|NYFiZ1hOl-i9vf!Zc9L+w+U!EwA3;Df_-Q)b zmf8!gg)ekdAtYe4V4M1Mz*og7@*X`w*@x;k`2o9#``Hh39jen?9ZW`Dedfy>OO8lp z?ZogM&PDYYA_H#zoc-3sa&`!fpW~+kMAmairm49 zJr2tqB(itllus&DFI?00H3HLO$}-(2BMRTIqNQng`vQUNxBkR7(}Kr&mSzA<<`JXJ zECQ`xh13B)AlS^fFwnrB7*ZbdWHWOP=ZA6Zrciuo#`9PrkW_CicOzJ-Rd;_ZPM8j1 z?`W=8EH14RUf+=Fn`NXS)FBB?JF|5NQsu{bBdhN2gCBMFR07F5`K;1WPE%vI%F?q~ z<+LAHa()2`lC-t8TRw~k-K6!|&t4x}KM+)n8e^<`hr3t@XR^c|=E@F^)mF2w&rq4$ zdu;IaU6}fO|2k<}t8hR_J)uGKGlL=7!mRH6<%Ms6x(F9_Tf4rkWu)Yy-o(Qt$(AEw zNpeNoKuY&+y;2Qc%*!tc52IiRUySePf=0g$SS349W!`aiM#d4+U;XDs2mhzJ`s_KY ztJmRm&*2i7%va9K=KQrEuJ^~rL)OM7H87EH*j&Z=^nZ7>=s%9aek-rw^NRwBsOVwQ z_N18JXbn^6^{ANCHY#)!NVZn+Cvw&cN1Xf2t}B|_DTb59LpeRZg_x;?+QM$g@8%kt zhnmW+xy3wVdMymttDU1SZCCX4!-adne&$sjWLUzXDk`Q_ML6MmYY2|}> zQ;;j-Xr2vwk86@!&02&PkK2o)8Ex_@@=lo#k>WEC%!ZHYwpRn2j2k!caQ)x|*k-~` z77l2fGzm-H@K52vTR?r@z23Cv9zvBR;DKx#+YIea-zjsEhz}6?jpkjujyEx~YgzNC zDjE)>;~0yZHXy_T7i{C?kGI~LE&f1D#{3KXsU_fY`sq2K$TqGYB(Gpk!XSs8#=25; z*2df3G}JGaM!=8%{h%K|f4uxDA#+keNfLK4scg+N{Lzn!X+!F|R=-JRjsyEH!qy!s zN^a)Y4J^{?)Ue}b&y6VB-D(rH=ecA|xUTr;4vN(^p!hhMz4`nt%7X&^qQX5KoblSHqvyAJGhApdTvmdIsqwH-w5MBFzkbMy2xzFcqd z02qV~E(!!53!X;<9+)0D-}W{fU)!IxAcK&aHy$fDw(4_UD%RWoO>v^f0D1dM<;?W| zDo+$#u%lS;ltY>;`8^$KxxpoZ7!e{Bb(Q&r|Wg`Eq&1-AZs)w z+Ti@3@YwjF&j{Gb+A)5@=lxp%OqqQ~paQ!6fMMMeK_5`=fpHNo{@a}XLGPipxxasQ zC<^iA-P`NNKDPfRHZT&L{r@vc@BI|*82{yF}N400PoOOwu`^(nE61$7Uf`JVM=-xE=H-S`vxblqLH5FkW~uON?>cK@Rv zjcYyWPJcNQrlo4zM4x$ih7frYbsmSUvA`cd^ZV@*;X@crQeUr&5+#(Jq2HLY>aE{R z`w6gE9sB>NiGBq4+rZ=x?u^`T<(hEXG6I`)`B2**bKJ(5X6t+a)0q-QdXB#TO~_Ws zl*;E8t(F!vV{$-9$QiTHd`i-#Mz9F%3~k1wTU>g&i`^`C9YXkkxzfwN$9;-J@1a-X z_^Vw7A!g9djQMJ7Owbw6j5_Ue1K|Jm1Q>C?i~TNy7wA)Wdfs_oxGr2U06XXY@aqza zukZ<3Krmf?wnC!h0N<4Bn!1QUg1autVw~M64|3-|@?${MF9AICS`HN6l&R)DX36WE z^YXKTC!zdU)SIb1*_z4%A|AvkBcKqcB#^^Zb?Vg|lhEARd4{yYEAEJ)!TbA{3mjxD zvn26iILFzCAQl3VJ4jb`>t7@=y&OkR!!FQ}26_bo57{!N4J~IaPb)uiAY=U%kij-;N`;P{QXWOb)9@9S+86q~j4 zZGbE$ND&|HOL&8OADiC>!@Y<9^{_?&Za;5+lzu1O4@oJ|;Mb1GEc-9jW*aLexhGFe`PDCo9Ndu2jinjvsA z!g%NZNKDy<4skO>^fo%_C%%(KFmvMm0D8MYNy|!U@ijVk`RjNBXOV20tpxVn*uG(4 zT%tPN0lcR1IoL(RK7$o(zS3f?)n_pg+|rJ3H{hPT?W>!%RMj_zWE8P|VWpLcUQK2hE2Pi}Ylo#U+}sdcMPnZX#?YI{O8@Ys==uzXHH zx)1;4Ea`At?^~cI!2_eR?dT=+3I-QMZ}9d=#7(I4(fYiV!By||me;II?D1H+ZoTBWUgIbzU^Xs{AHLP~wtK)Yn>xH~DX-(f z|CMtBIBePTZrV9w?RC)*d=j^gSHY$6Gl={{)j?!zQ@-Vmy_(~a1A4!OUqp58bG?yM zT+*++T9*HslI82m+$$cq-81SJs69r_@p)a_1CZ7+X1;?`C zp*1FEtQ)(}rqh8XM*g#Y8})6zk~{CDTJ63*+B$z+!kj9#%|*;I%dX^X1c?%Cq|I_0 z8)e0z{vt`>YsDJ#ao0slUn*<|M?oAp$F%Cf)S3H1Kb;SRDP$;dM?C6wYx?l{J_zr@ zlN6SuoR5fM_zLJKdE?-{ykN=ub@I~^|4Ml7%Cme+IWb#L`f^JJ|&5&b%}R~Uu-D@{hf`|vZ@wecNZ-N&Jqih(AN37HAIK-&16kxX-}%YVuP421OaXp0@|_EcCyw>XKlL(o} z%V}4_A~tM9yyMJ{|rZkL`#Yd7f9$z?bwTRh| ze|pf_e`@IvJD5wB?m}{rH?0u1N86uHq#1if-udKiYjmi_)gz5kpMr@Or7tRlU<+OzKN) zpQ|XwzawCyo8&81*EgG9vlPn|q-=g;p*m`W-^Ysgvt^AyQ-gi7*HHZkC1?YmU_pbo zSUhE)z&Rj_fymJsT&bKXkfSgr2Uc$}K~eURNWCoF^Z15GCS{iwMzNF~?Mksy+vqU9 zy;GX@_7><1YFf9aWUKsue_`HbbqeyW4G>~YyJkB4H~yw4ru@r^HySEVE0(9oh528_ zcc%8g?*PY=0~_EyYS{T-BLf*+Z#Q}KUY5y!zd-E0lLdGIuW*Sf>;BY}RZ)zzf47E2 zfUB%JWN%-=7l{u);`wK`W8u+ew{EHL-Qr;my_LT_4qn@pATab-?{{_uR+>*4!_Au7 zTHzrII9O6I#TPl*zLBMSMI}tQ#oPP)lYmy~*q^CO;oK}uvPW&txb~d5Z?{{LxreK} zozVFUm$H`}LITiJSI*sJ175p|>{vt48w>o&xA;h5Ko}8;PFV|`z0GK|t8so1Dl(7k zKN8Y;cmjk4gnUkQbOl&om?1dcs6%)j@m1u{yXQ8V##I{TaOS3cSYTAFW|HST6Iz8q z{=5t!U$d``N+@sG7*4LJvp$s)cEnW$2!`NmF560D!v9;xPL9QS_a`f7CL>jJc^_Bf zMpI@k;JI_C;|xo8xi4h1o_z@aE@a|^IiE6|uv|jrVIsjH&x@ zwn9Jd@1`*Q%|YsxAQ^~7`e{aA^Q$gcaOLTDR$A6_TGl$ZkNMGqiMxASnNM)AX#?xa zt&Q2sAv(a z6?pUu=rF0qZ?eHAlIf#m6|pC5wD$M7<|f-DZqT ziikI#wT4V4dao^+u$dg@$7S1b@F?f17wkBAM6c*E^E0=!$l4C8x^L27YikYdGbO_a&6nTV_hYVX%dhPid(`3f_f)eZ}Vd||WLRjx~Q zN+0tR79{;FO;r}dNl7kYZH;yo%>C!5Sg}O zHxHs-X82_H->dUt!#hw!xm|6LHLBb%e1qrK3VMF)>pL#m*D|z+$0vn`csfuu%q4q= zq9r&rnF_Fk1i&Gm8Be+546QXrE_38-k{mC@lB2fA<&sgCe9($HbBF;=9-1eH&qyA} zf%+%!`B{Bvmwvi=bV&lNT5-s1SYz27`E-l<%@I)(xwy~w;%lSVs(fVq{z`7F-52*X z<*$R=M*XehSlhz#@Y?Ft8f<|e{3b1`)(;=h6O&7<*7*g-%Q@-rlxODA2Upw0&~3ZE<6 zr`usoRED$8kV8)VZsDaC>_OtJ^JA%{?p)k+5?h z_d7jVYL@L=+N8!HB`v_D_r^J*}+yhH2_WP);MdL z#xZKH{|%N5e&pS)ifehyfy^=#*_Y_4{Et-|j>tNVwW`f}e^>mfRtA)5v7$5~8NulF z%NM*XO<^7Mf+%sse(v-TPF1BP-nSEJFOU+p$@DKC?D{Wb3l}CJpBX@lQ&l%(xHQ~ZE&Cph>>RA7PJQ^u(Y20wN86OZ%7EPD7fJtV89>1bLp4afpmtF0!n6FGjmHA%zKQ zyi;udhLAt2^zZ6q4Lq$VQv&kpXzXDMad{n5G#O?N9^1o3;OueVA8(L0FH28&6Qs~% zqc&$Qlfpt!-J+8@lI5ckgvK2>Q2Q}ekFjWhlAloOQ%+zhS4bW%9K2T#DLXUd*!8hd zV^-*(IE~jatfieT8Jc*Pnu2(*>H30yRz&RQtVIY}3KI+y(mBxUw>j6I)<=Pq;4!x5 zG5#8gILWZ-P0|FIIL8*mJwfn8*>p$CwUq%fQqvkCS_d}X5DT7gf!t(HRHTIK!vU<} zIZ-GFy@GuC!9l6QMlf{1xi$>POL-+o6&4JMh*V}WbZ`LMVjF^&Kn!5r^J-bJ7}=hz zK7H}6E_Ik2p@NN$R@SJFVc2vGOBX-p!h(xssfcFSoWglE?C_>7q(DQSUTXMNvDN5i z@8e4cLmxZnwdV5gHOlqmlx;~MpZ56#QU>;Z(V+hvMmCP3km55>cTb;gFn8enA1EKZ z$mH-1#ou!BWeGP?#UX^{>e^JKjo1!9xfThJ^nO)ktzyVY5C4Levt2JL^1C=EUC69g z%d#z={oDS6f1f@FmmGDYa+e5R#EYYX>VLL1-u$AC(bFwuZCp0nUAl>Jwo!%`3+7&F zWA-9G|KQ1yRiw0|W$(CBWmAo(7EU#!sg=!N`D)(ocVei^k=&6~y zFgH7E(RNp!{vQ%Gro(FDB!BD3UQXC}(1ajD ziGFBX{we2XpCwgH+x{l3tx;z87nrAOyFgGM8;yANboRj8Q^13ff|2*iErwqD@%UEP z!rnOXQp-8P$u}J#^zl%tYGcXL$|U8~-eR1p5v5q-sKs-!C6%crF@6XXx!msdq$~WV zA3JucQ~pE+P_UdY%h;$$Wu#f9sG9sS&TEG_`+9YdO$vme@dfBmSc{+R=+UL?JtSPb z&ObXHKG?LF1*L~>PEg(IUiu_+EZlt%cvF~VO%ww z@P9DaZXhcbhq-9-oMWZvX}@D=J8zli5Vzw?$tvJ+N>NsBldVy5N@m2-IWZ}h!^g*q z)*Psf4cJ_L?yW{iQx^7T74FR!OE$!?fpF3;8dE|fUBNCUC7OS1G!&coHCu)^-NTJ7 zqbnqn^}!n7(o*?Dhgc+5o&60f$i6U8x&e|J-aZlDS~C^ZRxNdiP$zoZkm|vOy*fYAmRYJLu>KkQizmehtn&r!hkpP8`im zV!%P%Dle@S^}qIhNo;^?K7SlFW5%z6^7IqRINoNmNq6d|u6Vfl@C{2&8t!W#WtaOR zI0=sGsA6a5?Jkn_F7(r}ekoJO#L4AH#ANo4XlO_wN>;ov5IZ@D0;iz}2`b3b4}1(J z1`Q&XUTY=n8u}dCI+54&S!nH*MBmOWiqod@N?NBbdC{8?4ADySXst7Po`hHbS%3bQ zQli+Jz8lDBc)Qm`<@YyEI~LfMj$Qt|#g<6}BK$E7$lYUm^PdK*x*mSIV86C|t9P3Y zE+#}b(?&(6k9)UKG&3{2ef=Z%ZXYj}=UUde_NrN9mXk;|(ff2%Ov0ZJEe=Z&_mJ++SRh}9Lv43GBZq2Tyj=TL(-fAi}=#qOA5hf`~7J~gccsy9X zE8`96>8qV36TX;JJD$R%SkS-%Mhq@P(LchsC3>_bp8$L$+E0@WPdmiRzy~{W-N)s_ z`I6GI+*!pnhoJnsdKCF8H9Q;+Aha>Q7uAn5%;S_VGj_W+4@YwrI6D|&36Re(o(J6? z)RX|2)3qWz=}povl1P{tgGd=2IfFbaq43>L6>+iPMas0kH=md{?mq1l)$2}o!ZnQ- z{}zUY|Bg1gU^mSPPEr8bdW}bF@%s0NDxoRmNc}H*WipFb*OByw4HWY_qb@n)09hJ` za{n=jmdZ17+22UE||>c*&jhcaHLQnMhA8O>YrZRB2~I-T{nKxOp%c? zmGTWQd3)(S$09)HtOdNiJOe&L+)rgV;u!kX*!MTuryFEF_=e;7^GO$&@j-*I#C{_S zLnT&l;~+i{N?;cp|inkLNI$?`1h`KU^m5JV$%Qiv;TDgajnH9kzakU)qq#N z6Bp%(1I$D_3jK$F56pL&=6LH20BT#?+8$QBUUd8tf_fdW9e#wU?H|yA_3Ogi2_k># zMG5pV!gt52h!+SM!u)7o4laX*v=*tctzVwRK)zGO0STBs> zfWZTs?k3ir97vNAfuzBT+E*8WHpIvaH*y6q?p zOS;#8R9-qw)b5{9jZd3~hcDQw+C@BE>#y%$EAC=KCK*z>@k1i?k;}0}NRR9j6nfCQ zCtDY9K~RV1ny?oxXY<{20(k^doWIB21BEPSrd7;wtcibYbz`)ZX0FgJ~=rZ z2&1HT%N~_W;7r2K#lg?L3p+aGC5)Y#o6)`fWM=Ga9A*H`C+#%|(|Y04k$gEIUg1ZV zF)qk2#>=vQU;x`KXn^t>xROnt_i;v2DRGaVl-3MgQCUET5meCk1%)o1e#fZ=dPb4Z z0Gm3L`?(x@E&}6EIuZEzqzVt4WVA#yT6kh%uLy?RSpd}3#wuTmd5A3s4RLC=6t z4;i59pG-@P_hl4Q8r2w<6!ERmy@wYI8qS8u)^_t99+VI)IT=WexR|+Ol))dR7N<9% zm0YVuRqk)`#(+gL;jp7mAWf6}A)_#EEeu;^Ope2U!-F$SGy5Q=YffyY%qkqEDjt2G zhI0a<&@F)u(VgK*4*Aep0tc1kPW~|p#g&vzKpnWKn%M_Cl%-*wyf3`=t6~NJ(56Eq zWs)ReYVzChIypL~Zaf1+`ina|fvNX%Bn-&N$X6-v;DGnh{O?1Osc)C7d&~cgrZ6Sk zEat)}jht3t=1H3qF(SmQQ>wFO1KW+5wc2J_FKo0S$`?vy%s_F}U7ks1TTO+kxqcn3 zJF3!}zdNPUasi|#>~K1g^@{9-;b6?kNU%VbywGUm9HU}^yxI3c)r~R&>`gO@^{`Pz zYJUVsm`HU8Rko%d1PqP23auOr!O8CIc8m!FN%AwzzV^Q`g$26}ld$y02}?kJ{mPN( zcj?I%H1ygg(r}ENVIfJWS0qvNo4zm(`q8#~sBq~Tb~STeC0`WeOEx;0>}hITPsGPQ z>(Nr8Qbd1}Tl6c+zF{?;q1CQWsL)*ID2F3WO`oVyiWJu{*pQs!q9yvhgWJ?D%GtD8wWrda-JTq|NfxV2wc~lHMCNa!HNT9f z9xDNvt^}cAa~kVg#$2m@9x)ek?nM2t-_;&$-97WxxXR1)ox3N1qEx1eJ6*Z@dmDx3OsjmUi$i{P5PG9Fl%VFZO_5PQ z%$QqHV&QjD`mEz}5=)319>vqePnRkURjR9+F2^zy5PL7ADJ6rsSSiM$39=L<)O+~} z5QTaPf3-WDZnaZTgP#m(a`_AQY>F)Pnx>Wap~)Q%(Z!`^I*sZ<25mp2U6n|og7lci zU-^~($?)w__Z!Cv=LHUK*FtFx?K=D3lpE~EzTL+XZeQV&&K1r6U3hq(IJ+xp` zn6rLIOXy%aVg)>)!89~6q|5oH>m5U+bhGzLSet7&&hBB<`9f+f+>U(AImkW z_wpkdw+01XSw>iU7Zmh4epSb%!eqe68VW)>ePjYF5c= z1!C0Fgz|Mg-0XgbD>8Hxty0zxTi{w{{N`xMe38H|&&9kiEOob4OIg~{AgXpRcTnP< zcKw`b?Npvs9pNjj`o)}my=bCRvTVM!!#YThP|46u7Zc!+4jSS z(8ZXE33-3O@i99;F9uLM-U%M>>~jVyBCj3P(~diRF%M6>bB5*M9}Bc~^m}m^;JS<_ zlq-mb!?fb9d+Mnf7fPlN-!p8_bY}HA-@eS`c94{k+y`NnTWJ|k!W$JDq!3Jy2*dsc z=#*CgjpPU5ni0sas*+dOa>T2-mH!Z$@W`{Z=W2BsjJ+YTj1zY*JsTN?&bU&s{~2NrUSp9n$)(tz9X8)O)C~GG`hgC0CQa zU0DC5368X^%C`LHWO$9qAhN#ygBdar?+`$M6@OPTzy8TDVL~Qv53Rqaxw?(~l^%j? zjzn5}tw^(qkJ@ik9ov36AT8arlEq1$50S^#Sj|!~cHSHNU6t=W?B^5%>LD5H1pRD# zYISu~qZ7cmO8OP1|{=X^Rj){+M+j zoWO~+hW0p9CZHL+#NXU3FJa`RDheec|q*O#Z3 zop_nDT6uYVN&7>0~~U8ZN@nTu@-cU3|UGVL*+`g?jra^Ugl3}7%J_I+T9 zaBdhhTD`FfA83p4=(#XWQvh#*%m7;gNi7264-aW+r9{ugp+Tw z9O2_9UP2&V-zc(jC&L_^oc=nSwbl)*GjSUSKEHV>zbRn%*UKVoX1ADp;ai6-&6bgt z@~|k*2X`g-BJOPq-#Fo7x(yeh1w2lZDuXvN?8Yk%JVkhpeMJqtx9sZI%)&VYJy{m4 z3_yv7JQ|r_>H^bbx0uW&Ddq&hgZKzN*@^i!&vD2w^G&Vy(WGcUdvwqxvN}n|7&BJW z?+ypQV9Xx%O1b+2ZtPGH81nLpTeDijP5h9FR$-mifyi$-vDN=t&b@s;~r8 zTRLgyoDbk0+A8KafG9Zm4b?}ST@$sN(nEDQf|!*lwyg0paE_@@G=fZbij8rg=;haT z6X$XL-F*Wk&md&71|=Rx9RlQbL^@nM+J7nU=XElUmhE0_0^^||Kn#*2;DT&xpbEwg zGLZ7HvwY}mWa9Z-%rhT$`^7j7;f*Tlw}RO9-rrZR8XK3bLej$kQ5ufO^AC9EHHayT z15#Z>1KVTG=|e2vZE9yJ9newyjfP zpF9%4A*m&7eHQ^=rz)B}=hOP}NO!lcjavKk&JDF*K0dhYjf7KwO9Z&)NJ&Izzpb7o)>L^s@Lrstl#wi}&UfB{@) z&1sNuv*eu)G2!rZ zk~5Tro3EH(5)ha-NDzi$xep~$sr3YHmE)1hg9=$t|7;;NX^wnZTI?3hcan#M=Ozwl z_NPTiDV1MC>iyMKv7U(LJ0o(OJ|Cgt0w^cOHMwoNd2Zi|H=Okg?Ok!*5sP68s*gxV z_+z$=3X7tIM-+ln3w7W6%ja#lS$6i8UF#qJ2JZA=)_7K?hoXJ^3M=eT0Hr#-j_BW$JV@Kf6~3F2%Fu zbW}tC2sba~^2w^+e*WSELxUxwOLYBdaec__zW*u<3cF;YxwxGqUHuaZ86(8C8TJ-q zDNIGHVDhfb{H3?`|q_|KXkXz_EXW6idG zp7!*hlT&Jkm8>1P$v0BT0@tbZLSmfI-*-#n3A+2K@ zW0zx?NES+@!gRS8s1lY4dM!I7jGB{(NGr|4J6`{ePFwsu3nCSRCiMr`|6W>C@b8Dgp6sKPqI?!hmrH3Eq4wsmWBvJi$JKW_zyT zAv&qnmZDWDD7w-hx&AtwY^qtXRB+%~9j2Lw0f7b@~d>$&W1CZ>wcYhLui@rldMQv=3r7H9B2nj)LZTNv_ z0Q656fE`h1rgV1;0i;v_DB4t6VE>trkkEFeAsk3b9^Nug-2UeU$k6wxJ2yyq#cuOB zS!l{cTeeMZdii7b{Db%?V}g#~_eHv@>(u(>aDP6R#|Y(n&-3nf!9Dgez6QabfKHSB zF0i*-n3@K=9nT5!A{WO1H7PDiAh++QHeeI|@yKHgZ6x8#%cgKxS!-62KxSB)D;8ln z%z|%{Sh+rTRd(oddpfbcMS#wv#dP0r%3?fIMx9!W)wEsAm*TYRWwr%glHkU6ceC95 z3=A#)9KBBZ71@^S%j9~)b>a+@C95P8?dvqVGIL-$?NO`$D_!fyT@#b(N<5Ck5j-rt zC99*eKP}+w!Eq$KxcUzU7Soiae_EFUTuJL$E z0`kRz+Huix#w~xN28*k|z}C8SVd#6A-~YY)lz<0pzl86~rG4lMyxoANy^9!N4BfzrkH)qYw$8bNOpGGX zQ|SNknwB)t)$cTKR_KU1!bsfNQH>B#tS5-v-L{ajjrV%%ymfAEX=ev2Ee(hKfb6)N zq;Zr%D35C4>dHmg{+VADNOJy@9_)SoCx{;>_~IVr(Y{Ssp;`OQmtTSF`RI8@lGf{b zTH>7;&r_Z?wjZSE{`h(k8;}`|KgtO2e_NkpMf(@-yRc`+Z**4o=;&w`9-a~P@%6x7 zo5(IJme(T6WC4S1W8JUfx?ib)uNobYTlzUWJzb7RxAHSmWQkVI+@1qmV>ANc_B=1e zN7x$o6YY0F?U(SMkiMD^q%?n1DlN)k{YK|tT#;TgEsxjcvMd=`X-}>;$XHvGq7ae5 z^$U)=QO@#{dQ!PvjS6(;RNvHX0$Gg!jq1F@j;`6?nPsc_(%6OYD zXBRc9-3;^O&|tvtICDFNcjJ|dG^N@QQ zifz(PoTH$por!bE^cG56DXJWWSRm1Ge0D`h>=Sn%~m^9~b7dgx_W5RzeP0ZROD__d_ zvZX5dpeKI0b`9IH4I~60c!ya=Z^q3&dtTy(kWB;5Eg{$3QD?v2JV3eQF(|=?!i*s6 zjY|+69QU7GY99HPbY&<@jf;3_U;~RNMh|1K4qy`dec3W52^fY>MXl{B3hIL#hhn+W zzxyU*;ey1=tk(N+!r_?qlra*NsOsU^dGML}*o&TFQsHmv#WkPiOl`x4qj(r`S`bGe zq0yvN3T2=+Ul|ckDgxL+ab5af+wJWdkzsicnS-E{vVnY+v zUn;f)W1MMjIR2eeXJw*XHE-Bd_EK&8UWb#YWC$XVn!aNTFjP#N9b8&MtV46T zHy9i^BvdAsUce~8xGpJfq2Fd5?U~XA!9kIWblf8~IxAnmMv8&OvWe9s#b4~uh;^;J zMGPxZeOOO+&mIkyvY4->#XRcWz0f*(Ufk{oR$1Y~AXN4j;YLC4eJPZSBmN#J)~Vr< zYSYg9S5`7BDv?u zw`Y`4WWpZisAY>u^i5ET{?^Y``)ve+dx+6whV8E(h;lnRvRZlA|MXvk^&88|%g@Zs zvEjq9V8CA-1Kxg20hE=l00GY5o&}7ntbBaYiSdD~Fq2FG;?VPQnA+>{u=stMXx>Y= zxuyVn2Qhvi@(lb`)%>lzsx_j~W?qn_>$q>*sq?1N;bIddAhp_e_Y=K-dn!<VgQY^nM+=;9&eBc4$utaxAzvMs&LHuT zEvf0pD08CYrj4$#G+ZKlbGmw-yaDv=1%y~ry1Nh`y)I}yv5;cMKy;xjPKN`EkKUj- znKVO6C0)MGvjwk`o<`bssqkmUN-Ioy2DXw)xi~45r9riL4n1aM#YV%jdrz}^q-xsu z-co~Ed4FKi_?~8)k{p8LggHY*UZSK{-9bxxH-v*=sS9~Vk-rcEQsg|xmRk}{ovf8f zOF9pt5>P~#fPrDgoXdB6oTbV#akfWr>YK`Eyx{g48dZJeT;PBbvQhTl|ETZ-(f4 zCj%3S*2-Ys@=!o3CD;5r4@~oCD+mS^DD1MF7!0H!F`J(>ZrRbHu)FzKy=;N2)!bL? z&Z5y&W4q9r(+9;u_=8lDFfWWYqU{JN-j-Sg$=#S0c}Bx%GF`Xq9l^z3H@d>Psx*pS z(j9;cJUP4@=QRC$Q6d;b)0e=O37I-k@0IAOOq#_7PUQl<4~3?lHG;BjSo@5ZI#nY4 z2~>s@rPKMP3kkrFkKY#zQpV;#5GyMy&A`R~0LT_u3yb}~F0+6R zpXBU%kOL~YRiF7=6sQt>A7^v+TymZ=^O>|8!rpJlCgA?Ne_5!NvM@IO_V#-A#?Js# zp-2Nn5TC}!$926ALB8+Jc`^o%Xm6KHZ^9-8cw#Mhy}iAE*V|I=I?nvskM+*BHr`$~ zz?+{hM-@h3v0?|cYK@`gH2QPz;$nS8H%v!| zBp;xSE63{xe2q?48sAqrU!Y8C=Ik8L*>NbB{EQdU4eaJ>@5xvGn^J|Wi(5Y`KXMY~(7;^>=@O`|@2J!WvThNjfKO zEG8y0QN{j6Ps6T09NOl|Vgq-!@1@l1jlo;eySj!(z#2QUv$Ol>O#+rmHjw&oimor` zLN5RQnB!BCi{~nP%F!i#ti|V6sKE1>qZz5$nHk}LfH$qiqf^^%|2{WIE}^~1e_e+_ zqy;ex673}|+lmj9#aE2E-pyS6C_r4$9ELqJ+U8U_gg>F)0CPEk?>q&t-E9AIea zkY?zvp*x5AuDPG@{ljvxbewg~oaa9F5qrb3e68&4HpitXGrdo#ybr4T8ZW1HM{hRU z)R>$Rd#fW2@4r#ruVMi1R4!rRVOjRpZYj{&OJGva9Ei z4ebwyKucX~akTYGN-B&|-F^L(53$$1+2as#k9Qq5muvs&#wjA$c)3;2Yb_*i(t2-yAJ&t1 zF!ozq=yFQc4_Iieb}weX+>$Dv&f|Q$mFzmB@A)!H^7gL%$(NAbz;50*`iJsS%@Erp zZz~gm4M$iOa$2670xx}WeeHU4vR0D)O1EKB3!tg%X!5#260-bkJK30{hx>BRTvI9YQBKIF6B)%bXvfDss=EIqn;CJl1vcUjg zXzSBM0^G0&37Xo+hWh{!$H2P<O|xMVLjDI`AS#M>Xti z>ZK(&JJrGF-e(n|DI!Ij%+`v71b1qL34*^*j{C_glaE zGM%Q=Uea4&FVirvl-&YcQNdPkzaXg^zejs&M>AGK5-8hzSqX`HwqIXuH3?yvuOs~p zd0$1FK74jiJ9^fEisv-UJ>#?y#p`n1dfoOX*2PBUSIYaRXM`-d4!0x=?RKABU7ZLy zc{HvneRvw)3Nl?U{V<+iyI3pxkC1Ro9NBr!f;^s;e0nF3+Y|fq(p{H=sS{NgAOVL; ze@t14Jfp3&8i+OUb4WfC2-UOkQb?f|;QR!tJc>z>dnaaw4LvVK=?I@bd9bENymb zXG)f9RTTck&?#hv>)jvYnrcG70O*{nbqi(7ylu{Dz@M5tuYE>hexU(sAx?Xhzueqn zZARx*eAeZzp45_!U8MrPlAOXI?0I*}_Y#cjo!rzG01s%JCaQxQ>g!<6msVx7X3 za-k8vj*7ggatZ_DhKdX!-+tF|AOl>!k(GU3!#;69_Ru9vevyTc~ z=>-)(O3Dh3%Kt>(-e)70rN^>K9`1(~5oo_6*bZQoj=Ef*6k3Ea^hR{=ouu?~Fw${? z!l!yU_&KC`;%m$DKD^3RQn@piKQs!_|Uzs}DDDHA7n(=^=X2mRa7R>5gsMD|uBWJR-Q5y z1J2?RMRO6jC-mH*>K}P|2_k#E?oaz5*UP@QBc5%pI-o#b;O2w?C>#@g$TW80&|-hO zrn2wh?ix7d_9E&mi84a>CtW~+xyJyC_)|G?NzELKR1C#uOi|bK2t{~vb2E_gk1=t= zL_+~)sYeOjZpI_HhKiSO|6u%LBNc_#qC6)vN~*YDw{d<)oGz_0It62rOz=$wcv z6HuVn!bI+=5i&6`Ny$3doqOoYF|6f$#1!am7JZLfF{us4y)J!n*9}KGV+4jyy#@)& zSHLdA82?!hH$0kIL;uXYVq9ZQ))T9;7>USBh&x{Wqwbogbx^ew zJbL)Y0cvp}t)lw<^Hd*+2PZP*N~V&t*4TBRe2YpSd17|Ew-0 zLl?Ehtt!G0mR#hG`LW7Y_Ju?IUtFV`eq+gry@g0Us!!D({7ufrem23oc}>A>38OU| z8HrOVWCJhI{4>K+`b%-A3eV|AblZE@4{k};Oro}tTCaD+t_p#XE)LYm#=hsAHtFhN z>ub^U@X1IeOV=#{PgbRUXQs8^BDwqxNpY9V4=j4E)*7!mZj2cCi>K{>C#=n1Qs{iN z91Ys`VH*P}5|fa1XwFDP6-Oa^Jp}MLj+3=vw3ZpP4^Q;^1&EOHSVzx=n00M05uy@y z0Ew0n8>FDG*_S#?GK{C*{&ow>xE!EJr^)F$l>u>{`0X{zW-F~Sfebd8fvYINgaHp1 zzl5$XZ&}iG65LgT*#avzaZZ+G#u*|kSslHy*`fdnQ?tp7UWTIUQGHKpw0%vng#!D6 z1bjQY^>X_K*1vBl;DdOl;3CI5+0R;alY2@n*L@<@0iQk6jm$Pt!Ilks%5S=WV)lO7m1<%$Q|IQ!j zlEUK>daHIWs2sM?jFfMPTJ4t5-PjcPL9?%fTbFf1OX~QgBt7(tp3j64tS6n-{c*cg zrq1T?^H4#<^{4$S9YBhXqq|8{E4)|+CB3{3!-qpxuEJoMW$&r{&a+4E0lAi;9Bbyz5al3m3W=tkxoEtxCxWIba%sIQ0 z007C&!{Z!=br_dawbp-<_T$|#EL!krbv=^ZVu9z9qI*m~L=U@vUVOzsHlJ=*&cE|Y*D0TiOhR6+a!;(k(AIFt8av(Ufx=PjB z+DeF;ln~cP8JKb10uu&y=ZVz%Wu;2L8@!gw9$k04_aXxTd>}kyjuJrstLEUf`cpY^YR`L^`jmQHI9=OPZtc^j+1jDp z`Xb{GrMp{pbGrXY`|kp_=aUknLZtq-{mxCdc%j~X$`pjQ2Wp{JC~xu@w-2KzI0 z{^VtcB58Vm9+^UYo%D_QtkHya?cql_72SkNGM6{_i|shlLJNweb0Kxd~9ED zhN;OskkRso^5>az3q-bSTd%$k3a)V&sr>4~s>b|XJNwrDODS}X%)=*9pwdN8zcdL$ z7TkiOGN?_d#lRKeadUW*OZgBE1lOFGySsyz;-ha$a(uIR(raC%wFF%5&&j8)E#OD-py8Ib>*Ssg_x5fZ;QzErQ#2 z`lQ0MH8PCCCww&U@w^3KZPYcU$pqZ`O(cBjmZ%JG%waZPimSfyEONP=) zi-UtblVcxN5;*oP<6TP@HegH{wY)6ccCz79{D@l^jQ`E(gV%Hm>;LjmUad+1t>gH0 zltn6_vOF?&~9zkWKi0WkdO>%v1w#iU~Z{ zDPsC|_xEedD!!eaAItMDb&KN(cfVk70g@CLjTaNLK{ey+g(44(*|+~J>sq4~wWIH!6wE#+<>1dX)-!@k^zkTSx+Dw^uqkw(_Q0l+|1hm5QBhU8qqaz0g$QI#I z+ns~Q!7PV}2&3CAKF(G2wqUQTpPymx_7;xUAM~)teVql+jmV0xTJl#H(k6g9@CJH- zAyhn}j`D_OfrW4-bKV)9b|1-RDo*gMxfPOjsGDyBEY~UTU|O1@Pu9f9|Rl1oIKayNEst^hDl`T z$3YPjCjG8+YHI4s?L10RWhKV;Py6$ijC881s&aC2|0-DKTYY&o^_-v082FaQp;Hk? zRy!;;?e&Ivhfz@;i8hu8a70Q*n*^kpSUkt?ho(iM5X8sFBhoj7pLXhz`qy~qbnI)?mGE6|1WoY8?1zB z4B@9xtldN0m{i-KhTr$iHah9)wGWUo@2W|oZ9g3fBl^rOKlQpf5&e?5>5R%jN8!Vt z1+Zk9<$p3;dKRr`3vu;v7@wh!?PrrsPY1$!j9veLzalrMup^*0e)%vI=da^iURF9E zacn5x04zLnl$}2l`JwaQ?aA~^ncLcs=YiP6n{|H+*cUn2wAGLmHVC=!==z!GVfP@i zJvOR7?xt@vY@1j^jfP^|p2Z)oogtWP9-jHdQFNvZmex8ChrCY~9d+a$R>2edXEs!U zUF43-r48Qxt1&sMuFkwK6Yv>=t5Af!g)?2J_CPLSY|?Dt zbglD-B;u4`9j}b$#(;h-9Bv~%2;L<(g1}47Kyz)dc|m(SCEuyEWxh&;6s3Oxf?I|c zXp@kTcp;8WoBy5HY7mAOfQ(0hHkO#2+}@wR1OxNpeD;spsX6OP_9phOX}25Bn}){)M@zU7d)6kaF}?Ax-1S4-Et8urWmqz>PUH zAM!i`T)*FR;KrQa6DRif-rn94N%t_#nEzyXJ+_&a4@T~-e&HQ*btLaszM_m91KGEg zrT_B+kW7&(Q3=Q?{x(W=BHnnYyP4wLROyn#DVg@BrV^NyZz~GmOeLkH=g3t4n3o44 z6-$^pF6u%R_Dfdr7UL2JCDUn1t7iO2SLvLxVsB1Xy(;AF%3~i4s=#+(70_h^N%%(U zgqjHq^yiUKzd)OdF#eg*B%x1u)R?gk3{Az49dc(Pt_m>^b;L}64^CD=nMvIZ3 zAw?q4^3CqP#hnT?`#W{bePdvXnpjkD682@akM%8F9barL_HFKK>Q`#J`I^L&Rka zjwl#rOC=S`Vx6lbx`$4+6o1S=W2IMj`ZD=ZG~1`*L@PWEj{eQ(b>~rqiLkkh=OGWoG@ zi^-}-h{Ymtb%2)sCj1X_@GBHWe@HtLRR?7P6&UlYWHdv76Ix*FKwlKTUd>0vOhO-S zLagc$&F_ju<7!WyIgu@d!aN)kLqGEE-zT!={CZ1Apgu`L@IAryQ~7!K)CX~6a1^9a zyzb4EGhk_Z3cch1kaHE^U@uS|(U5A#vo9o+Es8LkMpn{)-QKo9ki$D?`)Pnul-z!A zes#2D3&~cqvawkQIBfR2>tono49ZQw!?q5XWhk?6x*6;=tJQv~yo!+cN)U6x3ncL9 zp%BmJq{6Lid4H@`AV6Rlmwi!uBXcaq9&;qj2u;F!M z)Yh;vf=Y7xBoA%<@m{ikHvaljt7oQN_L&+@tI0W?b37^8Yu12=%<=#|X=y#)^x3uady{{G(OGJa-FoS{>2%SR8BrPk#nNL@Du&unhWNV4<_j zHh&uiv+8twnux1=AMr=dIg~47m%q9Bh^w}whKaeBb7L^PA<)cRy@g0wc zr>XEflAWf_Q?dp4=@>$_5E4F5MOTQ+%jfxJxWp`<6*n7_lQ2`AE~Lsj##Lqk?CkNo zk|`S@N-n8`_g$MI6@M%SJ>2B0a&`%0X#1(6~POVs-hpQ&gbP^GmA z{~VhggtE>4qpq_H>a2ZBF~oGp7Hq_kU>0+19*x$&3Fi}bW=VSK*!-D=)}Zazh6PjB zOGWgB&AOjn9SZfLP{>!^KBkgvU$kW&Q5n1|W=1lKX!CAcBjscM{C<>CBohtbiEbvHX z)GLJwU9hN3bQCwAyYg^Vib5gd&rD5t3hd*6Jo;<+hNI#|MpM}Zha)hV{Y`LwI|p@j znO95rCv>!=dBV9MGJVs%3?d)g1?Y1F#cp(JK4$^5^^&xZs=B&Q1Qe%3*E`-U)J9_0b4Kuc&?*e%%bj=Sw7g#ARY{anxwVBWWO z3$rz9J}$EY$q752q3wdb79L{kW0t%Gq3cCgK$}^))XffUhGpIvWUYO2QXX8+^FgPxr9f@)bBMJp)5(M#d(y;q7xp;maw~W!31PKTk#<=R`J+ zA6nb{+V7K}&MHuAJlACths^C3dg~9D8nt*GmpA(Y4*G6@j_hw|C(6phk>_pe%3bSH z&Vi>G=HEilB_o@DlLT?-{YKz@j5pAU^9Kk$R_#Oqs3X6!GDg$D`}2y~2jXSpma{?T zpHWe%EFF%>1(G<|pZkKKHoMuyZ?O??+v`_jg>PTuC-koGs|fwS)bN4H@L^B$_Ac=0 z7>Gdhz(Cjh6ut)>`rNUGHz9_rh|cY}$?*j>pFjK~5&(n>vwWWSIp0hqw{>@Sqdo14 zJTSBYqTngQI^_q7IlekI+k7_$B1mX{3>iP|TnzlDO1t`Ez{4-~q(x}JxhxLP0wyjl4P(wj%H zwWk?d#(<5Ur?%!LgKSHqi>agI_la|wa~Ty3c)L1S67MvOWqz^OuMpcEkKN{;PY=I@ zv>^v<*Jh9PApKkP$~yi>C@s*i5hipg1)hanN%QHa!lrHv>7!joU2nI!;`3Yv{vPV) z&xpQjm1nu3WM?tTd~#YOLry;*Rn=|Jx3{YG|C6j4vm*$G7|DVvUmORi6ia}0mfSN) zm-UVwo*R9TkS?6ubb(-GahMy!-Opl?7G7zkrPJgtZL*BWn{o@Ao4ontZtZdH8Frb^ z&lz?R`MpD5Hz!M(Va3NfTFtH|$!plW9&EH&dal~9CgUxz2Em2cA!U&?y1IH(q>j8N znivLiN|E(TU+yle*r!JELqq2W$xx?_4!%gQmakc@shJJ+oZ6RJG3p+x@e=WMVk17$>(v)>+~vNuLjq zlF@!BfEItBvU)J>kw}jWWrhafUY+gn2%l6HNa z@TmPgI8$HOFSnxUTbEi1`!9#GQBZH(d|y-E@O0xhioQwsJj_*~^5;Rr76dD*tXF$) zeuRaBomrhHKv8V&_jCEr4m6tEJx=t~Ra0@AIQKg3GjXPq3&ZJiPxjyZSYnmXfr8UP zth(~Ak?;l7G1a|k!`bo8hs3qMjjg21KKnLUW9F@+k6n={+pia!G2Qp$(%h$HPs?#S zNjnp4;(p}FHd)Ty;+Sk*p*#Nj2mWdq>n9oVQit4bIfKJd6`7Xd9<7ths%Fhwf8NFl zTQV(2Zj_s4qTBiFCve+V8-Hqhv4Z;XD+-?-YKO(fzkuO^RcLer*lTh@iZ0u3_#b-% za5Soblht`G;5Ioh717=i8F&R{Wl;cQf&ZiU|Q5#@|)aou`#KQ0Q&Y+Ad#Wb;$dmH*V}&pT{v&x+6bf`Ribe!1PQ zP@VOZ;V@RVmZvxu{T-u959PFq_jlk)k!N427InhuQg^Gko8^7`DBDI4rQ!%GqwJpM z9PdD9j*%RXD`6C0{&mb+ee^nuk;RtSnDF=&2LmiAD$lqTtVu(%uWMdnaOyq_wu4mLO;Z?MaRouvO(XnCd8cVZD=1n9rf(=9c+1{RQ%_ zGF0}+o5GUaFovI~p2UO2$X5olNpfNL`}Hq7_AfR1d-B@3vzy&>SWt)&uXp2$$wf*@ zI#FDkD$#3FjpRFi{R28mEC-yEhhs}`)^Lj{)Rl8S_bV5>@eq7FX?5NUa*}l0{-ba` z%;^S{deRct4qG1~=d%_PX#<&xtP>OD9^V@4v)m0CZ}R3Z*Q?Z_;G9eL>jKEj=whPR z)O_2%)l>&BLRf~fDDK2m@V;p|U6-?-d|VpyZ1iY~WD^d*i=fBTZ*OBj-Nu0L9+8JX zb5_Lq8-fLn(H3(#yEo5o$qZD~({S(V*ticS$uqFy~A3|B{_| zHYaupST8XVubs>JP}@Du!OA8zww`CvwRc9dq7z&FaYCgt)){I_Xc;atZx$=(PS#hu2${GZtUz{_^Qch@Umb zYsVWvQ?K_;9l#_nUMaYtquNlevkKo8qqV>@Mg+7 zKCa*Naw%l}rzT!%rRP`ec(wyvgv~63ZzC?NJFZPkJF)1@SvgR|TzpuDjqT;MAe)Ns zj)M1_M5YSmLYt+KvIESXr%dp^y%Ghe;!;hBk2<-fBX=fCpa8JC0YSF-9hg#1@-7in z`wmflJBN*O@$vN!r}OfAt7Nh-d%#zZ^_~Rxwl;=yFpC;;Fwn6w+MFWFlDg67uPZbR z`IA!eyY>pisk85MLLxKJ=Ko$E<*rb_k;t%fHq4Wxz0+gwK}a}7_FG@n54dI(R_8K zh>!fva25~gu5N27&9~B&R$K5k@k-)QqSbe6m`@VLaoqSg3&WuUdAqzMyxU(|1QDBH z<9>ui$hNYze$+p2ZMfT+>~R$s0D$MeBVNt^4%-p8H^{uvF&H239*5;Wh>Fcru}^}L z^!Eg}vxWshh@BiiF16pqx;M7Wv9PitJSTDcGnMCnxneJUdu!<-J4f?PZRf_xOvA&fgJy>|&F9Bti@5yWVgnTp9j1GBRNUcG6E?d01NE-rs9T z5qUZnfdRf1pP>!-!+Tew6&d<$<%Rg-|Rb;+VwznyxVQw_5oUe z7Z*4G`0>E`>Oec1Qe1pLXrZj^fJ?K`1w{n!~9QzV+wix{gt@bT+8 ze??pJpkb1hQpGQkk66URO)!#j&?sL^^UX5&$=n9C(_2*xufY%f-jjFs(m!pGrsw@3!e+d^QKbCcUNm3T#Mfi2WI`zz-34Fg zR2jmbc|UyK?WF;se~uhj2O2E_?rWXPHzVZgqjZ3T%RAI>l_Y@dU>=)PX(5EIOEJpA zpVv%-ToVEWpZAQbG;yX4bhHZ^Dn&fTGgDhW6PFwcazPblN=G$oRU53I*$68rF4Lzg z*N$V2kBFrxl=^#mSj17O4N>KrdDy(t9HQqH_Kx?{84k7rlxC>=bCqE?ZT8{XvN#c3hAyu2VJjn(8{@CE4pyFwgVODi||Kwqt#DCibG=>X0tJ87w*ZaEr z_lvtf)AZG3o;R;n}tbVE0sIz+S zmfIZ@vmL%{T;3?3mD&2X^qhrzB&t|+(U#LlyVUV(6(>f;mG_U@p7WKmZ~4)sGRJ&d z4)XOv;)0tGSvb~xy=<&;cvEMgP`ZG#gSYuHP-fQ0%`IImYi@Ca9W{Oz1sostSe8Wb zU-LqB`Y4*MSN&BziwzcEwx;--+;#-cyKLGSlas2?guOyqA;3Hj-IV+s^B%qI>@7H! z`?6$*p*oR?sY&U_zSMY|yXR;N9&aJ}Ni$1YITI?^QZh^nL$57p4(V6>L;@TYU4=)v za9O^ukpotK#X$I^-zqBQDpBAmQD9yMtK&1+NahA0z5aFAPfAKMxpomqe=%v}F;7m` zXWxLDEnmWnovO6Oc`_jl8&K5cEgl8DtB}-kg0YEu8O#vazvo z4^Rw-nBTr4vNG^(36)fuC0eYv$U(?`u)y2kw9OK6>ofJoP4&0UBFH=O{GjV>O= zh|fZ!Yr2N_-qG27#g1Y!17Sh``uY6{F#p=NKOH;o-%W`>VU^_$q$1ho&sg8z;<<4k zX;${ww~!)&2*4b&l`FJ2A~s}N7}J0}fiFe{Fh5V1?G=tZWK_6fgq_SY70lM!`3bWQ z9f`I!l0sj*7@*i+k-}dWj+Ukl+qHi_-`P!Z6%9saU@LliTHpF1$sV84`TMV+_|pj2 zlg-cOF4yGgkpy9H1uH0Wp*GI&3Gp8|52)vA=1DE}@3B7rFlH4e>yQJpdr%LU)naD| zRrc#t$a_?LuGbvKhY8^B{yr6ci*MFEfQ@TQL_GjG?`!lCHh`I0vN5_Z+wq*7wUUk3 z)IKZ!S{=b$EkK#F`1K{&F3Ft3ON%sMz+!&N=NsWZ8eCHiZAyv{R1Y%Pu|{;8VzS5#@t_4TZ4t` zcS2l3l}Quu{6zAmy>mrJRT!uH{6tny-f}k^7dw8H^K>kWv7bd21!eiePIhIhLG|^! zRL^aAnmTH+IN#Ka|NAP2Z-&;ReA(MQejExjt|N){+$J^I**L zHN`DU`1}vO!63$*6m4z&?x=9(m3B&vK8>WlvGQHuv1My-dPQJh9>UqWTl3Fq|BuP>*lMp z=Sz8K%2HXY7pb+?km5k2uX37(WijQB%^A&ZtbgV#E)IHT8?)w4iY`le7df%{{kB!? z^gLPZs6wGNAu8RR1T=Im%mn)}G~|Z(i&&%Qm|bIhRoJ1PR1At)n+Wr|;obZUBA0SG z9O|35f!31#FPhS8lvc)L9(UN{`;;vg*)*q>XB8TDX46-nR{Qh8bN)xCFU{Ap)Ejr$ z*-BiD$24fegXmdGwJ$yKQ-l3q;ft-_1swd|Z^JaXCRToBZ*G}aY5CH3|F2UOFb-z6 z98cF-#p;357+~+^KJA4B-Qt?e*z%zKR6hCd{?K# zdXBCUjBnNG2v4RxCboNswCW0io%T^$dUzxuY{m${3*|kg8G1EO%@?@o1k?A5VN;)* zpQni*xbF{8c>sd4PJ2^~xRleKl*G%g17My3VTfyujQ{2O+x)eB6SBeR)E>Z_X!?U)>KW#3&U&I$j;y-d_*(vZ1LYTn{+0af+( zhLRBboL$Lh@7<+j3=OKNtN+X2Tj!WU$tM5sU z_HFMByHnF}Xqj!8Ht&kHJ;94KvIIM*0TP}McAP!K%o8`7xegZlz(3dZshvdAvYqOv z!C|TM(r+u|bb;5f@J;Z}-z)}Cw_G{J<#*}TCjNF7dxXUa^L-YU^jIkFfs6~Hi|z#s zjuV=4%hqw6CiLkBig3q0S;0bgs6AKN}0JkuG2Dt2-oHDOo{XEuvC)R_BQv&pyhCTiSJkUzX29Z|+!%K6Elxq<4aH|PxvmGbtBfx$x- z+heS#Ufib3UJ4hPT`>Or;^+g}!onBPmIWXr5pWj>w?`4C?v8m5Gj?-ROFja6q#M9i zYmXqQv{x=@|IW{oAbbM|6TyXiC~pLUV+KrMyCz+_-9hd~52ut*96;55)Iln=r3k za^K2bkxAEjCt2|~5-;M_kRzJbJ_Y8QEV&=oF{Q{GfN^bMv?@-O{fc#FyHx}vH>31U zsRm!@Y31*+Fqi>V2du7_DlS2k{Yp|XV{?ph6yOqABjPnuU@==6r&b@ zDvqoc!23?Pp`)|~Ol*4QP$*gFUa@Js?jEoYfz8!T6)OCO8ENw3w~qgF{We*M=X{w) z@~)+_5{L$`&BFd!53NtU;hvP9ewESg#y#CPk<`;8tNB`+o{ryB8)us}xWf_Lc=e0K zNg!F4D}aZhn|!s?{Ic;kHlM%pAq=P8>R2$S>U^JCX5>ZZn0MYzV|FxZaluth8K+#V*XnR|~W+ z+BmC~_U&r=Xv>pFCpK_K3DBecl2IUNqZGv-vjIyN;vJMPFO1yWG)B;wdG!Gzj=z5i zDoBPYaeckVtCLEclp4+OrjzJs(A!p|bJ)Z9_^leIq-pw_) zLV7j4zd#C(9ZJjA?0UA4$`7B<$w|u$fw0HU^pld4-8jbD*k(#>^Xl?gkuZZ67HOQ~ zDr1aOK7V9xB1YPs!USUkH}`w#E@Ex8`1tZyd2(Bh9GJi4ax^5j^YQV){B}i31|NP{ z2*JlnWqxJ$&1}gx?qxEq#GT*E*x;)_1~c}QqKU^DvLX(5RX%Uy+y(o_%p=Z5>SvD| z_3Lcy6{llm)gZqjV0*J9i3|f@yPMw7K(G&2Xe>|!;m)rH#~!8B8jm4y2dzX)5_6y} z`GjM;$uB|<-*8N_Yht}BZXT;fAs&z7A{ElVs#QaaT3r9790|`>(W(xnQ`ruA+9{a{ zwiDPPjXxSzrAQwgRQ1 z6ESk?Hj{BZ?|2Yh?b3busGbaqjlF$H;Zu#=53f*A#47CRFfz|q^Fp4A?&68t@`4!{+`>K$6Rq(sQ>;6I2}Tx5mxo>>YlVb$W(Mk3J;Rb z0`3&mjdOOZv%^}Mf`aDZP{>C2&~`6CSLAKkxU7|IMZ zQh_FAQnKcV_+QUv!JcrfZp<0*>9+!&0yNf{zphg}wh*2+n9*lAvDm6FTT)?tK1^_S z_$Fn(vZY?bV8LOX{^!urDXG89`}v2K#IezZ8ex6LzmDG0B5*f_PeX-tQ(Dh!woDl= zTpPG5XnAJkNtvr&^?|2`R{6Z<8_}&GxIsMhC@c9}^VMhYwy<=KA!dJ~aWQK{s~Fo> z>@WWR>eKH=@_+MG==c47v99>pf0X(}4I*(=_qomvrG0DdM(68Uhg6-P^yhi8@Fjtm z_1WP~TPYRFT5=Z;)zm)xLzj0W@|>WU+lud%QCKVPR{3`MBiGFAoW@Ga$QvD;2yOfC ziNglab`%s8+#o#KfIQR=FKzefo2m}Qh{QL!Cg{Wn!ar$vdT21M%=FoJz3?|24plcy zThBd?>D$vu&D{P)2;9yM9UZabvz?AC1WpFNk?s(Np2V)V?k{QR7%1MFtjDFPT!J;H z`P?;deC!wGAFo#eL$j#4zZ=+}@<=)O{=kZg;-t(VrX?82cvi*P+)roX=?IFEJX~+1uFa-Zw@mi!_YXQ2Fp@Gi3l_f>$xM(ez0mb`?_WZeX z7YTwQwvK-J1a*_4Eq_?k0A3L?X~VXoGMV+B`Uu!AWVy?RzJW~-RQ>5?MifQ zLXK%;DawvG2l^^XS|P;thFm1&){%TU+7I<*#|Lp@M3dN4H<5KF&5$ z?1uD>UNO}`+Z;gfw(1lv^IKrna$5;K)q7Un zo6cU3H=QMUnqPn4Az()*RrsaZY!hWT@f*-}`iL{BO zBM4?M@NBK!)44+>qkG^guFWH>%G|oCi_0cv2VQnBCuZl3%;bh^wgho{>;CDg$oMt) zan7!V`0)D9p`921f^vHPU&T0=Pzj$Z5_;b1Ns-O5hx_+jEPs~cp2N$7!)^~P zw#q)YQmDKn0bHwkjJz~`uUDWiI$OyOX@`{fhk27*+GPq(I%ztYAO)V@{9=Wx-jEld zT<FuG9ZsIm3AA){kV4@hi~NJq#)YzpLZb{!@Iz2u5rSFC9`As)ICCyT7OF}?eX z%Ox&mYUBh#lV%qwOz|ocH4UcjZEe+WC+&GiKTIhG7=4Px7)C06!dGUHAA5a)Lq?a+ zzfS7#eevr&rEvS-j`3=(Ox=KZYJ1!hoAikDl$BYzlv*m)1I>ATnJPikUmUuic^~LOW}7dp1wTqhB>P- zno`8$J33?#$!Vh_Ya;v;h;RIPMJev$isBDnQPS_-=>c4_h^YOnzdm-$?lz>@QDl)& zZzi`5^Qs0@Qx%y3m*Q8=BX+E%jx((<0m1J7*Xv%OUS|rp+gz_u-u6p*JlXSkX(fFw zh5FcK_w^>>SBWDizG3WKlHq+?9++_ zKDrhsl_OmlU4D1{p_Uik*983j4qC-~W~v~n^yj;b?*aoH!;nMlTCkC55?Of3umM=H z59G}XZ-F?8Y`Mk;V2L$6_)@#JYV`m8Ze%P1&Wx&ztO_ary&KO}R6N6Vo$`Xn1wHS; zIK$Fm0?OGy(g(lOji!U6U$01XZLFejpVl3pg4yObVA)f2Bm=z#lNi&VO;(WvtAN01 zjL2gn8xPs1iQSK)`1okfF-`xyaA*T%pYrz$(*H0OFE%#zhnx@*K*D;CF&$*?1^YEn zhq?-q#+aVIm*>>x?x=6A|B9`izQ+vA3DFA=wHHN7%;)!G#q@VK{y}88^P`7@ao7gA zEhsVMt%{02DzF)5@cwmql1=dB`0ne1tBCt}WMuUk&Ak@M=s`x^K z#p(e*p~v#;aqs>$`xRk=D^^YmpZJibJ9(ez%|coE;WIiSl#be>d@KEJPq2?Q zVLMc8Km+|BSYtrfW+}mfVL&%Y2OSxlKNp@eJlKg%a{*qLp?7Sh*oUdcH#m_gT6@k^ z7thqs78NO06*#slu%)ZOZ*7Vt6b(hZS(Q6F4_%zl3?qC?iusjSv0Fj z1(4J4N3)F;EOMXg=F3<|;zWg$6XMR+KL%_@sZtxAUD@j~q@`8~S2*)xrR{Nu`J$G% zmi#ML&h`ySnC@E~ej_$YtFvoh9y>rPGUk)gv7{9Y7{D(fj0QUqqo%emPQ3x!lUUnq zXtG%9MvN0=Vxr^CQu7ECe^Y7>xN$+Tl9MG0q{WQd#_FcRx?9j(LNR2pK zRyEOFk8ZNu$lf|BC%+f$LY96xNDm!u4PXn-(b0|qf4``wP87@g6M^$CYU}?|_0~~Q zwcq&5X7CLWSI%E-N#cz&908Xsng#t}Q`vs?XDauC_OeoQkO+ZYw@ zJT!lpgKQ-Y`?K0*VNEmir6ENo@1OS?Xt-pxqBf4WEl(}(NNu=vRp}kRhB-l`*-g|; zhzEHNMo@S|y}p+=)RBGu?2s*JG#_W~4T-7wK3A_atoQApZ2yhGXLWnAVC}UR>S~~z z?|12u#BFp~>z7|k*ic)jaPfL}njY(^44bmI>zISP1<5Res>z-uFXUn`z522=R%Nl| zlRY>yH`;~*kT@q_Kn@#na4DPpejVfG-Se0SzcxajMo0|*t}pR%lv{nH+^u5gAz6&+ zCap6qtnO3BX@-aGo7kjVaAXt4u{-&~Xe{>S&O)rqYbW~snIlq_siFP1OsPf3Y0F2Y zg1OzL8K0J1JQ~^t_<;h&w_kK!nmU!}z&!XU8kCW-MjUq^A=G$bIjDd#RpWIuo^DKM zmeccr6G4AuL;2Qa(`me|4&yBG#p>K+$yfZ+MHxkFLk;F#@X?Og0A+2h%Ao3{m)_Rg zqGRzSl>JnojN1# z{`W87!m^f*$~8VEcxBF#ky|9-`ichJI8*j^q?lR{DVYRX)TS#jqS7x*`{s9KQ$0CF z6PZd>)dls5=(A^BLU&vY;K}@+3ksgiqF!ur$pg}#h^b>VmqgvX0d*LKkkWEl!?dh% zl|nhJLUjtN5mTKtagsR(z#C9$X(&tF&0Py3crgbj`*-SJed`ZEtozg#G_tB#0T-|G zhxn7qz6jNtaTaQtXP%$QSNu|QUpJ1{wOr94C5pvKZheo#+1k ze&>IkILDO0&WOhbAS-X?to{w?&(Jq6_l}Q6OfdeFqt1K<_`uh^|MqzqUY#_ev`IAL zm-J0jDPC*SrDm?O8b5yJQIaPFXx(9NFttrLcT~HVRK&Q87bs&ECO-}g_>kTmtYpM! z!dp`(#7908?iKLi!?oBpwAEF_(Iu_E>FM?alCl`4bM4o^&X$TPRqYV)PSZCXw+6>- z-&Vk)tG<nKIAxC?anR`{<68VceA&Xk%ya?Nj}l4zLgVTWx5*unsr)z9`fcf zg`KX|HX09i(clegVLh1U9B?000)2_g-yMuzkaSgXKR31Gp!Gyea&$;zCMzo_`E~u z%oz*pf7V0FJF8oC$~t>bikAVW$vG!$q7m` z%D^vDD5_iRp2n+QN7N)hy`cS@ce!3XfDSb+uhjwiQ?)2f>4@ZYO-<~A-L#W=d3iSt z#?X>&o&ZK6floMV7usIbeuIp~aQ(8Ny!JUbOdZ^z+(X!&Nkh)Zs(E1d&<4}ud0225 zb6Ke+$IJ$uBlZmZ^uwQSDT;4jL869XFvX%8!y*n(7CEdQ9 zkLi|XS@;XL4Lm{WiuHG%%a;nD7TliJOx_=2F_tXEuT<8VB)pJ7?!ye4#KtVS z>l>P6o7_snn`g1^lbs_`-ma|Q2Z=m9y5#?hY8C%Qwe4YF1dh2o6`}Oo!{=>pZDv0F z*hdK8;Nhwe%Yj5Nn?7`*WPs+rlAN<_IGX0tQO0n~+l^|3--M-cT^~u$D@7^VwPOe( zt<1_hM*N_$F|sySpZm!bR1l$a`g`09v5`@^-txzNS+ImDtPk~XKe@}JBGLx`ecON zHnH9E&!ClXe4IS#NuoZd!fm^#gu3J>BZ_5pU}%0@!J?OU98j zV#Z+U=VoHL+0X5+?2*)2YNZ;NcihSP24zW6<|4&~;@XPv$eEc}Wr<7ies%-zb8vQHGt|x@RV8B$e%7UB9fSD0sUs!XNYWM;7I!B27z*!H=bpY90<%i z&aDi6PO4gQ09}1%vIhd`=K^;lHXxtp?up@zQM@%~roVrzLK5J5WD6qAR(!^l z%hBsf53cH(xBxBUz`@S=&m#0HdOHiU$}^nhqRIf(ZW8k$8_J=O$KUs zFwVUnufnS)dS>xlrYa%&#!4i0EX*Nq&g)f4_^;x7iUZ}?%olosMCdCdw0}O=e`E>{ zhN@pjAdNG?C&?vBrcZont75n`YSx4xTlXvr~f(=o!3yZC_ybd0?F*|p4}A=3&K z!(~o;p(I*Gg!5@+)4O(P(D!dLbwEvlyD;b7pBIK_uO@C)PDCku&5e}uDPGj5urpg^ z@!0s);t(dWAENeAeY=$o3JUuFuhYNEXIxsyhM$GGbgM$%IDa19QFV^p@KGt}male^ zmJ`u|>&9{W2)1>4@r3dj6&7+|0C=gBCs_5GZUHeC7Ray{vY;3A6*MBL6Q3G!m0jw* z0>EwZqvAvG zip0Vd#aDuv6wF-AvR<39`0xME_q!`2Gj(hU@_L%m=nn#oF`*IKsp>m{nW-# zpAMXvWi8*)LNT&x&DC`u5SjCfaC)W_Ok1{o8?gHDE>XjimK7EE%eO_XwQfxXWLSrP zsOQ!k{gqla+D@L7h4}oEQW>#i4=>bZ;}8h7s#g_Xd`{%4$;1rx!Q+H2SaUSaWuAF* zzyAmy-x>L_wI$xgl$hd~vM-q_#NvmPQ?WUz{}cz_;3Bm#V|qgKd(|?6J+8n2|J`Z~=(sk; znP=X)^9^!Vo<8;eCZ|tj$se&9=mju@dWEe z0g3l(x{sgM@=hevkj7wUAvvgCNiIzIIp(L45>>PajKO$Gnsvp(Oapj0P(J&+yxpsB zwOk^?`Z9R;d@s&)z1a)1!jgdw>K$$4Y)kqA2^!~jz-2e2#mWo}`d|PE_-FgJ2VRy? z6|{%B8&d*`Z!TO6Wd;VxDMpzKl`b#}JTodMh#<( zhAuQ6Y<>F;KC^1TMPHd-r{Q>ZrMNGUkLuAO`8dm^I&sZ~XA=$C>)p|b@BD&&C1_mV zI#EzCAolG7coQs^FrjQqQ~^aFw)~jGm@~$~p90j-&(3R-V-wh4zVb^kP-nZ)*3xDK zBim4R?90iG?U03QTbHyz>OU~h+=eKj4Yw@)|K;P9or z;emI=FB%LP=w?~p*a|0sLc2gz`@3dT*pm9Hu*1hq9N2|o=o}iq`L{*!j*!&2pNfXp zCI~I0oG45ovW?xirn)E7OW{?42X$?eJ2iA{0{CbX!(Z1JzMB3R6r36uG;n%@+4R*E zaV{{`f$JraWs91W5*Q#2f>XgxsYlNUX}%VDu&P*tF;?+{|tY+!sjTM%!_*zbq&B)5bwORH9o62`xDe~FDY)PV?o&03l!nxLSQ zNO`sX(6a-~!R5tyzN9#!V(5SG`%;ZuIzW4o%r)?Ty#To3oXo>X*1NpNBcTK9INneK zD;R#EhmHC5VH;k~fc0pvCB~QJdeWgOEk&VMdKlRXta@Y?Daq9XBaLL2Hlh0gary0) zTvvy7sR}DlV^aC4Q_(lq?N)utj?tMSHO8{P((rv8vw9^r>|y(_$FpWb(6oR0Eop&7 zL_D4yFVTm8Q~hdnw^|m(@*`G?nwA#wXi$)wbAo-OCk{Q=4=s z)mecdDo=P3H$WP^Z-%-O|3`{~@8czfxUXFDJDVN9*m&8ACJ}y&zO5>_vxu6o^I1IY zN;)P38*LV||Cx&-5%`)X;S3i@l8TaSm-Gd(%enBohGuTRE|9*?b~7~)^Vxh`otVxd zWzJ7H6W-Uwosi!q+mxurZlW~nZ|-`Tf5@`S3TFe7Ru|osYCb>niGEUaTHqrN(AnA9 zjEpEgHY2Xb&8n@^qNkarIb;fPeR&noydji>d#9XkJ*0Cq8jk-uf9x95x0J znZJ;6%W%gI=52l6EaxqpmF%13n|_&q681rL7B z>1S_an3?ffByb&E@6z=fp)s;`O@>iV-pZs=6#o5aik`HZjce?N!!f&m&-YrL`#o^W zS9}|okgeL6i7A{1=MpHdw)dojOP{>ToHtrf^@VLEYNBfNzps?=efq)~o0FKDLIQYc zpeBjiF-TqUR4K*d`qQ65)$GqV9p)`jE!j_QC&OQd^~iCs91SM*ao!f9sTho8*W7g54o1OwN-dCAOJf2nEdR#tLUC@L_2OTc! z&{`L$Ct@<_Wza7twm9|T-I8wdv<`MNL96(nd1+as+Dnj!Vf?rt>|6itgn+yiS5W^}mPlf;c zB+~k!zQmHQK7&B~FUC=$0QtbaFMy_RwEw?*!GfOgU5g=Iogl*W`Q9fYXwdR=Tk{sC zOnJs)E7a+Q#3GuKn(VjcHj;&{n$v4K=$-+y{G~YW3|80ktl5;G=fb!X#>!UN-@^;& zf&6_LA=Xo#qYIyGGq9HE-%gqQZRn`U!VLZ-cd$go48^JQw!3eY*q!xFbt#)eS7%+> zKo@EYeNEwKqjr1jzj|-u&!p1;W9p$=3I;NM)Zt%v4V4zRO$xW46dkeJPK{FFesS7) z`$I|+GOJ%A!Ue(wTvm$qkA{nH-q<2sbwiGdSFnwH{x;xWu|Zu zZY^jGw$6)@X}QSTozl|1pg$R2ayZO*i$$!!jR$g=Z(9$$XcxZlF) z9DrvZ`1o$nGC~xeOMBx7L<>;^uRXcC;uqG)OEcfE5?t;9nx`^A`*$yqB*i9Vk2ki* z>lBJ!NVyHTHFS1qz9|B%_snzpP7xw^PAjmqMZ|%d>d0@orxGwbuiM6Lll;6D0~_wC zZ3R{@E|rFK1~jH>&rS{8x1CF?-*|TyfOdq(%}CB%i7H!oqw9|IDI2y0Do~&OY^2YA zlY@OXAQE+6U(&{r)g&&(TQe?bQm=mq;iuc4Vc`OHDl%EI7tEB zh%7lHz}jfeQ*U}?*r54nd{UDz0@+qx;fCrIf^M8$An();NSn5{fl=g5zAnZNt2-mu zDPXLO1a6X~0o}TBj-6|2^1a)c6{<)qIy;4oe*dt{Na$OQZZ>96zV)Sbv4ym?tJ*G~ zvmKV}_=d*Mmhfu1m-w-ulZ?z}x~G{Fwd|tj)z3ZBE`_SM3{3&A{*=!i{qg(Iw~IH> zaDw<}R-xf|1ZA|AO(3+H1Q=BiQ(_6@P@&T(NrcJ-+Gh90IulTcHv3ASTNBx&jVJyZ z)=f>;Yj%UIvP?~`86YLkXtWdMwKYzRQ&GoEds1t-jo0Okk;WFDAQOw&NjcX98ob{E zP966q0r@@I290kby2n%|Nlc)XO9qJ-pw>We%}`+3KtbnQDh=4_yRCa-JZLoifp5-4 zn^u}9Zup9=2SRM!ze@A|l_ZPJaq^?RT+?;BYTlFO6jMuf=3}WHecySm@W{U*7weMh zDJ9*P_lmZM7G3UwYl2d@-Hr;Xs>Z4rXx*XD;|54Tl6)TDO+rZ`brAz z+1~PI=+PH)J`esxXN|>|3`t2`plCU!iCL*Ge=T%Pq)N^rNG8al=!v_#2erNDsO~RDg+U$9SFZj$au2W2xeDgw`N*HAtLwoK7!KdJ zUpPFkvz`iOw#o)v3+=Ja9A{2ZKnJV4*)BS}uA{Cw#5Fsj{Wtz?aoFXkt~v7jO^^J^(;J(P6dl_AJK_u7>RJ@ zZ*Ow2m4_^~tJL(lm{IAV!{BV;5wE8C3tO0Eg%-k{i}yok;01JQt@b&v?umLa@g{M4 zob2T;)PLkLrO%|zQ{DrUnza+~No8#jN9i3R=N(?yU=n|K$ zx2O3*k>=JMl$Z_2pHY>7)5j;PlJP&_hky9-x#*PAOa6_D#EeyFCFx#65Sz*_sW29U z?9@V+I$dK8;qN9ngG7{{qU07w7@pdy_{aK8%fdOHM*Rw;gUyx^=Mce_i^}unaUk(f zqR>YvH(?<)V0uj1W>@SQs3^%shV_x;atyUL>a}PFXJG#K@cr}IeKY9%t>t5FQMru^ zsqhk~oZS-i#~t&|D6)(xy34E3k7%Q(iW2jnTF59lBRZ~flW9GsUNUfV!Wq$)5zhRo z*@1-t@5L9W(dsRI%_T@uyK5%k`(HavigY>>Y*StP?Pkg2U3r+5ztVSG9%7?hYXUOI zI*0swcvUpYJ4L$q^CxmmjU&x3)IvQXAurhXXzTViiZVpV9r*5~0lcI@R-F6ili&Xw z0ebZ<8R!LM+}}L_kDU-Z8K$#;|A6|^$qB3P7oX3~{~p?se;-;QO6JV5YjiHUhoe9+ zE)CEYo2C?dKzshf;mxx}RrgjKyWTj?oTuV#L{m%k1w+>i(OiRHpzfvq-{$3@*bg$F z+5=bH24-cZCfO&v!$q5Mo2o17wnwX*h@Pz}h--E7y|FyEG|Ed(KZO^*8F>T|W+3G} zfA$R1SdMJHJ#%NIN>CabwlsxxE(MIW-@{w4)iJBO!92&OTZE*)M&EE$H+5B9-QjEe zeO;H*tu6_=OoCLx%}j8e@6~z||2?L#qmLht?KVx%&ntp*q^vpXl%FONx?+&=ls!+$ zW0Z#7uteKckW0|Y7Pvs>wtT`7I^5OZl+7lj2N}JDn7me{LPZ9xQSf7WW=0V?w$h!v z9P*tn1uE$R2BRz%#W9B9JXF>pomm15jz7-5-g9vk`r$%PSFV3xxOPqd^e+QvGs-ZS zpHJw->(0f+YY%Kj*9!oniZYz?p?Q=n)C<(k`aT+Vi zblBg!8cPa*qQz>(d3j0)f4Y1ss&Jp@gWe=0>O9cL%5|+eA+K`tN)cJJ2-~ zJSrXY#NqErpFK+?Lcp!d+Au*)7wkdfATAb`7z~v)_nMDkrHrV2=^`V~4Tr8#B@|?x zA6I~P0Jm93rx)EU*l0zw&!azz2V*y?O&;UmWAP>mNBH*> zYcfk$xuk^AXiF}T%*D98j>~rH7$cXQyf@E4Kf-o&L-#U*Gx>q`nTW%xxdYwL3=}H| z0z3v>u`Ck|uL;bxza^)SsUxUIRZMu%7umr%Tx3f4hUFewk~ z5z6D`dcyB0TVH~0Q!sT?Q+9$846mDAtjq!q61r{mFxvZ4;+KPS2rgkS0yw+SYLXhJ9F(-ZrC_zLhZHC zx+Ximcl>^XYe#NbK@^3g-dr3zBzot9$28F3DY8fwH}V`VZI{U{pO=#<{23jK-}g#U4@zwW6PaMF9_G=m!DS=UFvdu(JhNcsY2a930iYmD-%B!v5C)^kg(XgArnNk z$|mw3YS~+D*Kzdb6rAu0SUBvb;bY9pW*k{E*>OdLHWdlW$1Z@h2W%vBSU4z0>CtLe z@vTBQp>^Q~nbQYeX!jQ*p(sNzon15F-H zomvw${mrMLX>o~=ESL{_gEv;9OBs00ffB3jMeqL!9N3lfSdcb0fI}Idm|!Oo_$OG< z6*LbCX@%Y()&KpKu7C`)8x>fB0dr5lhZOj6=;7GKu{I$s(v33iV{MiG@7NXp=frOk zG3Wn;Cou`O%rStYwCQ2ubNKMA3WRb^*4W3hu){t;G*BZPuKC&@hiVQJ8SUy5mqxYFbYgIB0jPUD}uB zFyzF3!WEW;Fv*X`Y;B>5Tw7eU8mH-7Uu~U)Ys?W?#ZGO=eZ!|io{OmLnTdS-sa%_2p><%cn7x=7tZh&;VGvK!Q)=ezryVj@O{YqK&mBCL*-^ zgqaC2 zkgg}fYXyKc5UDZTS@u3~?&}Z-BuG4&rh6Ow+zNaTguiYDidGrRl2g!P_aJ>Ol5Mu=xsADhxnTB zqL$uvV#~tU3({Rz0Nc}z(CvSPNCaEDy1k3r+p2JR2BT?sBgtjl_|UFc-A}d!AuU2o zMD#CH`h!QPD<(JGWu@lXLmZU^1sr7o7qzKKV#Uu)+k{zdZOZ9h^`F1sg0pNG=|jeQ z>kuP;h+I~Q9I#O7b1{i8zl)J+VlvVr$9_<}3eF5QdRoSpu$hiJ@m)l}%YXx#6#3e${smQm+^Ak2z=&Z?ACtkdZu?e%{O_MCUUT7Eh|?5)q( z-(&)bBUM#n$ozsQbS8&7G+0iNHOG?gmld>F(j6^m{!j_iIN)iML zmauoe6;BCe-8kU~^9*x&ZUtykg+PI!Tb&>K6c;`xbnuupSecXNvHb_K;JW89jH$2Cc<1wa60tMWf=1H;Vqd-^w_$1W#7)YUbxIDz9$`H7 zCPfNAYj5!jE4ff9m8k4h|JtG@N$Vf4@sIc>lli;RbC*<+5DHzo&keg}f%j@y~f>HeH5(Y+BqkSRTuRFhsFq)tR2}!o6=p zE&M1s!n%Ibk-zJ}BQ`Ra@5Z?7%`*RD{zZG)`_pHKi>Z_9l7U%?Q_#krY%RuIvuicl zn+suoaH-Ox9Kq_!EOy2{a$S5syeJmVU43v5E}|(O?aw<{513~s_}-89TVlv{28CCW zN=s>O8H>e=Rji`VN%MA#pwfgdRh99#y)#s}N zYFqA2Q}%)~1qo7FtGAGN(6Bsluk6S2!FJ4dTssa&3nlk*Z`=zAG4<5d5*?>2ngc+o zEDgc$!RTXLub%Y!IL<7kj8JT*TiRMB;;VA%m^*K%I>)@!edf%I`D2!R!ikP}mSuIe z#6ft4aeb!x$Oxld+zT#_q8N>jfC&CL4KSiPS>n?wVW zELqab?#6u#C`7i_m3jjX!bD;AcKk4_;0)a5U{up(@id@IcaJj1&Z39Xm%m_adT#f~ zS}Tv)XruXr!nFO?d`oF3-ibaXUeSjx|?HEVR98c$wgwTJaa2=7PsFEqHNtH}oXx4j#TG+SJm5Yk_87f6N5K`;O9kg;$D1MRe*0 zoR#W+AiL_|b5c|I@_cEzMG{5Q?%d#!sYa7G>&C@=MV$8GszP#w9q&Cpui0rM`W-Go zlg%xNpYuC7vEdWc-+8#RFCNwS&74biM&VC)z!wFJ+YLDg+`ZhrTQ((lPQ^~X^P(kK{A}_CVNdf z6pp+IuF^I0J^{!&8?0fQJ2~Gu= zr}mJ_*YISLvwu@21}mEfKR>`|`PgYpccWHi{lj0I_gthax-uC?E2B@kephqmR@Qvo>uwZKP-NMj5ZMA=PZtWJ zn`*gN2NL$?7v=%`f7y^$wA{R=e|4vQ+jM)BB}bpos#3UF0vGl z<31!KpCW-dZxC`A^}6;-HGkU@nhV%$g|c@i6VkenHd3T7N; zCEZpu#%Awm-vU7dGB|s zafZ`;P66$Am1py5BWeJNb5ED`Gyq|8I{Zyf_I^BoMeG9(bCfbdpj1U?+6=~V+WqrD z^gW`=nbD>qVh;}{sMuk}&!4PFnn|;PjoMhkS}9t!^-3^xbHiIL>^u6?CGbhd8i`f* zv%TL%B|hn#>N#c^YED*^6@}txyqb8Pa&$t=CC_f(69r>8R6(zD8krz;k^GqxGtoT!Fi4>o{wV-3D-S+PUHr1VvdJrHx#S zj}TFtSBN(NlQ(1I7=k2*Q#u7Ur{ex}5>DEBW0lx8oO{tX^_0meOswGk2m|{)0l~@I z;5G|K?>VmI5u4#MgtXu0SN+iCoe`+x<^*?t(+yspsHF&4WZwU0za9szwbQRFOb*-T z&J5d>Df^E(c_y>rp+(jz>_+p_8S2_|pWvyLVDypIukWzv) z?P;d@Q`(PeDYZ{9ROUTtJ{EjCIS(6D)-jB|3%rT~RX;&h_ra}{CW`rvaVmI}Uf+Cx zk%lNFXdaccmf>N-K|~HH{tf6)<9|ZbH}td8AWgtPD|Y;fcpUacP+h;zyuq@@y(s&; zeV-c6+DLG43b(~QTb^d`?;;#+lL@miO<5D)3?7;s>$WYlt@uB`(MCAM$z6?ZPc^-; z`l5&cnW4^}RY3ln%%GP0G*!WTVX-zV8!fVeHH#LqvY1U%;`|wqDs~HBJm))w1#w3< zI4D2+K=56H15NPhpIJ8F-I@&B2>dT&8roHg1S)!Bu1(F&dNoz41I?SAr@Vz~-kWZV zXt#Lzi%HmFa_`r*-k7Hz%JTJR(7YkWrQhg6*qZa9;T(v4O~O9NmJ^4IpDL@nJT-ml z2W`i|Un^9`Z{$vW{Pb3m#^iX}zZ)F!yI#+!$S#xU@+I3i@Es)Fq*y6V{t~Cyk$oe1%GMq9n zK^A$rk+&Oeo!cU+QO@5$A&nY;6$Ku?UV?Uzvnwa_&{M(i_7;u?rYFUQQZlnGmFOJP ztKYaRF#HZ&w!*M^O&3Cc&k!h9Bev(MnN;@&U9)Yb8(lMD6BQ?Tf?7v67cLve**_C> zY@jW!CJQK!SqW{SH#ml zW1uJl|7M=k3k-5pJZi}wRqmfL8mfo)|JMu9=(;Pd#F-vrGkg9SEf#}87VCnhvyg#R zGcK{gdM?n&BO-?B>zi-73fdSSa7;xG3`SpO#59!xQ!;z5=-M`^unAm-pKEaC7xm7l z)J5WRfL#(uanaSthLuRp2bRs2b0ATd7c9jVnuc>AUfOg$-_PbbQ6!3@{4pcmX(Mrv zks7y^Cgy4HtLz2XJ;CQ{VmW?SY&J5!&8l|_w+mZniD}Z=9W>^>|_d^&Mq4#TE4CZdJ8!uTx|@7W`?V35=!^t25Xm zpZHbRyM-M}hZLI!d;cZTA?7QyVyeW#>AQM((MQi(o?1>wAOT3|Htq>9NFIrcuU zAD`w+C<<9%<(Fg>6r1(jC0Sm1XHTCqF}t>Q$Wi+cp@A5^6l#8TDql5)kA>|>yXVC) zktc8Q;%W}+UIDY`{b$JrmT@I5Y=WbI>s^g404x3GW>qimEpmKn>hu8~YSe`^)G%d9 zEz;FBV(y+d{^UmU-J=AxV;usxwx9uIryYgag8c_$3BUx~dpq3-smALBkkPYp^o>G# z(g3ciZ6Eq&Y#te*$;j68ea-`4r)$S3q+aK~@qnaY&vjOXXTO@xiOk<~xy3QT(4{QL z^=1pg8OZQsgHh1m%V{(%;Y%lv=ecja@?8d*v@pic$csLxUW%X2^|d!C+Q*h?*rUyH zF?xC!&|#s>@7Na}(6D>?RV&)Py>|Yf3^cKCafaoiS9k@+>8zjDVmw79kd{1X%uu=-KY-(Yy_Cf2rdg<$kQuRBnX|3^I(2n{!^G zst+(01a_(xTj%AYsV2lxGc!u!Fv)vd@1TMXbbH95Oyo~{yO5)oN@#QKKFU$T{tVeP zaiJX(by{(C$abq}^>?!JzL@o@s>-To$7ezUkIrj#CFA1!M8A~hy;sytshB7Ny>~KMs*O4!-QTUS90pxrMw*_y=18fU|Q$x<7sY zX3mm1_8UO_hCkSL27+l&4<4DGhi9S?Dvqx3)u{q#VY=I|LswTrGLs86M`VU$NW)qJ!q1dJBD{fVhymezyTgQYgs-m{FQOwQ};W85M z*nQ-sV9R1QZZnbh<{qQ;tq~Pb+M+2m1!d({wsmXd=Vuo~%M@lRSXn*8FpHN3CJnr@ z9XhiH1xoG8)iUMURxsq;Kx+E(HSPlqY~`sjEa9KWOEFl>iPtn)F%cZ(@ngDW&naL6 z>+9c$X;ig!7>hA&#bCA>s?3O>N2U5|aXWrx-SQYQS;PrN8H?kkY%KFFPokv?l%3p# zss@DKg|?%ah}%}lhe$Ag%&I4+qtTlm8Nqy%EU9-`GXO-*G2PqY)o~%lg&!wUsX9}- zY)}oD#uD+sl3Lm)HhEq4aXk`b{lT@6GW}+|{g@S{L~YkXu8yF%Kyg};0SAADn8(wP z`T3>3P5O?fBhi>xr%G0)L8){4;nq$olbSk$GwVl``hs)%*!P|kV_eA-;!H-LYvpXn=J8Fi*yRWB?xhX48AvFTE*X?1ZZJ~7yRo&A&ht@Z(`SRhL>Nz>( zBe_GZlcgz14u&@YAYmI;4M24WMg3IJVwy{O#V5uK4`m3IoN*G^yc2oK#4D5T0Oh1@5WrgnaOA*8HwJTkT z5=0uyLh|f1*&o#fzem0_8?SIYJd{h6zp8qlv(#kfTXhF}VJLELc4Daf7_aijy(4t}4zKEG^a5)JJ4kMn2YCmXJsXC2}d6 z?jJ!`in_Y;x_yEDaPI>FEpAu%&19J!`OjnEp$g_v)947~3Qc(6wai;*4FvYLUL@FB z0GLz_&Ker0HT9jhL7GC8<;m5@M^^ehAo!f1%j#?`rM~*P^|{|Ak0Z+Ukt5GiSD!Gv zCrigl2#P+_a>V23wj2$9_3g{Gn3cttwLJZ>iHS>5i%~kt7h_HaW=2}Y9MiAej#3RR zof{wZZ0YB#=gGbqZ8H`dxvKCNY|`u=PA{APYJBPv!I8anZ_H^{+ue^C8VoicZ$f@ zEv4K{uG2dlw0q>M?$HV`s=viV`Il$pF54k_@{BvGwe{3oIF>-2j z-bwg@YWKiI-;C3_vBY>F!=pcadJXUa3t6voAKhLYZl!4Od|%o41A4HOJGTM$zD2Mkqd-Caol^^!P(i`#YHo7G5mGs2uTeWX)Jp(CTej#`R~?S z?m!_@Z>95C#rz@L)EuT1s7i#jlgOCNwUMdA^fYn zN!N<`VzHt%a+J98k~Qdw5gQ>hn>9SzjqeBiJwZ%65+y~JPg559IO^p`mP8P*S%$MF zaFzaaW|g)1{+@S2gl3MKN^1dMg4RD&){4)bE)2cT_V+a3-+eV8(7y>kZG268CQXW^ zg6U{2N}fPCi^HX=Mo;dkG=&XxW;7ubQAtPlkxafd^*Hs$)D#yS?!-msIUYjFqR1m_ zWl?pM8k{1JE^}a{N_n{Xkp}rI#lkRPQa`$w)|#=Qw>2TaLc>~5-ZUrDn*Y(v$IDi@ z)4jQRT#`!8QznePSEc;&Q7=o5q~K(?#lgqMoo*n)=)uasIOkgD5Vp=~vL?_al8KRA znY{g#I^!d`#Q%ck~*f@&EPZS@5*TM;RS}1L-rTW$w3R`v6yVIf)`a z-1252koUMhU-aH9%k%>9r>%F)aAsb(Z?&|2nk>DnbitzSf7L7DVsjor8JXjdh~nP> zS}GA>HZQ#hI+tukR>7`Tccq8wt%uH@7m!>5v-M*+>u2R;+ep|`+Sj3~&o?D5Wwg#N zE>0e}s_sGiX2H7EWJK~PQzu5=btfj(KIoizU-BocY_LY<>YKVFkt-Gd^3Bzeg@P9-v>UBBp<|Jz4IcE)RKyIU|{xxW3A-P z&yv7dF&(JECcNWlbL!8*6dw+PtZ2#`*kONghV%lc)2AvSXDVms+#P44zSPBf_orv# z5dOqearhX@yw?_e*HlII4>h{K&AY-)NjY1r&;0QbMm3K!Y`wG`B1rqj*jTR@$H_@L zXVK;+)lb#s?3{=@4lGnU7A*z^-!XBxEYHLkIqp=Us-Kdgd{NI(`THBzLfFRU*y__463Xkp77#17`^w#a%J-M^qH!*wG1C7ukSA0XYwJ3%DD|Zg$1;#6(Rz>4 z>yi}=kI-yfaSK!#u1Izn!PW1#FqyKC#%f0+Bz`O zJx4CNTc*Bswa9w$0NIShqY2cz=wMPw-~(v10Gqsm^;+_o-|_kciIMr2p8J)a-z}fI zv~(Crj@$trb_P zmTgC5f`24_73C{rWniX$yGvH-2MuQ3$4J1D8NuvxC4SuMaIf4#`|BuVCWbO?S94}o zLe{yEggY1;rOYScB#e2mZWAbs&%&S3z3B$_kE-p7itSmyj|*k#3ZhQXJeF;?B6PR3 z_&5!acaya%t`FTq#*XhMkAIFhhy9ag0;TFIL={iZHw@I{``cq8@Y`5bb-@xJNy*tl zIls;4wXJ-6fx{murPMA+8J2;s~j&>g?n?-QZgol{f@xA zJ426Bw9IhJfX1O;A?xQs*(-+j6W1dQfx!=AJx$H?3tYN4o&e?DkDqGGI?vN{w4HpC zoM8#DZf&RBcue0nV*;24v1bOE_izjbzChOt7vMqi>1Ckwk5bAku~NefIiGmyIJ+z< z5 zv-U66PcC}4@wO=xAe_V5N}@&G+@2>y2Z2kNwmoGoF|u58x~DY=C+*V{Y&&AtyC0Z- z&%J@|pO3Udv&D@j8PQy1_=s&0CwUAO<)_igh9R1QBkXo5`lBn7Kyl_h>u~zKAGNqA zF$~F;XpmtmP%x6LB3xw#52##*2xrlUjPsE$9kd?$5$OXb7>5NfQl9Txq{ zCY%$r-VWLIn)1bfy*}#R5>T$pj86S-=kzC@S1K@F7^a@h1RT4ZS-R;_rf}Q zmRq#yjeX7&GdaNO4?zmO0MLBTq_5}~E&SJFXFtCEdw=;*i)w$=cO@zF=pD)farFfN zkZ%1wNLA30Y`ky_B?FJ%^o^?zmxTzC3MUG&n}}BCKl1whAw9p&n6&c~QQfBWE61Mo z>e5@u|3}nUM@990@gg9gG%6*aq;z*nNrQB!ba#W&-6bgv(%m2}-Cfe%IpjO@{k^vy zYw-uL)-ZGLx#xUp@2%_Z;Q>isg%A?C{(GSVUM3^P1oc0p2b`m~VWQLtuh%NL@w`6A zj5XOM?OUo#0yWr~E>=^fvp4--%TFd0#%s}qMgw=Q^(5Nf?yb(S0JV-<(@M8yayfHO*;EFw=?bUXQ{!_l$PtROB!88+t$dX@fgvV&mZ{xHN%LFSa`!gOss<;V$zgdKJVunlp?_`o~QJ6rlZW zdqjL&sz$4DOd#Y~`1K7O8=~POTHbJR3_M|~a|1y?4~gKS*t9rY#d6ND;Tj`P?S;A4+$VH0m}mq_eNIJcxo-A>PpJD&C3zcPHVLPZ zbVx%@k0%M*q}-c`XA0`vYAIgbH1s*CDyIC<{!J|Z7he?%U9mu|F`v9~dH~?s_mYcBVSvwb0(HwN^X4ho`S%VCm zVEDGt$x1792+K~*3ky5X{n>F7Fk>2w8`efXnv_Hp3 z+1163?lj&XH#Z)XH3P6Y`6o*_sNwnP9uJHqzOi<)Uf*zFx1Cm2JsXemj@Ptly=r`~ zo{9KBp?P9Lh(EJHi@v<{|EAFT5DVW|ki-Pr{LuhavcVxCAuMmEr3Cd?gWR@?%O@2x zI0WwRjt;kSnjU=LAi+00-5o%{FqzI_j#W?D>*}>N{Wi$3%{kBtfk;}5BQ@FyCND$f z3@{Nquedl2OvQtaUM_3g#wTB$loLRm5*}@z<8;5I1Y-B$VgdfiY#P_?++3e&XyI4G zOojyW069l*SlRYvH)T*hXS)`FV}E<94<2(k+V@L1T$5sFR*Q8^+}s2I{(VG5D`c>l zh5c_22<|Ze)B30rLNh?EGW4q&L7d9W%^jR`6k z18{Wy3OsEHfMmB?y{xvrd!1tO^nb8A>iHHOE2Nw1eMQ^z)6*8#tbIGn5W+kSb2 zaOZzs-~LF~+S2{*G51?H*@r|umot1gytVK1HUYsz}~_pN)z$UQ86a&#Ns-QCrD zetLWuY=1!ZIYspOx39_1fC3GuqiosZQIW@p``6Xgu~_G3CMW-cj)#W=t#Q-%rzdYP zI|cL>(Q@C*vz)8=yt?_)WW0P8OvChqOB`*C0J(@tSFr~@$o~R~Q#pRMb#-kY#o`=d zz>O(u+NUPLblD`&+!1qe;ppn>%AMSE82O$cTfpU9a@>3lh4QYm%`3J0ZA>gIT>u6` z&Xd}uX}6vIm;PqM-Q)+#Rq3K|Ms_L6@%1=?OYpe6b)-_gwYXjxcvOBbid0d1g%K7-@>u+*ic7Tz2t#@}(!2Q*SF>X~qK) zIjP7YMR7{CMr8p-`rF~(6?6*>n0`7Xj~W3K*B|rw+aKFnH%I3*HSt!hh$xgFCF5$k zROEX_af3gx3wM+cEHo%ss`0Akx84_E_)43jET)0uq}Cu%(n`na8YTX3G@b-2_K$}t ziGg>ESMmuc-#EeKhiG(0w{v*9@rvTMi?}ZT+B?~B6igKHEj6tEe|Gh{X;~XzigFcL zoi8)3ir$1{cpNag}K^c0`{0XUxnXg@@2vE^_%yZT2U?Qv8+}oY;Wzna1_gmkH0D0kqmf^y(q@t_s&i$z z;cM;Ee-bz!aquv8hZJaNZ@3#<;+mVg^#w*=e6tu*ULEhq@%J_NDk%7LU{w}wL76nc z`NHX8Y6xXhS-_%7r9)b*5c^^f?*$E;ECv;MrKQ5S z|M#C~`Y3dlbw(-D1rwX#pQfjF_ZNBN=O*|GzSC#TK$c)CB>M1+lSO*YS?iJa-7xb) zcI3g{+GmYy%)B!8jvN?U zI>g|8hD_gbDkP+_c+cyCy?Tp|j$Z9jzF&Q8X#yr5Kp=N)5YVZKfX_YNFNL8sfz$Jr zvD|IgB4gTB8O&nC!&`e-?i!HcIHE|O1OcF|FY{?H6Km?2n7<%ux!EO7G7lFI&rQ~_ z#Mrp9fFjQ?b=hM+ z-rT{D`$lv*eA4vMG1!xzT235N7c$qrBlAKw<2)gQy4#UF$769Y$zUXI$ft~dP>~MC z#$$1@0kWOyHb1Bn$ltCN0+}~Ee?#Sh>JOuyYht*(V_o`BJ4zHF!=s}k|1N!@EDR8c zes9wfBL_x1JUr|O_=v&HJe;jEvhW6I4^7lLA-+H-%~7O^`>E*_9S4vE)c=blVJ8IIm~gnWt1I%zu;eXj#qk$OcEsbFhGECS_1n=0 zOaD@Cui|My%$zRiEy6)v;YbTk{bHS>7b9~iK8}`chW#0+vbubrmP!RG_cy^@mty-Z zmvCIe?9^ZKAAXUPzNw!-nna!WHf)k|IK4*qc?(taj;re<5p|QY_`>pIDMCx?WWTKdjEywresj=1D`3J>@vs_)CN6kQQ$@pRj-T?Eudo^oP zoSMWH@7x|`l6KXokrpnWTfAePlR6x%^ZO*L`J>l*vAx*Xyb!=ug2ErAMBw%%}jZy) zP834CNu%gQpU?2_=yZ}J%wK#ux?zUDZta)ZUY`FRRd<;I7rpKB>GM(ION)8M$z>k5-LWgqyLN7>$)q&)u^$6DKJoYXYEDaxyI;m zeYm#badHL3yd8E>$R{F%I@@N9lqLNuphWlfQlb_koBzf52TFfifp4y+LcsyTdv1KJ z*cTp0!qZ6u`!TAsiRY!iIDUsMHV=FcqS&{}Ns?l)&@O-8m{2v>)Yhd;GSTtMM22WJ zeIe9q917iznJu=yde(ig5DX4@-+J##FXKAp^7&?>WuS*8UbU~kvyDJs z-aSzzountp`{w8ve*y+Yf)+W+A|#(bVtm93ISu4!`H|FmXq16|1_r8wsw0vte7sQv z>B-#u(&X^I4J2YvnIJW)@I&yQy6Qs-8@OXm2Qz1vlX9eajyKcQ$>4N{E{d=(L~j1j zQ9nyAt6nWvr8ZtOOok~GH_I*`pi|SbJ~b99QA^9nl$!f`lrgcZWSZKnw5ZE)N|_R< zj+;7)b~)uKbkrRbYxs5itIl|?H6CxD1LOdNVtytz;qx97Bh#+>T*cqD7GzY^IdGL% z&5&1~x7si*zc~So8;y=zE@Yn$d>+f)v2b)fnLr*yPfzc=;Kx58`XR@6^;Q7zoy7CG zx?#HdrOwk+Mksb2{fnEVz$_pzD)7)Ha0+-{3K)W^HCjah$^yY;#r>wJ(wAlLtoZpy z6U51cEG&vox|jcpweFyR;Dv1SXuK!?D0nTO+aRC6#X48i)@=}DFljuI;(HhX1=j74 z&N^4WRnMR^*`=kWX-fy334%OMT9cq>BNz*s2!+1wfKY7KEm}jdGxT>|LFhF1eof;C zhyu4ScG6vlLPUIdjvM?KJlBvtpDr?YW;AV#0LSAwX_-{U{=T=@G@3A@;&gQ|{|Dq? zpfj|9j$*mmmJVGC;#4sT%zzY}fI;SGjiX+X{rwVNlPt2lL^8)}mb5ZS)U8)bi+_@FK;5z9ckh%CHR?cyA2G48AW5Gz8Rz-GuNj!d zIx`E4$*rAm4BvzDcA~;B@4bPiFa(vyHCN8DXEiS@${GXJXvG+DH^Ey{*Kh+f9^bFt zBAmGP@!Zb(JgORrerCnrf^rrCKp4Rp>c7O%`a_r196vK2}Mhrlnqdrd#)=hg9MlZ+x(E0zCY5#tYl&<@@ud3xZF4}b1zwU3%B(xS5 zV#zMWh^uuW7pNkotNWqc>&ODKj??}Zr|tA5ee)r+s(M^M8F+{}z@V;ea5(YOl%s=6 z_^By>BX#%KQHRa7pby)Ln%3h+U`yh3+>PFGwX(L}{__KFKypL$Y1`&05F{$LTCQu$ zr{i=Op)aZPd^dYBXBcI--W|eXF0RAt%$}-!VOngmsy)7wW@N|pT;wU|d8cOfYR{Z= z+G-h+#82l|X7gsb*)y^s>9NU$u0m*f{ob&wOIgYZ= zV$j4-OTno~pROP`ydR;-{8Js3L0zDaL$9*1BiW>)dtzzObA7I&I>=&q^mCJ{44+ud z>4PR+*m#@{5;WQd#(6XX!RBXj@+r!yHUR5!0+2ZJjdxS&UhOAdCmYagR47fE>0j+n z_z~wb^=%12>WTdDeA_2gYzS`N?LR~TaZSzl&k%uUli3|XQc_Z>OpbhzRz%(J<^5Ok z;E%Dtb9LkMeB*XG{sq$giN9mE?V1hX?3)!21|Kk6*I5O>9GeMcBYw379S!XqEWbF! z51!GF_Xlk#&v)g|DHo#xnQ~tHidr5=wPg;6J>A{#U^AQoiiq^&H(T52i1!>Md7Hu? z?l9_Cy?Iu_!gL$dT&Y^$5sch8J$ZgQY1w8gACKduN*WYg{@08J_JN_HA&d|a0M3<) zl?S$%r_B@iJg#YLg^QF7z^(+IB2EG@6UHCIa8iM9n2l>kNe~X&Fz73L4-bTO?|xs5WVcqdT=}veGClNOCC1MV!-o} z`3%Xt0Q*C?y^HN(vN#EXKK1Da&iBy@3e*XI zjjMql1S*a@^e_giR0wn}J_9=xSkK`*p+#T^ee)f9b;>*fjMSIx`UpKify38JQD_#3 zzU_7$=P;v~)c+%P*xBmSqR&Q(McG<*82x(FLD^(=>8r5fuQ=r{7X9-cCYM~FLd0^C z^NR)BngiS5{AS^M*mRPdu&-mt#2v&qKc=Fg0~M<$+}qWuhI z!B@Px{H>-s$}XzPs!lGg-d8%?WQu|=nxy0YY4v8RaA?iS?xul4#MGV3@$d=38XZKi zM2%=`pBcQKKKs3C>lQ4ye6RPb8jqC=_M>1$Gpdi0bKQpse@fB;d9iPTs1YNH>13=B zmGOf;MyrdOOX91}fc>h3nVXPW2ZPy3Z6cI&3msTP~!u=T0Yb(;RT1Jx+%6 z`YT97v-5H80_LY`j3#X3r1JMtLf&J$ZPvcaXcFKOqE{TWBB}J4werVmMaG4!PL4>G z+axBu!k_b8CX1JFBO~a<(>L!kSs0G zBjkNnv-^mG&iVI{v#C64?KGO0JKQH%^A449-OMPEB8uw!+7nu!aMjJ(k4P~s*(67s ziLqU?Wl@wyt(6SxK!g^BRKGt8<^?q(^s3$ZeXDQc?;DAPQLc#z&Q+!P*hNlOxAF+i z{(bCGG{J`@tw9L)LLn}!K*yZfx)bx@L88XQCtbtH>)zcPOjfhNZ`);zlZyY2Jj1B1 z{eqQmGNkz<)6&ZU`IC8R@wV#|+~rLsqN4A(`tZ2$Z)0K2~@m`lC^4v#e;JwusK{KUo?=P2I|LH&|_ z7@5z*Ssxxg{(3me2xIzNxT%>L*wf?YlPdQsb6RZV^0qtb#d@0^3*GyaBA*hs3(%aq z3!y}X21G;BQqr!6v-kxf$q3L8q1gc%)v`^HN(F%6ytdqHcnbfYc&9;SvMfS16R^Bf z*enXm%S|?VBb1cM{qkH}b=a*Ix(5w3s17_|ml;#n;RR5ms?wNe%E7cdXh1|Z zRZ@rR-#(BT_!)_%w{AWIPWs{F@7cK#MFh+Go;{((d&TF`zQePw9 zH}Ab8RXY^(!Oj*BiNuOx5+p}z9R8HBNR`R18GCiWv{WV$ct@mdnPZ-B$0fYw2zf#7 z|7*@HN36((5z8oa+RXGKk{CG>YwIO1W}gE0J7$W-&V7Tw8b5ldXX{Il1`4RrC9*b# zGYxPRt1m2-Mq>{!&|XU1dWDxK-X{z126A(rzy8UopOzIRN@BOapFru~By07k)s>8o zkE=KF%}v_B3v+*Gm?Qkama|iu9E<8tTH|@6KL%0^<6kxz!xc}rb6_SVb1#0Ghj)Y3 zt0og?{MvLJ^B`oP@d8_vi4acgeDl$7zLoCi2};}mm)%H z7cQFUFEGN!aA?S@+hF3P(%wdiVM;QU^qJNw;q_ikP`^)L+2n?KD;INvBP4%ZrKm`= zS{=CDoVz-2+q_JxSttGO1LFw)z2$!~E3mv(%5~@#E1H1-ZoL)vL(=b|V}|qj-mTZT10oQ`t!Z^G5%t%-puNm4CMlRaLQ2I`l@C^9PW6$0jGc7HTc3 zsZRrgg8l=CV4QFc#ZgRPAcBNMt?QY=z`y`#al0A8vGVu#A9Hi__3k%vOBUpvE0h(H z-20T+bQ;~@1-OnIHg*pWHvt(l?C^c5pj-a?_j=41qBT&gLNb_0w{dq+F2}I^3c+v5 zevqyO`2A3wc!D`2Pb%sBBJ(+|dXztPf8TtBb0geQgBIIxxyfnC{h+i3_=~Y`c4K3) zzz#B3XZ0TJr{#?oBRmNv7N?3?f57;xG?x`O0!M^}tXwvBy#m|02qUi2^_&bN?yuHXx{G%&#Or?86h<94KpLteFXK#@+LGXY zop_^T3IS4#SA6}65+pp-*{LxI5DooVZ9VQZNAkf@WkZYoR0dQ9oLtA3DEa6 z&+~o)pw#X0UqUI(irdal>J_>*Z)|STfmFC(9V5SjFkP6*`FCF={&iypj;1RwQNPUS zj=-}Ued8vUb;BBhH;~$my{vcc|i2z5~K^bBN!Ug%k- z(N?NiZ$HG;SGZpCO?IVEXp;5!@88f+N#pf`g&Po#P`#G`npOS!wS#R|i!>qt@R4U@ za4n!WA)nt=mV1v3x{#Zk4%8|QL>KPPAUprbBU^xOWa+!5WB3AyA2+Mx0ouwrLj@u# zKBA}`vy>tsh`8ZeXMmPBWDBZR0Y=gO@$KtMw+myHQVpkWnu?EZ%Qv%>dKV-7-jFXB z+}>VdzO&w@ZHI@o9D|Ua&NuS45<;_;->vBgTCcaO4ZSkkqBXfI&!hyWfcv1TasK9#skDb*}O$0yK~gE@9U=cjedA=#?J>mg>&&wDk&=) zJvROSW!SKM%tR-^PX%_lLHg$KPZ_Sh02?F%C!Hv)rxS>GP_PE1}=fJ ztG9deeJ>hi0{09kKOncT2CX&8O4p{x5eg>tmi~Os?RlWNYH+nb4Gk`XjR9=^1j6Z2 zN|Kd^$y|amc|SaA5{+4iabVY8XY7%B!4Z)M$O;@T)GqqEP5)NjvoF)A4TXl7 zK`ANY5v)m9AnIOAG{GBm-cuMHZO5-oCxuconwpw2@6=)~@Iox@Nfq;@nUv*)Ck)O9 zXv&p(g8Zi*k8CL`!dq#-M9K*&D=X7)TKu;m{k2QpJw6`UH`y1gH0XK#ySNy-*YEA^ zz4-TdvuXl9Y+%wnm}FT~JJcpZMNdsF8HBj1Df(T~yozb&JfTa53~No``9c5!A_5~N z>eaXNqu#yXk?%^R)0`^#@-{@I)3HAsuc?g1>&|hqzZC3Minrjz>$0j}?uC9&;sShP+{AG(5j6rN;b6qYYFLFQYc6pm)d^~AYtO)6 z|2c9Om8ocb46m}^lB}~{9sr!di7lk11w3lwa&TeTbnCYpQ9Do*H7`kLy)Y+Ip_(8D zi5RT>x7gUnNw5d<6QEv{lOXYJ3H5Jzvt#^72 zh>xUVVJPshf(l=~3%M?-s|hmA&d<-m8DKVfE-ZQwS<1;wh>i?8JiICpov}q+8ust} zDm)L{N{FQG{Ta=fquQZ(e7?G1dN+t{b1!%9cTCY&99Var6jXG`OuqK!Je>kwXBLKb zgbaKj0<*o4jRomicEu$*8S^fAVIvA!o!^Qqt&npr$HcPav>VFA{#l)H=mQxnfKpEiQyi9__&`$iVJB< zu~Va)2>Kx7C;rQ!UN63_j6DZVofsGQ93%9|8WDAO&ytuZ?jo>Dzb08XR4dPHY;h%c z^;5fJV9|RnL)KDa z7ak3ge9sz8krr(cmVM;0rG~gR{(_oqexfkF3n#rd=OQD_6QZp23=U&(aHcVzSyL?; ztRrqFC-ss-0qZ8mj>-}9w+OpguNvr!5bc~Z)DL7%Si-+;(r|eu>RCL7ZAx=`;=pd>oq$B`=HbSd3Io>I)e&6cK_$(xw+C zVTBR4s-itK%sn!smHZHf;v5$&_Vpx>FobbUejCC{0+;?PjRybKn;Np+el?ESjDV&|1_bRbs6qfLgV%sUz{=aKh(tW$UCk^3*;$x1bqji}J?nP6 z7Q_Xr?}`cwVPc=!X3DfvBPG=os%*R^&|aRorpZ&*%*qbaP*dLuJnuXMgz@&>J3D|d zF90w92~hI-nJahN;}f;Xs`~+*pVK=*GczivZ)DT{$Swd#e&cqE1zC@*p&==Fl9?%u z`$*WHuGy*UhmAL?2I)7lf{50Cnq;g25-gj^fPr)hf@H(Lr1uY`5I~VWEmTWXFQr#} zYF5~zqoWf%_wu3*5U#6aw_a*+?CvH_7~0YH_U2dB^-B8=R*`1ub!waA4fD0HD&GtW?9$w}e?qf{3JZ89Y5L~11v6LCh>Se2 z;#8nP(i0kmhY!a{j3GnCyrrXyOYyqj$R-!EEtTw2smlAw?Z1(Ui_UYD^Q-?a3-EUA zD1}1Ck?qfhtpcmt%yGD&v>c1g}gbg^4031&`J zaU=4Ke_Y!mLaFCNn(6g=A97-=e}6^b)%Kh#(2pYt_}o4ys*|7 z9cN@RDym$H)DzOYO>KPEB3Tj|;;{4O!^FF#qY~VY>-JeVN~FV%Y^RZqYd8H2Va{H` z3-e(pS61_o7jR$Q4CJ+O3(V_0hy5{7=8odQ(4EbI4odO>qY0;|FG92g95KFj_Nh0l z@e}wZ-@}=^13kv*Ag1i|T-$%6BWC37V-ra5@v@z_J%vA9)SZx#Y(5dl`Kzg0(} z{m3_Sgw12CihHWa`QBJv@SY%a(TaVWF23C8b4L1J?RoNR1UM8l*SrJd?-a>=H>O<; z2x>KI*LLgnTt&(Ry~xD2bA+^NWJw)sw#>SAFa#*@ln_qoqV;ZV9Nz$^uw1*NizY|~ zi}|i0X*zw$)+E_aatbg)IgkCzAAd>YxPx!cR77FD^gFD=UKRy^YTO%J%3>9$X+Gih z)>eDcBudT)2@3^<=IrM(lV$6t=(^)sw4F1vOa)GF4;&hp)*(F-zF;kWFi@9|mm7DS z&k_(i_4a^sW1s&t#`G?ZvM8opj_fTN=0(h3l;A8gHR@EmguxB`q@cU`E&EjDj%FVT zy{~C&Eb_tAI)SWZKc4hH2%mGSZ;2l|cpH<;-*4 zU)AM8H%9)*Ey98UipQk^iWL{hKtsiTqTz3@ebwc-=X@zZD%+~>cVt?yJfvBef zuIk%5k}5PA`;?_H{#xJ_2ta|*#y~|2TaUU)`b)CD6(D)_f#RAN*?S3XOlMzTcHO zZO$g$c@qezx1%-cOOnHFpO$xN!rb=ac$v)*`b_|KzyO0@KJM-so(GO*UtB0_j__a)DUv% zi1xSh8D5!23X+Fjm9l*D1oNaMeFc&6nZCl2;@+Y$>_bLKZi5tZq0;9mmi;8STgICE z4f}y1L(-8L;Y1=UVvG86sq;*eeQYsBklv-C1Shjf> zQ_r*zomk8`h-1BoSyl_jqGz>?XOd#=uO6t>jrrL|S1fQ6CAuwsIOl6|{B-W)q z*{!^8_*`d?Z$!~2ldhOxl7A%QhRXayK9WYkE#U$w+$x>A`g0vlcz8HQSPxo1@|N#Q zWHrFB8QN}1pywDM2pTgIdR|_9P>0l}4U+$MKx?Z9M|ZQNdPGuF0(u{Tt&dv2IGp+X zU^3~9A#^&WC}(%x|EXBQ3^~h7y~&kw%!#mkb`W4wC`-t@$p@tv`}_N@C#^S7k@VEP z6+!B_ONR1o=fPE#>3DX@?1Q)g5Qa-MY6lo&WSG3}E*)71fw07|tP6MpL;HjM47vL} zB{j9sWQ~`G3ZU>qATC4*qvN{v^5eW5bTum?o>PUj+Hy*N{fgPs(_?5&g&eE&zT2Sk zQGs)FXD3da3`K?R%j?q8QYaJ6iR2FL?cIFso1IMpnn*wo`2k z>KD;RTa3_idmo-O2#6$&N7DLpCE{+u+Mdp3{oT1E&uq6YvUdYgeG|`UL0u)f?fgg4 z%i+Lqvgc6evD)g2?rik}C>jVZIUm_Q6)sIIUzm}JuW#GV>a?zu(t z0O-p$P~5=qU0o9>fr8!e1`V37&h~MlGnH?+MiVyz=s>BE^D~ z>mcbojR6U7P(%wagaix?Kr-em*@4pwV&l>&WSU4OvEpQ7tX%7Q1HaG2mF@%;ej11k zNd7gbWHgDiJo6%p-RHTt`jH$Q7o0-V*0n|{%zv>}`a=-I0KZvaEIj)F;cIAU=ed+R%^;jjN%ckR?6Y%vJmV-UWbf z5&-0k@?J>0fA~IMZ4|cmmM`539>F*C$QjE=4tXmvSAll(2IDoIB*P$&JiOoM%R+QM zTw#&NUuLE%Ia@{~M8fFDDq}|>rmO>i3aYhvHrCMI$j2z^ZE^krF2UGz?T!%|P{jUQ zByb?q@C{Hyb#O$a0E@#GuqdeBWf(Q6rA3beeRzRfU;-pc-m57^TCD~Q?b&&tO#<_X z0HDKU;)2-nM-;EaA`{)|{W@uG1I2QW)KKStF zGur`O7UYw__2>mO7@SYYt^f-|KL|3;z~Bgr8+g;nd>(bVX|hx!kxDOTOakJgs)5i$ zPF}iY0qU0neI31pq^nwQhOuIKmZ&9Hv(^Skbvh2t|v)P5Mw-Ia0p5V%@4 z?fT>)b|3=dV&ZYP3S^Bm@4G#-moq>u9t0NE2$1hgez!D%$^+n0@dEuN&F2YXCe;Hr z2UuGmr$U==5rTkmXvj}nM(uDD>Frs;8 z(L28Nt|<7qPgTuWhlAo=zrK1*esuf?c4Qr*_GvQ)2|Zi%!4!MLLB1<=UB_A4QF{mI zkH$cjP{04zL00f*z)p~gib@~E7X&}rn$E(}=mvk>bLf^1WN*qd!aJ9)*&L?5xQ@QV z$|K@P$TvuFxor4pZ&f30zEY!w&Fmg6ZHA@H-sF?7^**6^M{+A}GpBvJWqzTfW?1Gt z-{<`~MHDe}*!RRC<3!aM@~vKGJrb#OT{_h&;le&P28R6E&x3PHF&gyJ2Rs^$%R-Fh zs_bs&&(e)Q!#AIDUNR*O3Uxgh_f0czVM+W{PfeZfD6ux|pW66cmAm9xcIXySWqDpw zHFXug*)I^wO2xX#mK5_lnD$L?(`SV`j+@HL%|M5|Z_qc4X5Ox^6hA*cDWn{DrbYFW zdRAdX*pweJd_*w|W zo1pM1g{`|jblG|b5Fle9eS%hQYZnl}Ikap$UK(md12GPG0w_>z5iFOp`$zB#kcscC z$#G@@yDZQn=3mEbUXS)@B&DIQrJ@9L}OOfvg=8HM2>wu^Woti zA}??TTCQd^dBHQp%E95VU{+A1eiOWGZL&S|6S^yrVTH8n8047YLs=YDC?4^;Sq_@q z8`^(Zv91S=DrTV$3)J?^h?C{+cf?bq#ohqIo*_681Qm)rK*NAjs45E0&m_>OO160^ z+&+3kD<+}sEF_K{xw+Q--+-g}J~wT!(gp<;H6|&^>p&uLCiX zmGbcgt0qyM0au}Ds3)Jaeq*DNY9(7oe39Z;Rg1n2yF2%4&9~eHXwUs6eI0K|mhsgS-uTQcUt;CMao(emSPKz%%wVoW07IX473c_z+VXG9vKo=?w~L za(#Tx!gN_VbyRauGn{7Bp(!zFTLd$UA@DSve|SFoU?!lEl5Yoe#$+8oGJ`4Y?=jLh zFtVydipIy+CI@Gcj2&hKNid=$lImCCxiqi=Eh1^o<)|AT{iZrGXD4!kCMKVn%1mm> z_~*V^91(C`BNtDHPMi1aTo5X}Ozc|r<+HhwD!~|=Z;4BOONGK~C8H!8O0}WUHM!a; zE~GOmux_0Xw`o`Q*};b92+sa8LCvRt_zp*?A}=Q({qYSA+p$hcS+*48B$9F_)vb!0iXaqH%5)f`o zU9ntR8AFQ$`V<7CxS6#l9c;Pc-Xali$7`opUE1ea}kMQwu(+7CaF zVC{a()o%M_fqz-cfu%g;Pr4!-_%MJ&MojtIV~lyfBqqFRj*U!UC_9GnO{rZA-uS>6 ztE6G;ko{j>zCc2+mgYgj;0Ij1!(aId-Wa#O{7r#d-iY{XKV%Is8`}&T!rI&Yv!dQ< zB37zzz1p2wL30m;JvaPe8B5!oE^OCwTDj-Lg z)x#YXb3GeQdsk8*3e~v^lCUYv8|TS{B)Q_s+Udjbl9F;zD>93Te?~^_?2P%}Q5Gw| zbOu&{ZQnJah@t(;b}vG9WioHR5b@m|0^V+1P6peN^c}zaz1qbH0?F6LD5n}W%m}gE z15ymulZ75}F%e$WT}uo0Tb@?|LPOzBUx{Mw{mAD;RsFOA|LHNrX^GB7->bO{b;)P) zmR)6`-K9DTr=mmnT<_w&S7rm}4MJ3xWIQ)xz$1g;&Xr}&Jc1JN9mBWrop-NHeAGb% z;@m_Nor79juqaig*7sKV3`zt7*@sri)!Ce}X4GMl_P|?S{mw4o^JJLU1Lp3? ztexw~+7$}M3^B2XDSs7eMhbC$J}?mqIh^w(Ocv7h|%q!M^hE+!bMI-j*s5m=9MjYj{eYen=hRzL=i+5U%PH_rq75WS{U9 z3uKoMUS0gqo1yLDdeYIWR4Xhh`r6~sZCrhH0RfmC7Z>+eL4is8$j>fuK%k@&X}NYg zV6PJ*BhlJG#sivFtF)YF1_%IZkU5Q5_QsM+-GVyGUSV{;ZooBvVE6)OSYfzMwM4Db zclG({#?i?s!i+Ev0DF=|2Hg=5WE})dVTXyZltHT@x**d#MT(&{9%`2XDO@bH8!tla zKecNwH!e3g1{sHb6N)f^NM;1AFfGssB-WP!Kf)f6hjXBbPyTxA(5MAHa9aR66CsIV zdiR&>Iuq&y0hbf+PS(bT0c;A-FaF4RpT7Y`o!MS!(Y6)9ZdI=~KDyw$lb6@k9Tj+- z6sQDViC`ptp&98{;bQNV7I=SuqEsY_ ziAWs! z)oiP5^<*~HcBkL44)o<^> z@gus*(Nywb@NGFu*i;?lPlQ#&qe`LgzcfvL#WIlhH!3B6t;TGM(#!JCWKYl?l1flX zunXtmTdJEcsa+CL2<8G`aMUig4szhKTKd1u;IRIt7LJ!rSX?rxeM8R?dGOm@KyiQ5 z&ML}?aEc47oqR!)^eQGZfAjmXzey*C#>k zSpY=vvnkC}dO@Ci5Y#3NL7!P@5jM2G5SZn=2M1CNs2Ww@LTYr)SGgRvZ9(fgOtc_} z*Cl>{uj_%7trlnm5$FN&fAyvTxa!cnvU-Ky3o9$DFX6BU;=RVzmBz#PpzeriVbO(w z!GAeauo_(;CBG85T2EKH&(nIST>72xpp@a-=P%PKs6DU)(Y52+tE(RrH-T{*VB)k| zGP_ku2Nv=F!U=!vZ1He$KQb`LDQrLGuo(8DK=URmKxK!rCN{`Fl79q!HxdupGPj#U ziK^Iy%pj8nsz!976sLfK&{=8l8C;NPum>u|9)$q9bPgQ3L;w-nKut-6*$Xyo7ULnk zl@>Qokgq2Ibj|!c8IW(?HIT(vws^S)^qSl9=Q{>xAbF{(;((GwB~?`ipgE+_qf6TX z+wUCsa+70Yg5Zxp4}<=3kggtgfjMrfDhm`ZS2*q|kY8aK1bx!=h|Lyq(EWTb#fc^B z{m3N^`aV^GjDX^S0MHVbT~>!dhEZBdYEVDo_{Ple?s5;xWuWgx;vN_7zruk-XC9Lb zHwxgDzI{i2ulNz;&%xC>a0(MZn1?i7poi~fsViGFOzF%d14M{GSxAQwD0un1^sexK zJ19^ffIff~RV-Ebe_1X8V%(1(FU($jjoeJSDK2XY1+O1y%Ig02Q7-{^8O!UpnYnp3 zSU!f4OfDIooLnGYFxTW{!Ogq{>g1EB8|~R?v85I!I)_LMZTbfXH$avWA2cN3KXYBu zlVHIHN6MlJBBW^7{T^R`)VP|-W`%cqIF2sAFT1WT5wPkCqrt?k;y=IrX$H#W^AH0c z+b=Vd6BDsXV#H@G465e~L4pVb0F2kWyYvDfRNEkTvJ`{m=)Rblc|o^6LmrWD6C ztjgRycRZ(yR>|ZD9*g4e2uxhWB*K=t!j>W~$qb!ImF zVrq)gxQODdiS*xesoB*L-fzyfoY8 z(e%MY3=iH{(1pi&i^kAIlVwIe-tjH{N1|67#|NaplKF3(YS#*flx<@}mGeM$-qM28L085^ZH}gU&+TQ6 zu&~K|+q6houRP9u)Vg8kti$urQ?;K9?#tq5MvL89& zb0*^o+@%_BDz+%PiI$5@4)L6XT2kMro-TT=8@F4iKz`(maT=Q2gHs*5p<=HSCxO8) zpJ-coG?lUO8UL<5##?`L3p3Wsi^v(EI?3RFhXvj-^X0{LBE=pD+2B9xBQpG0FW76R z+OG=qQU9l}vy6(WZ`U{oNQ$F`ASDfg)X?3Cw1gndFm!i!cRO?`DAJun2n;cFx6+D$ zFm!n~&vV}Qd^=xetywc`@BLx_?|tv<{$1DK)=$hU^14O{YK({Oh%F~~d`j}e$j{l- z3N;{kY-`5k6G$;aL;fKtti57>nwxKYc>5JC1v^q~SG3tL;x znk3Om`p^|(;z0`*=dY?xy^mX6I3GRkN#ZfWx>&r5iZeG-dL+govWxw?m)6~O^U~bc z3_U;^$w>M;qZTz%xxb$&U6I`PXrA3_dnR~HR8!?ns}3Mi?tl?PZ-4>I`aQ6ApFsk&7qwX`W&kUGk42Xobu5C& zUD&rr^7@cI3zjx9bEw=j)yz*Z=qzrFdP0V0eVOYU=XaxZhJ8ay=1=w6y8$0b`s!az z*$5x2o3+I8G&B{oXfNWlb80YMG7g1+!zRF1{WSG|NC^k;Tp-uogvlu>wfeBrg-%@` z5%z63=eBy+POVaLV8de+hk7|L4_WKX>-KU9yVVETzsU-a#;fa!f$5nq!n%wNLPc?( zXbHViu1L>4iwRRLvMJMwkY#yYfx+~0G>_kGqE8V3UbiF}uY+emG= zUkoN+9W-*iP(A6HC$C2G4=(By!YIp;)V;6P&t>kCx=q{UrdZS~F>r1SA1DO>=4xmwk1~kcg72$q^F4U^o!X_WS&P9#+s%@Qs1^S2iVT<{wpI#vm-dkPqgdv*+ zU~kDj9r4!#(CTJ9nEG1_r}t~gJ6%-i{w})Z1te-x6^DPgWYgQDbz$LPe3s8i*RWFV zH?pb5MiC%nwnV<4yTP6?KIsrAqYma&nm7QelTrV+JSJ}8WH@1|+lyBnDNe?z+k+}> zp@D676urYiRt%r>o7(bANA7OJMXl|iCa1Vdgz27vp#$C9~QunvDU=^ zr(|S2Q>RqWxe0GuHS5(1qUZ-`>F@QSAPMt9v{hQsPuEX8vXQ>KaR-uhFFD`J*y~ov zM}EG8lNElxaj&i~3kgv?9yX?XZn0+~ksupEl2YOvP!Zbd<89#ErUc7+$B<}CJOATo zgOYQN22vwPR61AKC?sjD9NlX%Q!R{0_8yTemY5$NulDmtEDW>cmczU7JQ{yBV;n0T zlW)_cF`CtorKca?zEC*s*ev^6X$EvG_x_5=)4uB|Bw#gIfcuL8Bw|rk+PARwc2S4+ zBl-IXT2+bL6AZHj_mAqDn%~}aUTLoay?V}rJv3knM+&sk{U_Nad%}S2{txVKC5Mqj zD?Kw1N%ovzV|>$6BZdX{X*zhzGeRS$YrRiF>F_Hy1>ox95`fHF^QnTXmnsriFDwRI%9K@glGekNyHg? zolML$4HlT(LXKcp z0LpB@yfIuN9*6bvZa2A*qH|dOi@uwOC})O z7^_@qK^oq-tjDljGzDG@v>R1rGG}1lnQGV*Q-vl z+x$yz?UqZ6RfIed0Tg5-1bQ*Qa`tmXIYTaQF;H#i>EP{5EneDM@sgDVG%yuXvT2b` z_9~kJJpAG4Z`?>dVUO-?&95Ux0c9wexpb7dz1D)b9c&=Qg}|QcJC!8 z2u4XCJ|I*CR(gT(L^-a{vi=uoVCzYS`(yy%cBOV(5v4Oo5JLfWGT{A3pyco?Fx$qK z#t8s$XTW07q;6m(GN(Mpubl9DReBO1oVYRI!fZB$~=Qd2G187G-x8HdcbjFg3No~uPHg#lLPbKGE zS_3u=f#lVCoFFgWkU%TYI}1!jmEwk`^a!IC!fq)}#HyNc{w(i9rh99UEl7Ee6BX{f|zdy6ILtN68L0U(=$}3PJmD4~8Ad=dxEK(TGi`aI{yN zXKT+q9#4*@?Q`u>S{bd*?~6N%XX5 z=RUeg#z9kbiF=754$CUX&e&~PncU>o1{l139hi~OO!40(oeLKYNRj34Q4YrU1yzZ~ z+p4KWIJhPyuCNesJ=PR~X&F$S#nbdX|J#7J71Ku^O79Or8J2 z=3V8IfzWPv4Cp~3BDF4Q0Rvz*0AV`6xFmk2F`InYF6ZgmS&~Tr8ir??2wdWy_k0VN_aiOIm$AX~mG=qF1zmi%yqa6SiH8(UCmX|RlBr>`=i@z^(K7NQcx6lO~#kY z1h0`vyUVXUu%5&kr$|`O5|v4b4jZi(LOmi{F%(0`E1j|248tUqF_#W|v0Ja9LBE3q zd(W((92*ugoxTA3D61Tca4(r2niy(T8ge2@f35KhUET~gWMlIdor!H?0ZkN6mON>l z!cL7_xaB)I76pndc~UF=lUFDtzoG!9SZ4#M<%dtDxxhc5chZpN`J<^{&@E{$NdQLb zRdn%|sS)fhBah&pdn&BCw~1qRXVn9;2hm3D;tr)9Km6@6R5JL(3i1O8@)h19PX_U+ z6uT89wcu|Gr)4yN87Q06J_+HDNPl`d_^1H-nc;GLr0c+mY#0S49|Oy`9m`|aZ)%(Tsqsaex^Iybh_e$3>kg;k1l4fyKj|?N4QNuIVj0>iHTV+BSOvqvf2NqA91fCo z@9vT77uS(+EHqe?3^MafG*xCi!9Ty0>0j4$YA0^|4gLHYn(pC*yLsmnu zQrO9GzMr0v4}s$QU|gCGu4;vZseG(a~qMWB}Yram%p&k;PV&TMP+chUfOLIcsxJ@{*Nav{#UfNM{^k@V2 zOj@>Z;Gr5}75d_ZU{J%0;x)8gQ}%F|lQ)G5gV|hE3X1X!vMP{8f^LIPga?y6$L=B= zTjKmrr!tF{9ntV|!z1_;=k1Bvl0h32I6AK$6Zi4bO3a#h-bFW(1%k=_}3GX``XC%-}%X&4!e0^HRUH&xRi8&LXRtx#(dNLm$y ze$tFbVWFulk2TKP4~$hY9CdSW-2OP6nG-{kkGQ(HyHwJ6z={DP?9K}3BTkRgOhuEL z!XGR0)t|u}e^JQT^~rCaTE*3IK{@anAs-gn?N`L-qHjIx;r*V`#M%f>ExEQ#(^;M3 zX&TC%+g}FUsq~88SoaM|s3hQ%T3K0%^uRU!R}DORj0E;|ad(#w_aUUuD&cm>5tS0$ zN2WV%zfsJz;exRW@VDwcH#`uY8{oYS2E7p@yp;TX2hNP$CJkI2x$x_Fwo zRGjCpypI*C++xBj78$-pQUv6)OdEpwk0M9QHteqS)c`L#w2n zp7*SQc1nejH?j~t@%bqBV;Q9Gn?lNKwSW3LO)V{1hN1wev45d97fN;jSgW(7c*Wof z^qU*ibU^`{K zB=bF*qPO}Yaa>CRQ7txKn;?iBd|Sp2+u?tc0vjFy)VRjsJQat4RxPnKxI@-CQOZ7S zVH5BDRbogcJKJ^If@EXIxts$Nm{Gr<-346p&?>7D;hR}v4fCKRnt;K!)Dq8YhE3q8 zyJ}CwM198y?sdwPXjSHK$!bo-$_Ko}ZEYRU0l+(qpSg9!15q0mV|lsP>)8OaM;}w1 zD3tX<*!a1-$4MgMf@C{G9cZiPC0y{zDY3(^uIx&_U`K8nE-^?j;Yg_|u!VacxBko< zC9T#?nihVJ*(x&dj`A^6yJ7vl%Ya3FRs^&;Ryu#Z)S{W_+fX1a*{%&O$L3(K(>wgb zyOrb|^n|CeVdTb|lDrHweJiVRGfX1B2m3$eU5VF+oE#o;Z90?^1AwCK=j;SS(w_!s zN5QH?R4)FI2`=g?>{lEj{K35}WD? zo`~ml@i;Hck>X>mtViSOhI8=}iqUcm4SsMo5x6gYX7Y~hv~MPY|F2bZEL^9BfPR&b zDV^N1HTgA7^pgbv_4}*~vJ*}IU5WIc~fXq1<< zcA>ShUkH~wCMlknSbR-KYnlbSnMR4&({g4z?0Bu1flazDtGJi*I z#U{e-OMa{qEcw8poLk65+PokY@{&nW?vMUW`yn-tpz~blZJLgDfrnd_2wtn7;~UKO zf??G&#opZ|;gDCx9_6c=Mk>Ck?0fq^nQWX*2i?{aOy*bQgEet=zB@oPq|!|d9PvHC z)2tu(=GXc*Q*2Vj`QxaQs~qXRhf^zJN;Yx!nv7L5C?S(>d%pmD5&fu|+Uz2{O1{&`JGD6yt=pVo*xVf)j5iF!1e_bpiv^=wGhw*sfk<`)4}38x#mP+KgP zJszz+md13JRZ@s3nw}mT8_4W67BwUVRBKWJ;fwe_#kg!*m9VEjUYwqiDChCKqG#@f zXjqJW$Zhs?PfMwOMxN7*ar5`=;G<#!1KanDHF}pX9d8=Sbkg73d?{_ypm+$56pABv z`X=bqA9wj+x%pV}0*#XUz<@gxf5fdgGdS5@v+Qj}i=2gdKXvjbt&-u-1J;OdIBXx! zMFy0O3e(ymea%}+cYG7`vhZ`ZS`nv1@F}BD#MrY9-cMb%IjZZ0(&@BWk9ncaa|G0t z&w+?meXS`ec*FJrcqF!}ydbP~{iu#JUbt7Iclnsa7h7liif(7&nM2TiY{0-a^8u%X zf(}LfZ2Lj4YV}FYEc?4?lYnN7M9ha(}oD*5C6J*eN1k z$bU7_rE(kjeO5cK26Yo&H*Rl;MSSM<;G{Met^9pgnr#*T*u@PgLpFK!k#9~%Fv;AivM^if)^@XI~h*d5bstWQ5LgZ(SVO8+W zG;b~>E_daeff*9$+eJ6K%4GC5{jU1n&9(#LQ@VcVQ)mq*#tPE!Z|y|Ne4e(g3suBre?#@v1}8*SQjy8 zz`xxvoAs4z`=W)seQge+ldv+Sa;u?Qhzu&z)~G%je5RW3StZPXa*zz@w00D>ekhl( zVd~IqYA?7bI_Aq+qZI~{#-TmHU+8*z*f*NcLPi37?Y*9|;?*@aZi)>DN&A_*>An59 zZN1wxBc|qqUrB`mqzZAQ|RW-`QKe$C%8T(H*qHZv(b5p&CHG_sbPMzGA3c^Id((( zKv`AnZ=a_`VWYp@UmW$DIf*;5%RTrl2AbQ5f}>btEVHOL=S|Y!!wfG@z%8m;!SqcD z2RLhIbw|gD6|ZkMT^MM6V?x)!%zxx+@wS4Cz}jwsmX&GJw5xx$@F@LnQw+<;)raL5 z*=SZU{pH@TZKmk$qFYDB^voYIl=-W-Y3wxDTm+ibV-}b37!OLwf*fX#G8%uIp`{62 zuSGo${mm71zJ9df`8%qU`K(5}g3meyq+sEl!oc9X>F1NQl0gBrev{nmP@cofsDvzT zlFNAe5%(;4iARmKg1*iZVRiUR-5ggj2Q>28ky1{cDuuzqpt(kUl7TiFQnHuy3D=vR zKg7G3>94Uv1FaI#5VEqW=p|3-qnS95LO#W!75!zw9K6W#g$7}mXJo1%WN^mXF&-TkpD^hN&Isfgg$V2cbpJPU=Fo^Y^Pq z+R;tG)&X0X8Ta?GxYYrkT-4vlN=ISjnA$7BdZu`6293i?f`Jrtb9&pF3YHXF4J#vk zCYik1hKBL*RIk?(yQ+q`Mo*54XO?vf&<#kqUxLB=UqtD4>obk~GrWgRAAQfxCp&3H z_nsE`m83u$FZTxzOj9$e@Ub|!<#n8b-=+G}p1~bsEN-g>#WDL2l)LT{%qBGCk9LeP z3}2!%j@(Ve0?ner+TP2+py6OBNQc?Pv&oVDrdF_@Q^6~IMxZZ>g#a0#6=T@BX+8CO zNqPq}*n4a|ie7P~VoNu}ifJKi-W#jmsfjAHa<4pRkZQa^?apdC)S=K?7g0-_qHm6yCM()%9H4a!7ah* zy#(0)50xya)=giF^X#O(jp;U#EQP=ixG0n4gEdMTECg}LPmssmFJA06#Md$?4s3wR z=}%V*5E{H(ztkCIws%ZN-+&LE;r5MFwrNuyDIkUxlrKwT!>S!eqv@!Q*9Qy1rSO2% z;`#=u*FDus4dPNW22G@TaNeC$_cp}n!T9IUmu3kzS-Gt(6Hk31{c={*g&J`eC>n_Z zQ|Q@Eq9ccwbs|>9!qsosWiF(+8Rhc&X(okw>(IoltJ@UiPQ@tECv7?l^inU-dbKcD8rhYh~kcdCOJD+V{PH$G%36ha9!FokH3Va}O5{!nbXU zf*mNt^73r)>M78SfLaGyhtN^zu7^4~IrWC5SFlr`=5CZpjcP>dCk$d=v`TZ#ZfoO@GSR=+q|W->zFPMiFMDxYDOw;<=noL z*U7+V3`vOdh!v+~)10N}-*FZSf(O(GRKolIP7^(Kzp|ORy?MWPYqh+M3CAu)+P5N- zzFyJsvElz1l^Gjso;}2-q|WrGmV2^j>txc9l#`-8QpcIMawy{b0AWkD|lV zYg%k{Tjj2MvpNff!@O`71~d(BNetIR4FxNF?R0iElz~GC{?!0 z<19?cgza&z{Yi^eEKMa;>FXRbPrU706#Rwp3*TOZQuEP+Y1OR>A1CIphlNVz7b{p$ z_(&xdD;$ua_EdJr$A2pG5G_J}k8Cx#t`%$Srde0CSfA!xi&M5jXcOp<2dLC;J&}7? zMcF@Vr|{?N`vU}V=2u-2^F#fQ%Js&wxlEw8W7dwYP@>Z=WS+p~0$pAMcSl2AFMOu4 zn#Rc_v4(~2i_PzY?77wY_i>(&bIwXmNuKMJ41dBF;O*az0KNYvSXk2vA)X_h%^}hP z?x+!TBUfmdR!vL8#xi!$?Jd<#$Hqu*iX=VDDUO(vGiInJ_b|J*|K>kC*w#rvme06vzPT^`&&NAIg(*agT+a%_lk zVAHMIoz5p~*5V?q?RZI|+_3{Am5cb$XJu(F`!?(O>fI9g>O=_c?KfbHReB2D{~WFt z`+Mow`6Ul8MC#521#(J_MB8On(|{duuTAxe|A5ZJU8mcX#2qpo?+86AIlotnd~;Y3=OZg7Ge^nGt@b08i3dEcneFXW)hJ z{>O-`g};BMuU`Q{+?;`@uST{F3(PBiT&)v}*iJ3{w4JPXTZb9sc9aZ^M0%h9iaYcl zTV8(0bzsON%H8Sz)%RT(GnaqO>>n;$?m7NaJuyekJ@5X|0E5jOzqwB|ZU=b5!vf4V zzEc9?4Z9v9(^>euC5!k@r`vJ7Bd|)D^J9YkPfzk+qsyIBLZQuN#{{)u3~l&i6=~}Q zzt^$X)C_T3WdCxl@OJfxsYJfs z0d|7Wf|{OqXOv*xqD#%$9cE7v5f8yM->_DW8Ec}Dz8?OU5BtNNeR;EH`&i*TOHQud z5zqDgQ=!CqzvEC}QFHBfvvI;FtyDML58@+)`W;5cqAIxgo5f|UU5zlNzbR$lgEfuC z9KnI8p-fFLOezl@9EeR>r*ETbbYrcjx{p3Ja22_TriSR9#%|kZgfn zq#r-@HfSiHzG<;7ui+wEqW72E$s|ZEe=Qw-Mk<`6f;nhby)w9V+vz&xUFS`>-t0c; zyvmyY&@8}Otfi9=3U|0(PkTuzbV#Lro>Rz!fVj@Dqma3Ct=wH|s-;8Uy{rdl_>pk* zaV0*j6=Ya*GfQXo{o2~k6ZbcJhI`bl?lbERPkgPded4ptxpeB2+rTHHTYF)M8xmB@ z`|NmcZ|?$*`T4$!|94gH6|Z$Y{rB7F!QX6XXlPZ6vQk?2Kc8ot(-QypkD&7`I}_ah zF6}5^75?gf4{^V`dpnr^Z>a*$5~I{d?En2Qj&l{zS^rZ6{`qL0GspOESpcepZEY~) p{~hW8z+(URivGEZ|NpdSYcjRXuREd?O@T{CQ Date: Mon, 4 Apr 2022 11:47:50 -0400 Subject: [PATCH 27/96] More warnings fixed on notebooks. --- docs/examples.rst | 11 +++++++ .../fmrisim_multivariate_example.ipynb | 32 +++++++++---------- 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/docs/examples.rst b/docs/examples.rst index 8a3037f6..b33744df 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -4,4 +4,15 @@ Examples .. toctree:: + examples/brsa/brsa_demo + examples/eventseg/Event_Segmentation + examples/fcma/FCMA_demo + examples/fmrisim/fmrisim_multivariate_example + examples/htfa/htfa + examples/iem/iem examples/iem_synthetic_RF/iem_example_synthetic_RF_data + examples/isc/ISC + examples/matnormal/Matrix-normal model prototyping + examples/real-time/README_INSTRUCTIONS + examples/real-time/rtcloud_notebook + examples/srm/SRM diff --git a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb index d8060e8c..53201e60 100644 --- a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb +++ b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb @@ -6,7 +6,7 @@ "source": [ "# fmrisim demo script\n", "\n", - "Authors: Cameron T Ellis ([cameron.ellis@yale.edu](mailto:cameron.ellis@yale.edu)), Christopher Baldassano ([c.baldassano@columbia.edu](mailto:c.baldassano@columbia.edu)), Anna C Schapiro ([aschapir@sas.upenn.edu](mailto:aschapir@sas.upenn.edu)), Ming Bo Cai ([mingbo.cai@ircn.jp](mailto:mingbo.cai@ircn.jp)), Jonathan D Cohen ([jdc@princeton.edu](jdc@princeton.edu)) \n", + "Authors: Cameron T Ellis ([cameron.ellis@yale.edu](mailto:cameron.ellis@yale.edu)), Christopher Baldassano ([c.baldassano@columbia.edu](mailto:c.baldassano@columbia.edu)), Anna C Schapiro ([aschapir@sas.upenn.edu](mailto:aschapir@sas.upenn.edu)), Ming Bo Cai ([mingbo.cai@ircn.jp](mailto:mingbo.cai@ircn.jp)), Jonathan D Cohen ([jdc@princeton.edu](mailto:jdc@princeton.edu)) \n", "\n", "## Overview\n", "\n", @@ -50,7 +50,7 @@ "- [3.3 Generate event time course](#generate_time_course) \n", "- [3.4 Export stimulus time course for analysis](#export_time_course) \n", "- [3.5 Estimate the voxel weight for each event](#weight_signal) \n", - "- [3.6 Convolve each voxel’s time course with the Hemodynamic Response Function](#convolve_HRF) \n", + "- [3.6 Convolve each voxel\u2019s time course with the Hemodynamic Response Function](#convolve_HRF) \n", "- [3.7 Establish signal magnitude](#compute_signal) \n", "- [3.8 Multiply the convolved response with the signal voxels](#multiply_signal) \n", "- [3.9 Combine signal and noise](#combine_signal) \n", @@ -193,7 +193,7 @@ "\n", "To ameliorate some of these concerns, it is possible to fit the spatial and temporal noise properties of the data. This iterates over the noise generation process and tunes parameters in order to match those that are provided. This is time consuming (especially for fitting the temporal noise) but is helpful in matching the specified noise properties. \n", "\n", - "This toolbox separates noise in two: spatial noise and temporal noise. To estimate spatial noise both the smoothness and the amount of non-brain noise of the data must be quantified. For smoothness, the Full Width Half Max (FWHM) of the volume is averaged for the X, Y and Z dimension and then averaged across a sample of time points. To calculate the Signal to Noise Ratio (SNR) the mean activity in brain voxels for the middle time point is divided by the standard deviation in activity across non-brain voxels for that time point. For temporal noise an auto-regressive and moving average (ARMA) process is estimated, along with the overall size of temporal variability. A sample of brain voxels is used to estimate the first AR component and the first MA component of each voxel's activity over time using the statsmodels package. The Signal to Fluctuation Noise Ratio (SFNR) is calculated by dividing the average activity of voxels in the brain with that voxel’s noise (Friedman & Glover, 2006). That noise is calculated by taking the standard deviation of that voxel over time after it has been detrended with a second order polynomial. The SFNR then controls the amount of functional variability. Other types of noise can be generated, such as physiological noise, but are not estimated by this function.\n" + "This toolbox separates noise in two: spatial noise and temporal noise. To estimate spatial noise both the smoothness and the amount of non-brain noise of the data must be quantified. For smoothness, the Full Width Half Max (FWHM) of the volume is averaged for the X, Y and Z dimension and then averaged across a sample of time points. To calculate the Signal to Noise Ratio (SNR) the mean activity in brain voxels for the middle time point is divided by the standard deviation in activity across non-brain voxels for that time point. For temporal noise an auto-regressive and moving average (ARMA) process is estimated, along with the overall size of temporal variability. A sample of brain voxels is used to estimate the first AR component and the first MA component of each voxel's activity over time using the statsmodels package. The Signal to Fluctuation Noise Ratio (SFNR) is calculated by dividing the average activity of voxels in the brain with that voxel\u2019s noise (Friedman & Glover, 2006). That noise is calculated by taking the standard deviation of that voxel over time after it has been detrended with a second order polynomial. The SFNR then controls the amount of functional variability. Other types of noise can be generated, such as physiological noise, but are not estimated by this function.\n" ] }, { @@ -290,7 +290,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -1107,7 +1107,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -1961,7 +1961,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -2808,7 +2808,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -3749,7 +3749,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -4582,7 +4582,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -5474,7 +5474,7 @@ "source": [ "*3.5 Estimate the voxel weight for each event*\n", "\n", - "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel’s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel’s response to signal over time." + "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel\u2019s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel\u2019s response to signal over time." ] }, { @@ -5513,7 +5513,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -6307,9 +6307,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.6 Convolve each voxel’s time course with the Hemodynamic Response Function*\n", + "*3.6 Convolve each voxel\u2019s time course with the Hemodynamic Response Function*\n", "\n", - "With the time course of stimulus events it is necessary to estimate the brain’s response to those events, which can be estimated by convolving it with using a Hemodynamic Response Function (HRF). By default, `convolve_hrf` assumes a double gamma HRF appropriately models a brain’s response to events, as modeled by fMRI (Friston, et al., 1998). To do this convolution, each voxel’s time course is convolved to make a function of the signal activity. Hence this produces an estimate of the voxel’s activity, after considering the temporal blurring of the HRF. This can take a single vector of events or multiple time courses." + "With the time course of stimulus events it is necessary to estimate the brain\u2019s response to those events, which can be estimated by convolving it with using a Hemodynamic Response Function (HRF). By default, `convolve_hrf` assumes a double gamma HRF appropriately models a brain\u2019s response to events, as modeled by fMRI (Friston, et al., 1998). To do this convolution, each voxel\u2019s time course is convolved to make a function of the signal activity. Hence this produces an estimate of the voxel\u2019s activity, after considering the temporal blurring of the HRF. This can take a single vector of events or multiple time courses." ] }, { @@ -6346,7 +6346,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -7292,7 +7292,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", @@ -8114,7 +8114,7 @@ " return MozWebSocket;\n", " } else {\n", " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.');\n", " };\n", From 98a54640b49c88f018ce785bb92020ccd9feadc8 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 4 Apr 2022 13:47:50 -0400 Subject: [PATCH 28/96] small change to test CI on master. --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index 2aa348d3..5af4ff67 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,7 @@ long_description = f.read() + ext_modules = [ Extension( 'brainiak.factoranalysis.tfa_extension', From 52719e775f387691d36282bb6ae9d810ccd80e4b Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 4 Apr 2022 14:38:03 -0400 Subject: [PATCH 29/96] Update main.yml run workflow on push --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 24cec168..d34cbbe8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,4 +1,4 @@ -on: [pull_request] +on: [pull_request, push] jobs: pypi: env: From fe8788b06afa91e33fee38d74392a345783af5d2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 25 Jul 2022 13:09:11 -0400 Subject: [PATCH 30/96] Some packaging changes - Setup build isolation, see changes to pyproject.toml. - Moved a lot of stuff from setup.py to setup.cfg. Left programmatic definition of extra requirments in setup.py. This is a move to more modern Python packaging I think. - Added a requirements file for examples only in docs. - Some small changes to meta.yaml to install tensforflow in the install section instead of tests. - Change install of package in pr-check.sh to a single pip install command so all requirements are considered when solving dependencies. --- .conda/meta.yaml | 5 +- docs/examples/requirements-examples.txt | 32 +++++++ pr-check.sh | 14 +-- pyproject.toml | 12 +++ run-tests.sh | 2 +- setup.cfg | 83 +++++++++++++++++ setup.py | 113 ++++++++++++------------ 7 files changed, 191 insertions(+), 70 deletions(-) create mode 100644 docs/examples/requirements-examples.txt diff --git a/.conda/meta.yaml b/.conda/meta.yaml index 883c41d9..6c8fe2bb 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -38,7 +38,6 @@ requirements: - pip - mpich - openmp - - libgcc {% for req in data.get('setup_requires', []) if req not in conda_package_nonexistent -%} - {{req}} @@ -48,7 +47,8 @@ requirements: - python - mpich - openmp - - libgcc + - tensorflow + - tensorflow-probability {% for req in data.get('install_requires', []) if req not in conda_package_nonexistent -%} - {{req}} @@ -57,7 +57,6 @@ requirements: test: commands: - find $BRAINIAK_HOME/tests | grep pycache | xargs rm -rf - - pip install tensorflow tensorflow-probability - mpiexec -n 2 pytest $BRAINIAK_HOME # Known issue: https://github.com/travis-ci/travis-ci/issues/4704#issuecomment-348435959 diff --git a/docs/examples/requirements-examples.txt b/docs/examples/requirements-examples.txt new file mode 100644 index 00000000..403764cb --- /dev/null +++ b/docs/examples/requirements-examples.txt @@ -0,0 +1,32 @@ +testbook +brainiak +nilearn +nxviz<=0.6.3 +nltools +timecorr +seaborn +holoviews +pyOpenSSL +awscli +bcrypt +indexed_gzip +inflect +ipython +jupyter +mypy +nibabel +nilearn +nodejs +numpy +pydicom +requests +rpyc +scikit-learn +scipy +toml +tornado +websocket-client +wsaccel +inotify +pybids +watchdog diff --git a/pr-check.sh b/pr-check.sh index a11ba20a..27b5d8da 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -148,7 +148,6 @@ $activate_venv $venv || { if [[ "$is_della" == true ]]; then - # We need to fetch any data needed for running notebook examples # Update our data cache with any download_data.sh scripts found in the repo BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak_tests/brainiak-example-data @@ -172,16 +171,10 @@ else fi # install brainiak in editable mode (required for testing) -# brainiak will also be installed together with the developer dependencies, but -# we install it first here to check that installation succeeds without the -# developer dependencies. -python3 -m pip install $ignore_installed -U -e .[matnormal] || \ +# Install with all dependencies (testing, documentation, examples, etc.) +python3 -m pip install $ignore_installed -U -e .[all] || \ exit_with_error_and_venv "Failed to install BrainIAK." -# install developer dependencies -python3 -m pip install $ignore_installed -U -r requirements-dev.txt || \ - exit_with_error_and_venv "Failed to install development requirements." - # static analysis, skip on della for now, failing for numpy 1.20 typing issues I think if [[ "$is_della" == false ]]; then @@ -192,12 +185,11 @@ fi if [[ "$is_della" == true ]]; then echo "Running on della head node, need to request time on a compute node" export BRAINIAKDEV_MPI_COMMAND=srun - salloc -t 03:00:00 -N 1 -n 16 ./run-tests.sh $sdist_mode || \ + salloc -t 03:00:00 -N 1 -n 16 sh run-tests.sh $sdist_mode || \ exit_with_error_and_venv "run-tests failed" else ./run-tests.sh $sdist_mode || \ exit_with_error_and_venv "run-tests failed" - fi diff --git a/pyproject.toml b/pyproject.toml index 7a213d9a..a16e7fa6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,3 +28,15 @@ title_format = "BrainIAK {version} ({project_date})" markers = [ "notebook: marks example notebook tests", ] + +[build-system] +requires = [ + "setuptools>=42", + "wheel", + "pybind11>=2.9.0", + "scipy!=1.0.0", + "cython", + "oldest-supported-numpy", + "setuptools_scm", +] +build-backend = "setuptools.build_meta" diff --git a/run-tests.sh b/run-tests.sh index 2bce00a4..c9f4177b 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -45,7 +45,7 @@ $mpi_command -n 2 coverage run -m mpi4py -m pytest if [[ $(hostname -s) == della* ]]; then echo "Running notebook tests on della" - pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests + $mpi_command -n 2 pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests fi # Coverage produces empty files which trigger warnings on combine diff --git a/setup.cfg b/setup.cfg index 2075d92f..9d21d1d6 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,3 +1,86 @@ +[metadata] +name = brainiak +description = Brain Imaging Analysis Kit +long_description = file: README.rst +long_description_content_type = text/x-rst +url = http://brainiak.org +author = Princeton Neuroscience Institute and Intel Corporation +author_email = mihai.capota@intel.com +maintainer = Mihai Capota +maintainer_email = mihai.capota@intel.com +license = Apache 2 +license_file = LICENSE +classifiers = + Development Status :: 5 - Production/Stable + Intended Audience :: Developers + Intended Audience :: Information Technology + Intended Audience :: Science/Research + License :: OSI Approved :: Apache Software License + Operating System :: MacOS + Operating System :: Microsoft :: Windows + Operating System :: POSIX + Operating System :: Unix + Programming Language :: C++ + Programming Language :: Python + Programming Language :: Python :: 3 + Programming Language :: Python :: 3 :: Only + Programming Language :: Python :: 3.5 + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Python :: 3.9 + Programming Language :: Python :: 3.10 + Programming Language :: Python :: Implementation :: CPython + Topic :: Scientific/Engineering + Topic :: Scientific/Engineering :: Information Analysis + Topic :: Scientific/Engineering :: Mathematics + Topic :: Scientific/Engineering :: Medical Science Apps. + Topic :: Scientific/Engineering :: Bio-Informatics + Topic :: Software Development + Topic :: Utilities + Typing :: Typed +keywords = + neuroscience + algorithm + fMRI + distributed + scalable +project_urls = + Documentation = https://brainiak.org/docs/ + Bug Tracker = https://github.com/brainiak/brainiak/issues + Changelog = https://brainiak.org/docs/release_notes.html + Chat = https://gitter.im/brainiak/brainiak + +[options] +packages = find: +install_requires = + numpy>=1.13.3 + dataclasses;python_version<'3.7' + typing-extensions;python_version<'3.8' + + # https://travis-ci.org/brainiak/brainiak/jobs/545838666 + mpi4py>=3 + nitime + scikit-learn>=0.18 + + # See https://github.com/scipy/scipy/pull/8082 + scipy!=1.0.0 + statsmodels + pymanopt + theano>=1.0.4 # See https://github.com/Theano/Theano/pull/6671 + psutil + nibabel + joblib + wheel # See https://github.com/astropy/astropy-helpers/issues/501 + pydicom + +python_requires = >=3.5 +include_package_data = True +zip_safe = False + +[options.packages.find] +where = . + [flake8] max-complexity = 10 extend-ignore = diff --git a/setup.py b/setup.py index 36fe0bed..02bfa93d 100644 --- a/setup.py +++ b/setup.py @@ -16,13 +16,6 @@ # https://github.com/pypa/pip/issues/7953#issuecomment-645133255 site.ENABLE_USER_SITE = "--user" in sys.argv[1:] -here = os.path.abspath(os.path.dirname(__file__)) - -# Get the long description from the README file -with open(os.path.join(here, 'README.rst'), encoding='utf-8') as f: - long_description = f.read() - - ext_modules = [ Extension( 'brainiak.factoranalysis.tfa_extension', @@ -115,57 +108,67 @@ def finalize_options(self): ]) -setup( - name='brainiak', - use_scm_version=True, - setup_requires=[ - 'cython', - # https://github.com/numpy/numpy/issues/14189 - # https://github.com/brainiak/brainiak/issues/493 - 'numpy', - 'pybind11>=1.7', - 'scipy!=1.0.0', - 'setuptools_scm', - ], - install_requires=[ - 'cython', - # Previous versions fail of the Anaconda package fail on MacOS: - # https://travis-ci.org/brainiak/brainiak/jobs/545838666 - 'mpi4py>=3', - 'nitime', - # https://github.com/numpy/numpy/issues/14189 - # https://github.com/brainiak/brainiak/issues/493 - 'numpy', - 'scikit-learn[alldeps]>=0.18', - # See https://github.com/scipy/scipy/pull/8082 - 'scipy!=1.0.0', - 'statsmodels', - 'pymanopt', - 'theano>=1.0.4', # See https://github.com/Theano/Theano/pull/6671 - 'pybind11>=1.7', - 'psutil', - 'nibabel', - 'joblib', - 'wheel', # See https://github.com/astropy/astropy-helpers/issues/501 - 'pydicom', - ], - extras_require={ - 'matnormal': [ +extras = { + "dev": [ + "pytest", + "coverage", + "flake8", + "flake8-print", + "mypy", + "myst-nb", + "restructuredtext-lint", + "setuptools_scm", + "sphinx", + "sphinx_rtd_theme", + "towncrier", + "numdifftools", + "testbook" + ], + + 'matnormal': [ 'tensorflow', 'tensorflow_probability<=0.15.0', ], - }, - author='Princeton Neuroscience Institute and Intel Corporation', - author_email='mihai.capota@intel.com', - url='http://brainiak.org', - description='Brain Imaging Analysis Kit', - license='Apache 2', - keywords='neuroscience, algorithm, fMRI, distributed, scalable', - long_description=long_description, + + # All requirements for notebook examples in docs/examples + "examples": [ + "nilearn", + "nxviz<=0.6.3", + "nltools", + "timecorr", + "seaborn", + "holoviews", + "pyOpenSSL", + "awscli", + "bcrypt", + "indexed_gzip", + "inflect", + "ipython", + "jupyter", + "mypy", + "nibabel", + "nilearn", + "nodejs", + "numpy", + "pydicom", + "requests", + "rpyc", + "scikit-learn", + "scipy", + "toml", + "tornado", + "websocket-client", + "wsaccel", + "inotify", + "pybids", + "watchdog" + ], +} +extras["all"] = sum(extras.values(), []) + + +setup( + extras_require=extras, ext_modules=ext_modules, cmdclass={'build_ext': BuildExt}, - packages=find_packages(), - include_package_data=True, - python_requires='>=3.5', - zip_safe=False, ) From cf30127e5e36ba6928bc64005c795f15c4cf3bd1 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 25 Jul 2022 13:46:55 -0400 Subject: [PATCH 31/96] Add version cap for pymanopt, new version breaks things. --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index 9d21d1d6..c0f3d327 100644 --- a/setup.cfg +++ b/setup.cfg @@ -66,7 +66,7 @@ install_requires = # See https://github.com/scipy/scipy/pull/8082 scipy!=1.0.0 statsmodels - pymanopt + pymanopt<=0.2.5 theano>=1.0.4 # See https://github.com/Theano/Theano/pull/6671 psutil nibabel From 243efdceb6130cac00fd215def94c4e310a6c422 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 25 Jul 2022 14:17:25 -0400 Subject: [PATCH 32/96] Remove typing-extensions and dataclasses dependencies. Not needed. --- setup.cfg | 2 -- 1 file changed, 2 deletions(-) diff --git a/setup.cfg b/setup.cfg index c0f3d327..4d452791 100644 --- a/setup.cfg +++ b/setup.cfg @@ -55,8 +55,6 @@ project_urls = packages = find: install_requires = numpy>=1.13.3 - dataclasses;python_version<'3.7' - typing-extensions;python_version<'3.8' # https://travis-ci.org/brainiak/brainiak/jobs/545838666 mpi4py>=3 From 709035e1545819085d424815f6a6c98de759557e Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 25 Jul 2022 15:29:53 -0400 Subject: [PATCH 33/96] Fix some numpy type decprecation warnings. --- brainiak/funcalign/fastsrm.py | 4 ++-- brainiak/funcalign/srm.py | 4 ++-- tests/fcma/test_mvpa_voxel_selection.py | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/brainiak/funcalign/fastsrm.py b/brainiak/funcalign/fastsrm.py index 7ac05262..d69d5f37 100644 --- a/brainiak/funcalign/fastsrm.py +++ b/brainiak/funcalign/fastsrm.py @@ -238,7 +238,7 @@ def _check_imgs_array(imgs): for i in range(n_subjects): for j in range(n_sessions): if not (isinstance(imgs[i, j], str) or isinstance( - imgs[i, j], np.str_) or isinstance(imgs[i, j], np.str)): + imgs[i, j], np.str_) or isinstance(imgs[i, j], str)): raise ValueError("imgs[%i, %i] is stored using " "type %s which is not a str" % (i, j, type(imgs[i, j]))) @@ -337,7 +337,7 @@ def check_atlas(atlas, n_components=None): return None if not (isinstance(atlas, np.ndarray) or isinstance(atlas, str) - or isinstance(atlas, np.str_) or isinstance(atlas, np.str)): + or isinstance(atlas, np.str_) or isinstance(atlas, str)): raise ValueError("Atlas is stored using " "type %s which is neither np.ndarray or str" % type(atlas)) diff --git a/brainiak/funcalign/srm.py b/brainiak/funcalign/srm.py index 3ed56a1d..f786aa8c 100644 --- a/brainiak/funcalign/srm.py +++ b/brainiak/funcalign/srm.py @@ -240,8 +240,8 @@ def fit(self, X, y=None): "Not all ranks have same number of subjects") # Collect size information - shape0 = np.zeros((number_subjects,), dtype=np.int) - shape1 = np.zeros((number_subjects,), dtype=np.int) + shape0 = np.zeros((number_subjects,), dtype=int) + shape1 = np.zeros((number_subjects,), dtype=int) for subject in range(number_subjects): if X[subject] is not None: diff --git a/tests/fcma/test_mvpa_voxel_selection.py b/tests/fcma/test_mvpa_voxel_selection.py index 9ff90ed0..2258e234 100644 --- a/tests/fcma/test_mvpa_voxel_selection.py +++ b/tests/fcma/test_mvpa_voxel_selection.py @@ -29,7 +29,7 @@ def test_mvpa_voxel_selection(): data = prng.rand(5, 5, 5, 8).astype(np.float32) # all MPI processes read the mask; the mask file is small - mask = np.ones([5, 5, 5], dtype=np.bool) + mask = np.ones([5, 5, 5], dtype=bool) mask[0, 0, :] = False labels = [0, 1, 0, 1, 0, 1, 0, 1] # 2 subjects, 4 epochs per subject From 53078a028518ef40772cfbf9eb07d29d0fab0085 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 13:14:29 -0400 Subject: [PATCH 34/96] Fix some code style errors. --- brainiak/factoranalysis/htfa.py | 2 +- brainiak/funcalign/rsrm.py | 4 ++-- brainiak/funcalign/srm.py | 9 ++++++--- brainiak/reprsimil/brsa.py | 14 +++++++------- brainiak/searchlight/searchlight.py | 4 ++-- 5 files changed, 18 insertions(+), 15 deletions(-) diff --git a/brainiak/factoranalysis/htfa.py b/brainiak/factoranalysis/htfa.py index 2012114c..6940ab6f 100644 --- a/brainiak/factoranalysis/htfa.py +++ b/brainiak/factoranalysis/htfa.py @@ -724,7 +724,7 @@ def _fit_htfa(self, data, R): m = 0 outer_converged = np.array([0]) while m < self.max_global_iter and not outer_converged[0]: - if(self.verbose): + if (self.verbose): logger.info("HTFA global iter %d " % (m)) # root broadcast first 4 fields of global_prior to all nodes self.comm.Bcast(self.global_prior_, root=0) diff --git a/brainiak/funcalign/rsrm.py b/brainiak/funcalign/rsrm.py index 9e2d419a..d1d6ab9d 100644 --- a/brainiak/funcalign/rsrm.py +++ b/brainiak/funcalign/rsrm.py @@ -191,8 +191,8 @@ def transform(self, X): return r, s def _transform_new_data(self, X, subject): - """Transform new data for a subjects by projecting to the shared subspace and - computing the individual information. + """Transform new data for a subjects by projecting to the shared + subspace and computing the individual information. Parameters ---------- diff --git a/brainiak/funcalign/srm.py b/brainiak/funcalign/srm.py index f786aa8c..bd55fd8f 100644 --- a/brainiak/funcalign/srm.py +++ b/brainiak/funcalign/srm.py @@ -51,7 +51,8 @@ def _init_w_transforms(data, features, random_states, comm=MPI.COMM_SELF): - """Initialize the mappings (Wi) for the SRM with random orthogonal matrices. + """Initialize the mappings (Wi) for the SRM with random orthogonal + matrices. Parameters ---------- @@ -480,7 +481,8 @@ def save(self, file): ) def _srm(self, data): - """Expectation-Maximization algorithm for fitting the probabilistic SRM. + """Expectation-Maximization algorithm for fitting the probabilistic + SRM. Parameters ---------- @@ -854,7 +856,8 @@ def transform_subject(self, X): return w def _srm(self, data): - """Expectation-Maximization algorithm for fitting the probabilistic SRM. + """Expectation-Maximization algorithm for fitting the probabilistic + SRM. Parameters ---------- diff --git a/brainiak/reprsimil/brsa.py b/brainiak/reprsimil/brsa.py index 6bf405c9..8a4404d7 100755 --- a/brainiak/reprsimil/brsa.py +++ b/brainiak/reprsimil/brsa.py @@ -4080,13 +4080,13 @@ def _check_scan_onsets_GBRSA(self, scan_onsets, X): return scan_onsets def _bin_exp(self, n_bin, scale=1.0): - """ Calculate the bin locations to approximate exponential distribution. - It breaks the cumulative probability of exponential distribution - into n_bin equal bins, each covering 1 / n_bin probability. Then it - calculates the center of mass in each bins and returns the - centers of mass. So, it approximates the exponential distribution - with n_bin of Delta function weighted by 1 / n_bin, at the - locations of these centers of mass. + """ Calculate the bin locations to approximate exponential + distribution. It breaks the cumulative probability of + exponential distribution into n_bin equal bins, each covering + 1 / n_bin probability. Then it calculates the center of mass in + each bins and returns the centers of mass. So, it approximates the + exponential distribution with n_bin of Delta function weighted by + 1 / n_bin, at the locations of these centers of mass. Parameters: ----------- n_bin: int diff --git a/brainiak/searchlight/searchlight.py b/brainiak/searchlight/searchlight.py index 55e40bf9..6bbc794e 100644 --- a/brainiak/searchlight/searchlight.py +++ b/brainiak/searchlight/searchlight.py @@ -94,7 +94,7 @@ def __init__(self, rad): for r1 in range(2*self.rad+1): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): - if(cityblock((r1, r2, r3), + if (cityblock((r1, r2, r3), (self.rad, self.rad, self.rad)) <= self.rad): self.mask_[r1, r2, r3] = True @@ -120,7 +120,7 @@ def __init__(self, rad): for r1 in range(2*self.rad+1): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): - if(euclidean((r1, r2, r3), + if (euclidean((r1, r2, r3), (self.rad, self.rad, self.rad)) <= self.rad): self.mask_[r1, r2, r3] = True From d62342283d52415aa0ee91198ab52c76913f1828 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 13:39:47 -0400 Subject: [PATCH 35/96] More code style fixes --- brainiak/searchlight/searchlight.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/brainiak/searchlight/searchlight.py b/brainiak/searchlight/searchlight.py index 6bbc794e..4504c80a 100644 --- a/brainiak/searchlight/searchlight.py +++ b/brainiak/searchlight/searchlight.py @@ -95,7 +95,7 @@ def __init__(self, rad): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): if (cityblock((r1, r2, r3), - (self.rad, self.rad, self.rad)) <= self.rad): + (self.rad, self.rad, self.rad)) <= self.rad): self.mask_[r1, r2, r3] = True @@ -121,7 +121,7 @@ def __init__(self, rad): for r2 in range(2*self.rad+1): for r3 in range(2*self.rad+1): if (euclidean((r1, r2, r3), - (self.rad, self.rad, self.rad)) <= self.rad): + (self.rad, self.rad, self.rad)) <= self.rad): self.mask_[r1, r2, r3] = True From 5cbcd642432b443f94e22371748290890fab46c5 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 13:49:35 -0400 Subject: [PATCH 36/96] More codestyle fixes. Also added and ignore for T201 (print statememts) on tests since this is not production code. --- tests/.flake8 | 1 + tests/reprsimil/test_gbrsa.py | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/tests/.flake8 b/tests/.flake8 index b90c8c63..19a46166 100644 --- a/tests/.flake8 +++ b/tests/.flake8 @@ -4,5 +4,6 @@ extend-ignore = # Print restriction only applies to libraries T001, T003, + T201, # Docstrings D, diff --git a/tests/reprsimil/test_gbrsa.py b/tests/reprsimil/test_gbrsa.py index 725f876e..66985b42 100644 --- a/tests/reprsimil/test_gbrsa.py +++ b/tests/reprsimil/test_gbrsa.py @@ -585,8 +585,8 @@ def setup_for_test(): LL_total_scipy = np.sum(np.log(scipy_sum) + max_value) tol = 1e-3 - assert(np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ - 'Error of log likelihood calculation exceeds the tolerance' + assert (np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ + 'Error of log likelihood calculation exceeds the tolerance' # Now test the log normal prior s = brainiak.reprsimil.brsa.GBRSA(n_iter=1, auto_nuisance=False, @@ -626,5 +626,5 @@ def setup_for_test(): LL_total_scipy = np.sum(np.log(scipy_sum) + max_value) tol = 1e-3 - assert(np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ - 'Error of log likelihood calculation exceeds the tolerance' + assert (np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ + 'Error of log likelihood calculation exceeds the tolerance' From 85cec102ce6232be451fda1a4a1550bda0b4ab38 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 13:51:24 -0400 Subject: [PATCH 37/96] More code style fixes in tests --- tests/funcalign/test_srm.py | 2 +- tests/funcalign/test_srm_distributed.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/funcalign/test_srm.py b/tests/funcalign/test_srm.py index b109a77b..8cf4a6fc 100644 --- a/tests/funcalign/test_srm.py +++ b/tests/funcalign/test_srm.py @@ -65,7 +65,7 @@ def test_can_instantiate(tmp_path): s.fit(X) from pathlib import Path sr_v0_4 = np.load(Path(__file__).parent / "sr_v0_4.npz")['sr'] - assert(np.allclose(sr_v0_4, s.s_)) + assert (np.allclose(sr_v0_4, s.s_)) assert len(s.w_) == subjects, ( "Invalid computation of SRM! (wrong # subjects in W)") diff --git a/tests/funcalign/test_srm_distributed.py b/tests/funcalign/test_srm_distributed.py index b4166267..7a5b6905 100644 --- a/tests/funcalign/test_srm_distributed.py +++ b/tests/funcalign/test_srm_distributed.py @@ -86,7 +86,7 @@ def test_distributed_srm(): # noqa: C901 s.fit(X) from pathlib import Path sr_v0_4 = np.load(Path(__file__).parent / "sr_v0_4.npz")['sr'] - assert(np.allclose(sr_v0_4, s.s_)) + assert (np.allclose(sr_v0_4, s.s_)) assert len(s.w_) == subjects, ( "Invalid computation of SRM! (wrong # subjects in W)") From 41f9a2c5b3cfca5623098d94381c43184873439f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 13:59:06 -0400 Subject: [PATCH 38/96] More style fixes in tests --- tests/reprsimil/test_gbrsa.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/reprsimil/test_gbrsa.py b/tests/reprsimil/test_gbrsa.py index 66985b42..8eb98994 100644 --- a/tests/reprsimil/test_gbrsa.py +++ b/tests/reprsimil/test_gbrsa.py @@ -586,7 +586,7 @@ def setup_for_test(): tol = 1e-3 assert (np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ - 'Error of log likelihood calculation exceeds the tolerance' + 'Error of log likelihood calculation exceeds the tolerance' # Now test the log normal prior s = brainiak.reprsimil.brsa.GBRSA(n_iter=1, auto_nuisance=False, @@ -627,4 +627,4 @@ def setup_for_test(): tol = 1e-3 assert (np.isclose(LL_total_scipy, LL_total, rtol=tol)), \ - 'Error of log likelihood calculation exceeds the tolerance' + 'Error of log likelihood calculation exceeds the tolerance' From 6d734dc85cd4bc5ffa64c9e0f21958588296656b Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 14:11:55 -0400 Subject: [PATCH 39/96] Fix exclusion of pymanopt in conda build --- .conda/meta.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index 6c8fe2bb..e56dc0d6 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -1,5 +1,5 @@ {% set conda_package_nonexistent = ( - "pymanopt", + "pymanopt<=0.2.5", ) %} {% set data = load_setup_py_data() %} From 372fff0fd1c884aba5bdba3bb9e596d9c4fc79ae Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 14:13:28 -0400 Subject: [PATCH 40/96] Specify engilish language for docs --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index d546e8e1..8548bd77 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -73,7 +73,7 @@ # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. -language = None +language = "en" # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: From d3be6e4e9f443ac8a503c139bbf8f6a14bfeb818 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 8 Aug 2022 14:29:25 -0400 Subject: [PATCH 41/96] Change 'jupyter_execute_notebooks' to 'nb_execution_mode'. --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 8548bd77..62b622bb 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -296,4 +296,4 @@ # Myst-nb execution_timeout = -1 -jupyter_execute_notebooks = "off" +nb_execution_mode = "off" From fe8755e164cc9123263af377c65f56fc8c74e420 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mihai=20Capot=C4=83?= Date: Mon, 8 Aug 2022 16:42:30 -0700 Subject: [PATCH 42/96] Fix Myst-NB config deprecation --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 8548bd77..62b622bb 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -296,4 +296,4 @@ # Myst-nb execution_timeout = -1 -jupyter_execute_notebooks = "off" +nb_execution_mode = "off" From 230d61ee1b104af1a3219bb9fa9366f1477b8ff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mihai=20Capot=C4=83?= Date: Mon, 8 Aug 2022 17:23:53 -0700 Subject: [PATCH 43/96] Another Myst-NB config deprecation fix --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 62b622bb..5a95e2a2 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -295,5 +295,5 @@ napoleon_include_special_with_doc = True # Myst-nb -execution_timeout = -1 +nb_execution_timeout = -1 nb_execution_mode = "off" From 7c20622a80b956f0b0b817b6c1fe0d9146eb1c63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mihai=20Capot=C4=83?= Date: Tue, 9 Aug 2022 09:28:51 -0700 Subject: [PATCH 44/96] Suppress Myst-NB Holoviews warning --- docs/conf.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/conf.py b/docs/conf.py index 5a95e2a2..6928926a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -58,6 +58,8 @@ master_doc = 'index' suppress_warnings = ["myst.header"] +# Suppress HTFA Holoviews content +suppress_warnings = ["mystnb.unknown_mime_type"] # General information about the project. project = 'brainiak' From 02ff296b015638221d5da4998d7dd7a21cc52cd0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mihai=20Capot=C4=83?= Date: Tue, 9 Aug 2022 17:32:09 -0700 Subject: [PATCH 45/96] Fix Myst warnings --- docs/conf.py | 1 + docs/examples/brsa/brsa_demo.ipynb | 34 +++--- .../eventseg/Event_Segmentation.ipynb | 20 ++-- docs/examples/fcma/FCMA_demo.ipynb | 46 ++++---- .../fmrisim_multivariate_example.ipynb | 102 +++++++++--------- docs/examples/htfa/htfa.ipynb | 20 ++-- docs/examples/isc/ISC.ipynb | 20 ++-- .../Matrix-normal model prototyping.ipynb | 15 +-- .../examples/real-time/README_INSTRUCTIONS.md | 8 +- .../examples/real-time/rtcloud_notebook.ipynb | 12 +-- docs/examples/srm/SRM.ipynb | 18 ++-- 11 files changed, 146 insertions(+), 150 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 6928926a..c6836a46 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -297,5 +297,6 @@ napoleon_include_special_with_doc = True # Myst-nb +myst_heading_anchors = 7 nb_execution_timeout = -1 nb_execution_mode = "off" diff --git a/docs/examples/brsa/brsa_demo.ipynb b/docs/examples/brsa/brsa_demo.ipynb index 4f076fba..987672f0 100644 --- a/docs/examples/brsa/brsa_demo.ipynb +++ b/docs/examples/brsa/brsa_demo.ipynb @@ -27,26 +27,26 @@ "2. Cai, M. B., Schuck, N. W., Pillow, J. W., & Niv, Y. (2019). Representational structure or task structure? Bias in neural representational similarity analysis and a Bayesian method for reducing bias. *PLoS Computational Biology*, 15(5), e1006299. [link](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006299&rev=2) *This paper improves the earlier version of BRSA by additionally modeling the spatial noise correlation and marginalizing voxel-wise noise parameters. The paper also introduces group BRSA and the use of cross-validation to compare an estimated model against a null model, and further extends BRSA to task-signal decoding, using the estimated similarity structure as an empirical prior for estimating neural patterns.*\n", "\n", "## Table of contents\n", - "* [Simulate data](#simulate)\n", - "* [Fit Group Bayesian RSA to simulated data](#fit)\n", - "* [Evaluation](#evaluation)\n", - "* [Other usage: \"decoding\" task-related signal from new data](#decoding)\n", - "* [Model selection by cross-validataion](#cross-validation)\n", - "* [Avoid false discovery](#avoiding)\n", - "* [Summary](#summary)" + "* [](#simulate-data)\n", + "* [](#fit-group-bayesian-rsa-to-simulated-data)\n", + "* [](#evaluation)\n", + "* [](#other-usage-decoding-task-related-signal-from-new-data)\n", + "* [](#model-selection-by-cross-validation)\n", + "* [](#avoid-false-discovery)\n", + "* [](#summary)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "##### Notes on data preparation\n", + "### Notes on data preparation\n", "When you apply this tool to real fMRI data, it is required that the data of each participant to be motion corrected. If multiple runs are acquired for each participant, they should be spatially aligned. Slice-timing correction is recommended. \n", "\n", "\n", "You will need to have the mask of the Region of Interest (ROI) ready (typically defined anatomically or by independent tasks). nilearn provides tools to extract signal from mask. You can refer to this [tutorial](http://nilearn.github.io/manipulating_images/manipulating_images.html)\n", "\n", - "##### Notes on model assumption\n", + "### Notes on model assumption\n", "Please note that the model assumes that the covariance matrix U which all $\\beta_i$ follow describe a multi-variate Gaussian distribution that is zero-meaned. This assumption does not imply that there must be both positive and negative responses across voxels.\n", "However, it means that (Group) Bayesian RSA treats the task-evoked activity against baseline BOLD level as signal, while in other RSA tools the deviation of task-evoked activity in each voxel from the average task-evoked activity level across voxels may be considered as signal of interest.\n", "Due to this assumption in (G)BRSA, relatively high degree of similarity may be expected when the activity patterns of two task conditions share a strong sensory driven components. When two task conditions elicit exactly the same activity pattern but only differ in their global magnitudes, under the assumption in (G)BRSA, their similarity is 1. However, if one take the assumption that only deviation of pattern from average patterns is signal of interest (which is currently not supported by (G)BRSA), their similarity would be -1 because the deviations of the two patterns from their average pattern are exactly opposite." @@ -56,7 +56,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Load some package which we will use in this demo.\n", + "### Load some package which we will use in this demo.\n", "If you see error related to loading any package, you can install that package. For example, if you use Anaconda, you can use \"conda install matplotlib\" to install matplotlib." ] }, @@ -100,7 +100,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Simulate data \n", + "## Simulate data\n", "We want to simulate some data in which each voxel responds to different task conditions differently, but following a common covariance structure.\n", "\n", "This example simulate 5 subjects. If you find the whole notebook runs for too long on your computer, you can reduce the number of simulated subjects by changing `n_subj` below." @@ -561,7 +561,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Fit Group Bayesian RSA to simulated data \n", + "## Fit Group Bayesian RSA to simulated data\n", "\n", "\n", "In BRSA and GBRSA, the nuisance regressors in typical fMRI analysis (such as head motion signal) are replaced by principal components estimated from residuals after subtracting mean posterior estimation of task-related response. `n_nureg` tells the model how many principal components to keep from the residual as nuisance regressors, in order to account for spatial correlation in noise. When it is set to None and `auto_nuisance=True`, this number will be estimated automatically by an algorithm of [Gavish & Dohono 2014](https://ieeexplore.ieee.org/document/6846297). If you prefer not using this approach based on principal components of residuals, you can set `auto_nuisance=False`, and optionally provide your own nuisance regressors as a list (one numpy array per subject) as nuisance argument to `GBRSA.fit()`. In practice, we find that the result is much better with `auto_nuisance=True`.\n", @@ -652,7 +652,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Evaluation \n", + "## Evaluation\n", "\n", "### Result of GBRSA\n", "We can have a look at the estimated similarity in matrix `gbrsa.C_`. \n", @@ -1073,7 +1073,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Other usage: \"decoding\" task-related signal from new data \n", + "## Other usage: \"decoding\" task-related signal from new data\n", "\n", "Now we generate a new data set.\n", "We keep the signal the same as in training data, but generate new noise.\n", @@ -1186,7 +1186,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Model selection by cross-validataion \n", + "## Model selection by cross-validation\n", "\n", "Both BRSA and GBRSA can compare full model against a null model (without task-related responses) by cross-validating the parameters of one model learnt from some training data on some testing data. GBRSA provides a `score()` function, which returns a pair of cross-validated log likelihood for the testing data. \n", "\n", @@ -1273,7 +1273,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Avoid false discovery \n", + "## Avoid false discovery\n", "\n", "If a model is fit to pure noise, some result of similarity structure can still be returned. How do we know if the result is valid?\n", "\n", @@ -1370,7 +1370,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Summary \n", + "## Summary\n", "\n", "(Group) Bayesian RSA models the covariance structure of the task-related activation patterns, and how the activation patterns and task-unrelated fluctuations together contribute to the temporal correlation in the fMRI data. By simulating fMRI data containing both task-related activation and spatio-temporally correlated noise, we show that (Group) Bayesian RSA recovers the similarity structure of activation patterns better than traditional RSA and suffers less from spurious correlation structure. GBRSA can additionally be used to decode task-related signals from new data. GBRSA also provides the ability to cross-validate the full model containing task-related signals against a null model assuming only spatiotemporally correlated noise, to prevent false discoveries." ] diff --git a/docs/examples/eventseg/Event_Segmentation.ipynb b/docs/examples/eventseg/Event_Segmentation.ipynb index d4b0cbc6..0e7c0038 100644 --- a/docs/examples/eventseg/Event_Segmentation.ipynb +++ b/docs/examples/eventseg/Event_Segmentation.ipynb @@ -23,11 +23,11 @@ "5. Antony, J. W., Hartshorne, T. H., Pomeroy, K., Gureckis, T. M., Hasson, U., McDougle, S. D., & Norman, K. A. (2020). Behavioral, physiological, and neural signatures of surprise during naturalistic sports viewing. *Neuron*. [`link`](https://doi.org/10.1016/j.neuron.2020.10.029) *Uses the event segmentation model to relate the number and timing of event boundaries in neural signals to the degree of surprise elicited in basketball games.*\n", "\n", "## Table of Contents\n", - "* [Loading data](#data)\n", - "* [Finding event boundaries during perception](#perception)\n", - "* [Comparing model and human-labeled boundaries](#comparing)\n", - "* [Aligning movie and recall data](#aligning)\n", - "* [Summary](#summary)" + "* [](#loading-data)\n", + "* [](#finding-event-boundaries-during-perception)\n", + "* [](#comparing-model-and-human-labeled-boundaries)\n", + "* [](#aligning-movie-and-recall-data)\n", + "* [](#summary)" ] }, { @@ -63,7 +63,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Loading data\n", + "## Loading data\n", "This tutorial will use data from the first run of the Sherlock dataset [(Chen et al. 2017)](https://doi.org/10.1038/nn.4450), masked to only include the Angular Gyrus." ] }, @@ -126,7 +126,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Finding event boundaries during perception" + "## Finding event boundaries during perception" ] }, { @@ -497,7 +497,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Comparing model and human-labeled boundaries\n", + "## Comparing model and human-labeled boundaries\n", "\n", "We can also quantitatively compare the event boundaries between different models, or between a model and human-labeled event boundaries. Because there is some ambiguity in both the stimulus and the model about exactly which timepoint the transition occurs at, we will count two boundaries as being a \"match\" if they are within 3 TRs (4.5 seconds) of each other.\n", "\n", @@ -563,7 +563,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Aligning movie and recall data\n", + "## Aligning movie and recall data\n", "\n", "A simple model of free recall is that a subject will revisit the same sequence of events experienced during perception, but the lengths of the events will not be identical between perception and recall. We use the same fit function as for a single dataset, but now we pass in both the movie and recall datasets in a list. We assume the two datasets have shared event transitions." ] @@ -608,7 +608,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Summary\n", + "## Summary\n", "Using the HMM, we first captured neural states corresponding with the naturalistic segmentation of events. Then, to verify that these states aligned with subjective event perception, we aligned their boundaries with event boundary annotations from an independent group of subjects. Finally, we showed that processes such as free recall, which feature similar transition structures but may be compressed or expanded in time, can be aligned to this perceptual HMM \"template\", broadening the scope of future research questions that can be addressed with this technique." ] }, diff --git a/docs/examples/fcma/FCMA_demo.ipynb b/docs/examples/fcma/FCMA_demo.ipynb index d929bff6..728a5ba1 100644 --- a/docs/examples/fcma/FCMA_demo.ipynb +++ b/docs/examples/fcma/FCMA_demo.ipynb @@ -21,7 +21,7 @@ " 2. If so, which brain regions are driving the difference?\n", "\n", "\n", - "- This jupyter notebook uses simulated data to demonstrate how the above two questions could be answered with FCMA. Look here to see [the important details of simulated data](#dat)\n", + "- This jupyter notebook uses simulated data to demonstrate how the above two questions could be answered with FCMA. Look here to see [](#important-details-of-simulated-data)\n", "\n", "\n", "- Brainiak also includes a tutorial for FCMA, which could be found [here](https://brainiak.org/notebooks/tutorials/html/09-fcma.html).\n", @@ -39,34 +39,34 @@ "source": [ "## Table of Contents\n", "\n", - "[1. FCMA Step1: Feature (voxel) selection](#fcma_voxselect)\n", - ">[1.1 The goal](#goal) \n", - ">[1.2 Data preprocessing](#preprocess) \n", - ">[1.3 Understanding preprocessed data](#understand_preprocess) \n", - ">[1.4 Feature selection with simplified implementation](#simplified_fs) \n", - ">[1.5 Understading the outputs of feature selection](#understand_simplified_fs) \n", - ">[1.6 Perform feature selection with actual FCMA implementation](#actual_fs) \n", - ">[1.7 Select n top performed features](#select_top_n) \n", + "[](#1-fcma-step-1-feature-voxel-selection)\n", + ">[](#11-the-goal)\n", + ">[](#12-data-preprocessing)\n", + ">[](#13-understanding-preprocessed-data)\n", + ">[](#14-feature-selection-with-simplified-implementation)\n", + ">[](#15-understanding-the-outputs-of-feature-selection)\n", + ">[](#16-perform-feature-selection-with-actual-fcma-implementation)\n", + ">[](#17-select-n-top-performing-features)\n", "\n", - "[2. FCMA Step 2: Classification using the selected features (voxels)](#classification)\n", - ">[2.1 The goal](#goal2) \n", - ">[2.2 Classification steps](#clf_steps) \n", - ">[2.3 Understanding the outputs of classification](#understand_clf) \n", - ">[2.4 Perform classification for all outer loop folds using FCMA script](#actual_clf) \n", + "[](#2-fcma-step-2-classification-using-the-selected-features-voxels)\n", + ">[](#21-the-goal)\n", + ">[](#22-classification-steps)\n", + ">[](#23-understanding-the-outputs-of-classification)\n", + ">[](#24-perform-classification-for-all-outer-loop-folds-using-fcma-script)\n", "\n", - "[3. Results visualizations](#visualization)\n", - ">[3.1 Examine classification accuracy for different top-n-mask](#line) \n", - ">[3.2 Visualize voxels in top-n-masks](#niview) \n", - ">[3.3 Visualize functional connectivity pattern with circos plot](#circos) \n", + "[](#3-results-visualizations)\n", + ">[](#31-examine-classification-accuracy-for-different-top-n-mask)\n", + ">[](#32-visualize-voxels-in-top-n-masks](#niview)\n", + ">[](#33-visualize-functional-connectivity-pattern-with-circos-plot)\n", "\n", - "[4. Summary](#sum)\n" + "[](#4-summary)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Important details of simulated data \n", + "### Important details of simulated data\n", "\n", "- The simulated data consists of 8 subjects. The experiment consists of a **block design** and two conditions (A and B). **Each condition has 10 blocks (or epochs) for a total of 20 epochs** for each subject. The order of the epochs were randomized across the 8 subjects. Each **epoch lasts for 15 time points** followed by **5 time points of inter-block interval**. The total experiment lasts 400 time points in total. Here, time points are arbitrary and are meant to correspond to single TRs in an actual study. \n", "\n", @@ -106,7 +106,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. FCMA Step1: Feature (voxel) selection \n", + "## 1. FCMA Step 1: Feature (voxel) selection \n", "### 1.1 The goal \n", "- Given the default specification of \"left_out_subj\", we can devide the 8-subjects data into a training set (7 subjects) and a testing set (1 subject). This is referred to as the \"outer loop leave-one-out cross validation\". The goal here is to perform feature selection on the traning set and use the selected features (7 subjects) to build a model and test using the left out test set (1 subject). This will ultimately be done 8 times to provide a complete assessment of all 8 subjects. \n", "\n", @@ -432,12 +432,12 @@ "source": [ "## 2. FCMA Step 2: Classification using the selected features (voxels) \n", "\n", - "#### 2.1 The goal \n", + "### 2.1 The goal \n", "- We have selected top N features (voxels) from the original brain mask. Now we can ask if we only consider the connectivity pattern within these selected voxels, how well can a classifier do in terms of differentiating two conditions? The rationale is that if a classifier trained on the FC pattern of the selected features is enough to differentiate the two task conditions, then we could say that the selected voxels are the brain regions among which the FC changes characterize certain task differences. \n", "\n", "- For the demo, we will still focus on Subject-0. During the feature selection step, we have selected top N features (voxels) using the traning set (the data of the rest 7 subjects). Now we are going to use these features to build a predictive model and use subject-0 as a testing data to finish the first fold of our outer loop cross validation. \n", "\n", - "#### 2.2 Classification steps \n", + "### 2.2 Classification steps \n", "\n", "1. Preprocess all 8 subjects' data as we have discussed above, yielding a list of labels of the length equals 20 (epochs/subject) * 8 (subjects) = 160, and a list of epoch data of the same length. Within each epoch (i.e., each entry in the variable \"int_data\" in the code below), there is a 2d array of [timepoint, nVoxel]. Note that nVoxel depends on the size of the top n masks we are using.\n", "\n", diff --git a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb index 53201e60..3c7a10c5 100644 --- a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb +++ b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb @@ -31,46 +31,46 @@ "\n", "\n", "## Table of Contents\n", - "[1. Set parameters](#set_parameters) \n", - "- [1.1 Import necessary Python packages](#import_packages) \n", - "- [1.2 Load participant data](#load_ppt) \n", - "- [1.3 Specify participant dimensions and resolution](#specify_dim) \n", - "- [1.4 Generate an activity template and a mask](#generate_template) \n", - "- [1.5 Determine noise parameters](#noise_parameters) \n", + "[](#1-set-parameters)\n", + "- [](#11-import-necessary-python-packages)\n", + "- [](#12-load-participant-data) \n", + "- [](#13-specify-participant-dimensions-and-resolution) \n", + "- [](#14-generate-an-activity-template-and-a-mask) \n", + "- [](#15-determine-noise-parameters) \n", "\n", - "[2. Generate noise](#generate_noise) \n", - "- [2.1 Create temporal noise](#temporal_noise) \n", - "- [2.2 Create system noise](#system_noise) \n", - "- [2.3 Combine noise and template](#template_noise) \n", - "- [2.4 Fit the data to the noise parameters](#fit_noise) \n", + "[2-generate-noise) \n", + "- [](#21-create-temporal-noise) \n", + "- [](#22-create-system-noise) \n", + "- [](#23-combine-noise-and-template) \n", + "- [](#24-fit-the-data-to-the-noise-parameters) \n", "\n", - "[3. Generate signal](#generate_signal) \n", - "- [3.1 Specify which voxels in the brain contain signal](#specify_signal) \n", - "- [3.2 Characterize signal for voxels](#characterize_signal) \n", - "- [3.3 Generate event time course](#generate_time_course) \n", - "- [3.4 Export stimulus time course for analysis](#export_time_course) \n", - "- [3.5 Estimate the voxel weight for each event](#weight_signal) \n", - "- [3.6 Convolve each voxel\u2019s time course with the Hemodynamic Response Function](#convolve_HRF) \n", - "- [3.7 Establish signal magnitude](#compute_signal) \n", - "- [3.8 Multiply the convolved response with the signal voxels](#multiply_signal) \n", - "- [3.9 Combine signal and noise](#combine_signal) \n", + "[3-generate-signal) \n", + "- [](#31-specify-which-voxels-in-the-brain-contain-signal) \n", + "- [](#32-characterize-signal-for-voxels) \n", + "- [](#33-generate-event-time-course) \n", + "- [](#34-export-stimulus-time-course-for-analysis) \n", + "- [](#35-estimate-the-voxel-weight-for-each-event) \n", + "- [](#36-convolve-each-voxels-time-course-with-the-hemodynamic-response-function) \n", + "- [](#37-establish-signal-magnitude) \n", + "- [](#38-multiply-the-convolved-response-with-the-signal-voxels) \n", + "- [](#39-combine-signal-and-noise) \n", "\n", - "[4. Analyse data](#analyse_data) \n", - "- [4.1 Pull out data for each trial](#pull_data) \n", - "- [4.2 Represent the data](#represent_data) \n", - "- [4.3 Test for univariate effect](#test_univariate) \n", - "- [4.4 Test for a multivariate effect](#test_multivariate) \n", + "[4-analyse-data) \n", + "- [](#41-pull-out-data-for-each-trial) \n", + "- [](#42-represent-the-data) \n", + "- [](#43-test-for-univariate-effect) \n", + "- [](#44-test-for-a-multivariate-effect) \n", "\n", - "[Summary](#summary)\n", + "[](#summary)\n", "\n", - "[References](#references)" + "[](#references)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### **1.\tSet parameters.** \n", + "### 1. Set parameters\n", "\n", "It is necessary to set various parameters that describe how the signal and the noise will be generated." ] @@ -79,7 +79,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*1.1 Import necessary Python packages* " + "#### 1.1 Import necessary Python packages\n" ] }, { @@ -109,7 +109,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*1.2 Load participant data*\n", + "#### 1.2 Load participant data*\n", "\n", "Any 4 dimensional fMRI data that is readible by nibabel can be used as input to this pipeline. For this example, data is taken from the open access repository DataSpace: http://arks.princeton.edu/ark:/88435/dsp01dn39x4181. This file is unzipped and placed same directory as this notebook with the name Corr_MVPA " ] @@ -130,7 +130,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*1.3\tSpecify participant dimensions and resolution*\n", + "#### 1.3 Specify participant dimensions and resolution\n", "\n", "The size of the volume and the resolution of the voxels must be specified (or extracted from the real data as is the case below)." ] @@ -163,7 +163,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*1.4 Generate an activity template and a mask*\n", + "#### 1.4 Generate an activity template and a mask\n", "\n", "Functions in fmrisim require a continuous map that describes the appropriate average MR value for each voxel in the brain and a mask which specifies voxels in the brain versus voxels outside of the brain. One way to generate both of these volumes is the mask_brain function. At a minimum, this takes as an input the fMRI volume to be simulated. To create the template this volume is averaged over time and bounded to a range from 0 to 1. In other words, voxels with a high value in the template have high activity over time. To create a mask, the template is thresholded. This threshold can be set manually or instead an appropriate value can be determined by looking for the minima between the two first peaks in the histogram of voxel values. If you would prefer, you could use the [compute_epi_mask](http://nilearn.github.io/modules/generated/nilearn.masking.compute_epi_mask.html) function in nilearn which uses a similar method." ] @@ -185,7 +185,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*1.5 Determine noise parameters*\n", + "#### 1.5 Determine noise parameters\n", "\n", "A critical step in the fmrisim toolbox is determining the noise parameters of the volume to be created. Many noise parameters are available for specification and if any are not set then they will default to reasonable values. As mentioned before, it is instead possible to provide raw fMRI data that will be used to estimate these noise parameters. The goal of the noise estimation is to calculate general descriptive statistics about the noise in the brain that are thought to be important. The simulations are then useful for understanding how signals will survive analyses when embedded in realistic neural noise. \n", "\n", @@ -1083,7 +1083,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*2.1 Create temporal noise*\n", + "#### 2.1 Create temporal noise\n", "\n", "The temporal noise of fMRI data is comprised of multiple components: drift, autoregression, task related motion and physiological noise. To estimate drift, cosine basis functions are combined, with longer runs being comprised of more basis functions (Welvaert, et al., 2011). This drift is then multiplied by a three-dimensional volume of Gaussian random fields of a specific FWHM. Autoregression noise is estimated by initializing with a brain shaped volume of gaussian random fields and then multiplying then creating an ARMA time course by adding additional volumes of noise. Physiological noise is modeled by sine waves comprised of heart rate (1.17Hz) and respiration rate (0.2Hz) (Biswal, et al., 1996) with random phase. This time course is also multiplied by brain shaped spatial noise. Finally, task related noise is simulated by adding Gaussian or Rician noise to time points where there are events (according to the event time course) and in turn this is multiplied by a brain shaped spatial noise volume. These four noise components are then mixed together in proportion to the size of their corresponding sigma values. This aggregated volume is then Z scored and the SFNR is used to estimate the appropriate standard deviation of these values across time. " ] @@ -2782,7 +2782,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*2.2 Create system noise*\n", + "#### 2.2 Create system noise\n", " \n", "Machine/system noise causes fluctuations in all voxels in the acquisition. When SNR is low, Rician noise is a good estimate of background noise data (Gudbjartsson, & Patz, 1995). However if you look at the distribution of non-brain voxel values averaged across time (i.e., the template) then you see that this is also rician, suggesting that most of the rician noise is a result of the structure in the background of the brain (e.g. the baseline MR of the head coil or skull). If you subtract this baseline then the noise becomes approximately gaussian, especially in the regions far from the brain (which is what the `calc_noise` algorithm considers when calculating SNR). Hence the machine noise here is gaussian added to an inherently rician baseline.\n", "\n", @@ -3633,7 +3633,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*2.3 Combine noise and template*\n", + "#### 2.3 Combine noise and template\n", " \n", "The template volume is used to estimate the appropriate baseline distribution of MR values. This estimate is then combined with the temporal noise and the system noise to make an estimate of the noise. " ] @@ -3642,7 +3642,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*2.4 Fit the data to the noise parameters*\n", + "#### 2.4 Fit the data to the noise parameters\n", "\n", "The generate_noise function does its best to estimate the appropriate noise parameters using assumptions about noise sources; however, because of the complexity of these different noise types, it is often wrong. To compensate, fitting is performed in which parameters involved in the noise generation process are changed and the noise metrics are recalculated to see whether those changes helped the fit. Due to their importance, the parameters that can be fit are SNR, SFNR and AR.\n", "\n", @@ -3706,7 +3706,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.1 Specify which voxels in the brain contain signal*\n", + "#### 3.1 Specify which voxels in the brain contain signal\n", "\n", "fmrisim provides tools to specify certain voxels in the brain that contain signal. The generate_signal function can produce regions of activity in a brain of different shapes, such as cubes, loops and spheres. Alternatively a volume could be loaded in that specifies the signal voxels (e.g. for ROIs from nilearn). The value of each voxel can be specified here, or set to be a random value." ] @@ -4542,7 +4542,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.2 Characterize signal for voxels*\n", + "#### 3.2 Characterize signal for voxels\n", "\n", "Specify the pattern of activity across a given number of voxels that characterizes each condition. This pattern can simply be random, as is done here, or can be structured, like the position of voxels in high-dimensional representation space." ] @@ -5385,7 +5385,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.3 Generate event time course*\n", + "#### 3.3 Generate event time course\n", "\n", "generate_stimfunction can be used to specify the time points at which task stimulus events occur. The timing of events can be specified by describing the onset and duration of each event. Alternatively, it is possible to provide a path to a 3 column timing file, used by fMRI software packages like FSL, which specifies event onset, duration and weight. \n" ] @@ -5438,7 +5438,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.4 Export stimulus time course for analysis*\n", + "#### 3.4 Export stimulus time course for analysis\n", "\n", "If a time course of events is generated, as is the case here, it may be useful to store this in a certain format for future analyses. The `export_3_column` function can be used to export the time course to be a three column (event onset, duration and weight) timing file that might readable to FSL. Alternatively, the export_epoch_file function can be used to export numpy files that are necessary inputs for MVPA and FCMA in BrainIAK.\n" ] @@ -5472,7 +5472,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.5 Estimate the voxel weight for each event*\n", + "#### 3.5 Estimate the voxel weight for each event\n", "\n", "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel\u2019s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel\u2019s response to signal over time." ] @@ -6307,7 +6307,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.6 Convolve each voxel\u2019s time course with the Hemodynamic Response Function*\n", + "#### 3.6 Convolve each voxel's time course with the Hemodynamic Response Function\n", "\n", "With the time course of stimulus events it is necessary to estimate the brain\u2019s response to those events, which can be estimated by convolving it with using a Hemodynamic Response Function (HRF). By default, `convolve_hrf` assumes a double gamma HRF appropriately models a brain\u2019s response to events, as modeled by fMRI (Friston, et al., 1998). To do this convolution, each voxel\u2019s time course is convolved to make a function of the signal activity. Hence this produces an estimate of the voxel\u2019s activity, after considering the temporal blurring of the HRF. This can take a single vector of events or multiple time courses." ] @@ -7149,7 +7149,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.7 Establish signal magnitude*\n", + "#### 3.7 Establish signal magnitude\n", "\n", "When specifying the signal we must determine the amount of activity change each voxel undergoes. fmrisim contains a tool to allow you to choose between a variety of different metrics that you could use to scale the signal. For instance, we can calculate percent signal change (referred to as PSC) by taking the average activity of a voxel in the noise volume and multiplying the maximal activation of the signal by a percentage of this number. This metric doesn't take into account the variance in the noise but other metrics in this tool do. One metric that does take account of variance, and is used below, is the signal amplitude divided by the temporal variability. The choices that are available for computing the signal scale are based on Welvaert and Rosseel (2013)." ] @@ -7194,7 +7194,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.8 Multiply the convolved response with the signal voxels*\n", + "#### 3.8 Multiply the convolved response with the signal voxels\n", "\n", "If you have a time course of simulated response for one or more voxels and a three dimensional volume representing voxels that ought to respond to these events then apply_signal will combine these appropriately. This function multiplies each signal voxel in the brain by the convolved event time course. " ] @@ -7216,7 +7216,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*3.9 Combine signal and noise*\n", + "#### 3.9 Combine signal and noise\n", "\n", "Since the brain signal is expected to be small and sparse relative to the noise, it is assumed sufficient to simply add the volume containing signal with the volume modeling noise to make the simulated brain. " ] @@ -7245,7 +7245,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*4.1 Pull out data for each trial*\n", + "#### 4.1 Pull out data for each trial\n", "\n", "Identify which voxels are in the signal ROI by using the coordinates provided earlier. To identify the relevant timepoints, assume that the peak of the neural response occurs 4 - 6s after each event onset. Take the TR corresponding to this peak response as the TR for that trial. In longer event/block designs you might instead average over each event." ] @@ -8090,7 +8090,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*4.2 Represent the data*\n", + "#### 4.2 Represent the data\n", "\n", "Treat each voxel as a dimension and each trial as a point in this voxel space. It is then possible to display the different conditions and determine whether these are separable in this lower dimensionality (note that the conditions may be separable in higher dimensionality but unsupervised techniques like Multidimensional Scaling used below, might not show such a difference)" ] @@ -8914,7 +8914,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*4.3 Test for univariate effect*\n", + "#### 4.3 Test for univariate effect*\n", "\n", "Do a t test to compare the means of the voxels between these two conditions to determine if there is a difference" ] @@ -8944,7 +8944,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "*4.4 Test for a multivariate effect*\n", + "#### 4.4 Test for a multivariate effect\n", "\n", "Use SVM from scikit-learn to estimate the classification accuracy between the conditions" ] diff --git a/docs/examples/htfa/htfa.ipynb b/docs/examples/htfa/htfa.ipynb index c84c17bd..d5f0bfce 100644 --- a/docs/examples/htfa/htfa.ipynb +++ b/docs/examples/htfa/htfa.ipynb @@ -43,16 +43,16 @@ "metadata": {}, "source": [ "## Table of contents:\n", - "- [Overview](#Overview)\n", - "- [Getting started](#Getting-started)\n", - "- [Code](#Code)\n", - " - [Initialization](#Initialization)\n", - " - [Fit HTFA to data](#Fit-HTFA-to-data)\n", - " - [Plotting HTFA global and local node locations](#Plotting-HTFA-global-and-local-node-locations)\n", - " - [Compute dynamic correlations](#Compute-dynamic-correlations)\n", - " - [Generate animated chord diagrams](#Generate-animated-chord-diagrams)\n", - " - [Generate animated brain network plots](#Generate-animated-brain-network-plots)\n", - "- [Summary](#Summary)\n", + "- [](#overview)\n", + "- [](#getting-started)\n", + "- [](#code)\n", + " - [](#initialization)\n", + " - [](#fit-htfa-to-data)\n", + " - [](#plotting-htfa-global-and-local-node-locations)\n", + " - [](#compute-dynamic-correlations)\n", + " - [](#generate-animated-chord-diagrams)\n", + " - [](#generate-animated-brain-network-plots)\n", + "- [](#summary)\n", "\n" ] }, diff --git a/docs/examples/isc/ISC.ipynb b/docs/examples/isc/ISC.ipynb index dcf73da4..32a55bf0 100644 --- a/docs/examples/isc/ISC.ipynb +++ b/docs/examples/isc/ISC.ipynb @@ -15,7 +15,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Annotated bibliography\n", + "## Annotated bibliography\n", "1. Hasson, U., Nir, Y., Levy, I., Fuhrmann, G., & Malach, R. (2004). Intersubject synchronization of cortical activity during natural vision. *Science*, *303*(5664), 1634-1640. [`link`](https://doi.org/10.1126/science.1089506) *Original application of ISC analysis to naturalistic movie-watching fMRI data, demonstrating shared stimulus-evoked responses across subjects.*\n", "\n", "2. Nastase, S. A., Gazzola, V., Hasson, U., & Keysers, C. (2019). Measuring shared responses across subjects using intersubject correlation. *Social Cognitive and Affective Neuroscience*, *14*(6), 667-685. [`link`](https://doi.org/10.1093/scan/nsz037) *Recent tutorial article that reviews ISC analysis and related methods.*\n", @@ -29,13 +29,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Table of contents\n", - "- [Example fMRI data and atlas](#Example-fMRI-data-and-atlas)\n", - "- [Computing intersubject correlation (ISC)](#Computing-intersubject-correlation-(ISC))\n", - "- [Temporal receptive windows](#Temporal-receptive-windows)\n", - "- [Intersubject network estimation (ISFC)](#Intersubject-network-estimation-(ISFC))\n", - "- [Intersubject pattern correlation (ISPC)](#Intersubject-pattern-correlation-(ISPC))\n", - "- [Summary](#Summary)" + "## Table of contents\n", + "- [](#example-fmri-data-and-atlas)\n", + "- [](#computing-intersubject-correlation-isc)\n", + "- [](#temporal-receptive-windows)\n", + "- [](#intersubject-network-estimation-isfc)\n", + "- [](#intersubject-pattern-correlation-ispc)\n", + "- [](#summary)" ] }, { @@ -62,7 +62,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Example fMRI data and atlas\n", + "## Example fMRI data and atlas\n", "To explore ISC analysis, we use an fMRI dataset collected while participants listened to two versions of a spoken story called \"[It's Not the Fall that Gets You](https://themoth.org/stories/its-not-the-fall-that-gets-you)\" by Andy Christie. Participants either listened to the original version of the story (referred to as the *intact* condition) or a temporally scrambled version of the story (referred to as the *shortscram* condition). These data are available as part of the [Narratives](https://github.com/snastase/narratives) collection ([Nastase et al., 2019](https://openneuro.org/datasets/ds002345)) and were recently published in work by Chien and Honey ([2020](https://doi.org/10.1016/j.neuron.2020.02.013)). Here, we download a pre-packaged subset of the data from Zenodo. These data have been preprocessed using fMRIPrep and confound regression in AFNI. To reduce computational demands, we compute parcel-wise ISCs using a cortical parcellation containing 400 parcels from Schaefer and colleages ([2018](https://doi.org/10.1093/cercor/bhx179))." ] }, @@ -598,7 +598,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### References\n", + "### References\n", "* Baldassano, C., Chen, J., Zadbood, A., Pillow, J. W., Hasson, U., & Norman, K. A. (2017). Discovering event structure in continuous narrative perception and memory. *Neuron*, *95(3), 709-721. https://doi.org/10.1016/j.neuron.2017.06.041\n", "\n", "* Chen, G., Shin, Y. W., Taylor, P. A., Glen, D. R., Reynolds, R. C., Israel, R. B., & Cox, R. W. (2016). Untangling the relatedness among correlations, part I: nonparametric approaches to inter-subject correlation analysis at the group level. *NeuroImage*, *142*, 248-259. https://doi.org/10.1016/j.neuroimage.2016.05.023\n", diff --git a/docs/examples/matnormal/Matrix-normal model prototyping.ipynb b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb index a7267abf..19ce4263 100644 --- a/docs/examples/matnormal/Matrix-normal model prototyping.ipynb +++ b/docs/examples/matnormal/Matrix-normal model prototyping.ipynb @@ -26,18 +26,17 @@ "\n", "\n", "## Table of contents\n", - "- [Overview: understanding Kronecker-separability](#Overview)\n", - "- [Example 1: regression](#regression)\n", - "- [Example 2: marginalization and RSA](#MN-RSA)\n", - "- [Example 3: design matrices: PCA and FA](#latent-design)\n", - "- [Summary and future outlook](#Summary)" + "- [](#overview-understanding-kronecker-separability)\n", + "- [](#example-1-matrix-normal-separable-covariance-regression)\n", + "- [](#example-2-priors-and-marginalization-with-mn-rsa)\n", + "- [](#example-3-latent-design-matrices-with-pca-and-fa)\n", + "- [](#summary)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n", "## Overview: Understanding kronecker-separability\n", "\n", "Unlike many of the other tools in `brainiak`, the `brainiak.matnormal` package is only a little bit about specific methods and a lot about letting you try new ideas and method variants quickly. If the variants are useful, they can be sped up and made neater for broader consumption. To understand the idea behind matrix-normal or kronecker-separable models, consider the following figure: \n", @@ -51,7 +50,6 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n", "## Example 1: Matrix-normal (separable-covariance) regression\n", "To understand how simple it is to prototype new matrix-normal models, consider first simple linear regression: \n", "\n", @@ -409,7 +407,6 @@ "metadata": {}, "source": [ "## Example 2: Priors and marginalization, with MN-RSA\n", - "\n", "We have already introduced the idea of priors in the previous example, though in that case we were using them purely as regularization. But we can sometimes set priors in a way that lets us integrate over some nuisance parameter entirely. This marginalization is used, for example, in deriving BRSA from beta-series RSA (also available in `brainiak`). We notate the same marginalization in the matrix-normal setting next. If: \n", "\n", "$$\n", @@ -562,7 +559,6 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n", "## Example 3: latent design matrices with PCA and FA\n", "The true benefit of a shared framework comes when starting to see the commonalities among methods. For example, consider what happens if the known design matrix $X$ is replaced with an unknown latent time series $S$, yielding the following model: \n", "\n", @@ -1037,7 +1033,6 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n", "## Summary\n", "\n", "This demonstrates how `brainiak.matnormal` supports prototyping of models with kronecker-separable residuals. Again we highlight that while the specific model variants here can be implemented more efficiently, the shared and consistent framing provided by the matrix-normal framework can allow us to showcase the similarity across methods, as well as introduce a consistent idea (e.g. a particular residual structure) to different models in a consistent way. \n", diff --git a/docs/examples/real-time/README_INSTRUCTIONS.md b/docs/examples/real-time/README_INSTRUCTIONS.md index 82d39498..766c1b1e 100644 --- a/docs/examples/real-time/README_INSTRUCTIONS.md +++ b/docs/examples/real-time/README_INSTRUCTIONS.md @@ -1,8 +1,8 @@ -## Set Up Instructions for the Real-Time fMRI Cloud-Based Framework +# Set Up Instructions for the Real-Time fMRI Cloud-Based Framework Here are instructions you have to follow in order to implement our real-time fMRI cloud-based framework when running the [rtcloud_notebook jupyter notebook](https://github.com/brainiak/brainiak-aperture/blob/master/notebooks/real-time/rtcloud_notebook.ipynb). There are some things that you have to set up only once, whereas there are other things you have to do every time before you launch and run the jupyter notebook. -### Things to do once +## Things to do once Before you can run this notebook, you will have to take the following steps to set up our software framework: 1. Clone the [brainiak aperture repo](https://github.com/brainiak/brainiak-aperture.git) and the [rtcloud framework repo](https://github.com/brainiak/rt-cloud.git). The location of the repositories do not matter but you should make a note of the paths. @@ -16,7 +16,7 @@ Before you can run this notebook, you will have to take the following steps to s + `npm install` + `npm run build` -### Things to do every time +## Things to do every time Here are the things that you have to do every time before you launch and run this jupyter notebook: 1. Activate the conda environment for the rtcloud framework: @@ -25,7 +25,7 @@ Here are the things that you have to do every time before you launch and run thi + `export RTCLOUD_PATH=/PATH_TO_RTCLOUD/rt-cloud/` + Double check that you did this correctly by typing the following command, which should print the *full* path to the rtcloud framework folder: `ECHO $RTCLOUD_PATH` -### Common Issues +## Common Issues - If you get a blank blue screen when you open the localhost with the web server, then you forgot to follow Step 4 above. - The `/tmp/notebook-simdata` folder is in your root directory. To get there, do `cd /tmp`. You want to delete this `notebook-simdata` folder whenever you want to similate the synthetic data being produced in real-time. diff --git a/docs/examples/real-time/rtcloud_notebook.ipynb b/docs/examples/real-time/rtcloud_notebook.ipynb index 72bb1dc6..93b0f385 100644 --- a/docs/examples/real-time/rtcloud_notebook.ipynb +++ b/docs/examples/real-time/rtcloud_notebook.ipynb @@ -22,12 +22,12 @@ "\n", "## Table of Contents\n", "\n", - "* [Before Running This Notebook](#setting_up)\n", - "* [Import Necessary Modules and Declare Important Variables](#import_modules)\n", - "* [Step 1: Start the ProjectInterface Web Server](#start_ProjectInterface)\n", - "* [Step 2: Start the Synthetic Data Generator](#start_DataGenerator)\n", - "* [Step 3: Open the Web Server on the localhost](#open_localhost)\n", - "* [Summary](#summary)\n", + "* [](#before-running-this-notebook)\n", + "* [](#import-necessary-modules-and-declare-important-variables)\n", + "* [](#step-1-start-the-projectinterface-web-server)\n", + "* [](#step-2-start-the-synthetic-data-generator)\n", + "* [](#step-3-open-the-web-server-on-the-localhost)\n", + "* [](#summary)\n", "\n", "## Before Running This Notebook \n", "\n", diff --git a/docs/examples/srm/SRM.ipynb b/docs/examples/srm/SRM.ipynb index a1cb4c7d..0def4d3a 100644 --- a/docs/examples/srm/SRM.ipynb +++ b/docs/examples/srm/SRM.ipynb @@ -22,7 +22,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Annotated bibliography\n", + "## Annotated bibliography\n", "1. Chen, P. H. C., Chen, J., Yeshurun, Y., Hasson, U., Haxby, J., & Ramadge, P. J. (2015). A reduced-dimension fMRI shared response model. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, R. Garnett (Eds.), *Advances in Neural Information Processing Systems, vol. 28* (pp. 460-468). [`link`](https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model) *Introduces the SRM method of functional alignment with several performance benchmarks.*\n", "\n", "2. Haxby, J. V., Guntupalli, J. S., Nastase, S. A., & Feilong, M. (2020). Hyperalignment: modeling shared information encoded in idiosyncratic cortical topographies. *eLife*, *9*, e56601. [`link`](https://doi.org/10.7554/eLife.56601) *Recent review of hyperalignment and related functional alignment methods.*\n", @@ -36,11 +36,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Table of contents\n", - "- [Example fMRI data and atlas](#Example-fMRI-data-and-atlas)\n", - "- [Estimating the SRM](#Estimating-the-SRM)\n", - "- [Between-subject time-segment classification](#Between-subject-time-segment-classification)\n", - "- [Summary](#Summary)" + "## Table of contents\n", + "- [](#example-fmri-data-and-atlas)\n", + "- [](#estimating-the-srm)\n", + "- [](#between-subject-time-segment-classification)\n", + "- [](#summary)" ] }, { @@ -65,7 +65,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Example fMRI data and atlas\n", + "## Example fMRI data and atlas\n", "To work through the SRM functionality, we use an fMRI dataset collected while participants listened to a spoken story called \"[I Knew You Were Black](https://themoth.org/stories/i-knew-you-were-black)\" by Carol Daniel. These data are available as part of the publicly available [Narratives](https://github.com/snastase/narratives) collection ([Nastase et al., 2019](https://openneuro.org/datasets/ds002345)). Here, we download a pre-packaged subset of the data from Zenodo. These data have been preprocessed using fMRIPrep with confound regression in AFNI. We apply the SRM to a region of interest (ROI) comprising the \"temporal parietal\" network according to a cortical parcellation containing 400 parcels from Schaefer and colleagues ([2018](https://doi.org/10.1093/cercor/bhx179))." ] }, @@ -218,7 +218,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Estimating the SRM\n", + "## Estimating the SRM\n", "Next, we train the SRM on the training data. We need to specify desired dimension of the shared feature space. Although we simply use 50 features, the optimal number of dimensions can be found using grid search with cross-validation. We also need to specify a number of iterations to ensure the SRM algorithm converges." ] }, @@ -520,7 +520,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### References\n", + "## References\n", "* Chen, P. H. C., Chen, J., Yeshurun, Y., Hasson, U., Haxby, J., & Ramadge, P. J. (2015). A reduced-dimension fMRI shared response model. In C. Cortes, N.D. Lawrence, D.D. Lee, M. Sugiyama, R. Garnett (Eds.), *Advances in Neural Information Processing Systems, vol. 28* (pp. 460-468). https://papers.nips.cc/paper/5855-a-reduced-dimension-fmri-shared-response-model\n", "\n", "* Haxby, J. V., Guntupalli, J. S., Connolly, A. C., Halchenko, Y. O., Conroy, B. R., Gobbini, M. I., Hanke, M., & Ramadge, P. J. (2011). A common, high-dimensional model of the representational space in human ventral temporal cortex. *Neuron*, *72*(2), 404-416. https://doi.org/10.1016/j.neuron.2011.08.026\n", From d7e9e8af5d05bb62c55288d62895fe1855dfaf22 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 19 Sep 2022 13:44:16 -0400 Subject: [PATCH 46/96] Add setup requires dependencies to meta.yaml host There is no longer setup_requires in setup.cfg. This has been implemented with build dependencies in pyproject.toml. Not sure how to read these from Jinja so I have just included them manually for now. --- .conda/meta.yaml | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index e56dc0d6..ad80e527 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -34,17 +34,19 @@ requirements: host: - python - - setuptools - pip - mpich - openmp - {% for req in data.get('setup_requires', []) - if req not in conda_package_nonexistent -%} - - {{req}} - {% endfor %} + - setuptools>=42 + - wheel + - pybind11>=2.9.0 + - scipy!=1.0.0 + - cython + - numpy run: - python + - {{ pin_compatible('numpy') }} - mpich - openmp - tensorflow From a24277460d15c0944aa434eadbf81d0d5db78ebd Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 19 Sep 2022 14:28:03 -0400 Subject: [PATCH 47/96] Add use_scm_version=True to setup.cfg Pin mypy to github version until fix for python 3.10.7 is released. https://github.com/python/mypy/pull/13500 --- .conda/meta.yaml | 1 + setup.cfg | 1 + setup.py | 2 +- 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index ad80e527..230f75f2 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -43,6 +43,7 @@ requirements: - scipy!=1.0.0 - cython - numpy + - setuptools_scm run: - python diff --git a/setup.cfg b/setup.cfg index 4d452791..d3fd2c63 100644 --- a/setup.cfg +++ b/setup.cfg @@ -75,6 +75,7 @@ install_requires = python_requires = >=3.5 include_package_data = True zip_safe = False +use_scm_version=True [options.packages.find] where = . diff --git a/setup.py b/setup.py index 02bfa93d..dd87e438 100644 --- a/setup.py +++ b/setup.py @@ -145,7 +145,7 @@ def finalize_options(self): "inflect", "ipython", "jupyter", - "mypy", + "git+https://github.com/python/mypy.git", "nibabel", "nilearn", "nodejs", From 177bd52ccd2eaa4cc4e86b729dc754a03359152f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 19 Sep 2022 14:38:57 -0400 Subject: [PATCH 48/96] Fix syntax for setting mypy github repo as dep --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index dd87e438..a0fc4b50 100644 --- a/setup.py +++ b/setup.py @@ -145,7 +145,7 @@ def finalize_options(self): "inflect", "ipython", "jupyter", - "git+https://github.com/python/mypy.git", + "mypy @ git+https://github.com/python/mypy.git", "nibabel", "nilearn", "nodejs", From bcc2e87fe04ce697e8aa18452283860cf30b65e9 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 19 Sep 2022 15:44:59 -0400 Subject: [PATCH 49/96] Pin pymanopt install in .conda/buiild.sh like in install_requires --- .conda/build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.conda/build.sh b/.conda/build.sh index 68ae389f..4854bede 100755 --- a/.conda/build.sh +++ b/.conda/build.sh @@ -3,7 +3,7 @@ # Install from PyPI because there is no current conda package for the # following. Explicitly install dependencies with no conda package as well # because otherwise conda-build does not include them in the output package. -PIP_NO_INDEX=False $PYTHON -m pip install pymanopt +PIP_NO_INDEX=False $PYTHON -m pip install pymanopt<=0.2.5 # NOTE: This is the recommended way to install packages $PYTHON setup.py install --single-version-externally-managed --record=record.txt From c795813f8667b393744854742e219eca06433c18 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 19 Sep 2022 16:01:02 -0400 Subject: [PATCH 50/96] fix pymanopt pin --- .conda/build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.conda/build.sh b/.conda/build.sh index 4854bede..378ec7ba 100755 --- a/.conda/build.sh +++ b/.conda/build.sh @@ -3,7 +3,7 @@ # Install from PyPI because there is no current conda package for the # following. Explicitly install dependencies with no conda package as well # because otherwise conda-build does not include them in the output package. -PIP_NO_INDEX=False $PYTHON -m pip install pymanopt<=0.2.5 +PIP_NO_INDEX=False $PYTHON -m pip install "pymanopt<=0.2.5" # NOTE: This is the recommended way to install packages $PYTHON setup.py install --single-version-externally-managed --record=record.txt From aa97190d40b982677a5790731585d822d2309cb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mihai=20Capot=C4=83?= Date: Mon, 26 Sep 2022 15:04:10 -0700 Subject: [PATCH 51/96] Remove mypy workaround --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index a0fc4b50..ae7bd42f 100644 --- a/setup.py +++ b/setup.py @@ -145,7 +145,7 @@ def finalize_options(self): "inflect", "ipython", "jupyter", - "mypy @ git+https://github.com/python/mypy.git", + "mypy", "nibabel", "nilearn", "nodejs", From 16f067b5c33880c4d50f200b7cc412dd9adcfac2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 17 Oct 2022 14:58:06 -0400 Subject: [PATCH 52/96] Mark rtcloud and MPI notebooks as skip The notebooks that require MPI are failing, mark them as skip for now. I also needed to make a small change to fmrisim notebook to get new version of numpy working with it. --- .../fmrisim/fmrisim_multivariate_example.ipynb | 1 + run-tests.sh | 4 ++-- tests/test_notebooks.py | 15 ++++++++++++--- 3 files changed, 15 insertions(+), 5 deletions(-) diff --git a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb index 3c7a10c5..2901251f 100644 --- a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb +++ b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb @@ -96,6 +96,7 @@ "from brainiak.utils import fmrisim\n", "import nibabel\n", "import numpy as np\n", + "import numpy.matlib\n", "import matplotlib.pyplot as plt\n", "import scipy.ndimage as ndimage\n", "import scipy.spatial.distance as sp_distance\n", diff --git a/run-tests.sh b/run-tests.sh index c9f4177b..e0ea42fb 100755 --- a/run-tests.sh +++ b/run-tests.sh @@ -44,8 +44,8 @@ $mpi_command -n 2 coverage run -m mpi4py -m pytest # If so, run the notebook tests separately if [[ $(hostname -s) == della* ]]; then - echo "Running notebook tests on della" - $mpi_command -n 2 pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests + echo "Running non-MPI notebook tests on della" + $mpi_command -n 1 pytest -s --durations=0 tests/test_notebooks.py --enable_notebook_tests fi # Coverage produces empty files which trigger warnings on combine diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index b4b17159..63c65a5c 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -7,8 +7,17 @@ nb_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) -# Exclude the rt-cloud notebook, we need to write a custom test for this one -# nb_files = [f for f in nb_files if 'real-time' not in f] +mpi_notebooks = ['SRM', 'htfa', 'FCMA'] + +nb_tests = [] +for f in nb_files: + # Mark notebooks that need MPI to skip for now, we are having some issues on della + if any([nb in f for nb in mpi_notebooks]): + nb_tests.append(pytest.param(f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della"))) + elif 'rtcloud' in f: + nb_tests.append(pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della"))) + else: + nb_tests.append(f) # Helper function to mark specific notebooks as expected failure. @@ -51,7 +60,7 @@ def chdir_back_to_root(): @pytest.mark.notebook -@pytest.mark.parametrize("notebook_file", nb_files) +@pytest.mark.parametrize("notebook_file", nb_tests) def test_notebook(notebook_file): os.chdir(os.path.dirname(notebook_file)) From 219880d9f030c0565257255e70bdb2087a851075 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 13:42:57 -0400 Subject: [PATCH 53/96] Disable matrix-normal notebook test. It if failing intermittently, seems like a convergenge issue. --- tests/test_notebooks.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 63c65a5c..f7f4aa74 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -7,7 +7,7 @@ nb_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) -mpi_notebooks = ['SRM', 'htfa', 'FCMA'] +mpi_notebooks = ['htfa', 'FCMA'] nb_tests = [] for f in nb_files: @@ -16,6 +16,8 @@ nb_tests.append(pytest.param(f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della"))) elif 'rtcloud' in f: nb_tests.append(pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della"))) + elif 'Matrix-normal' in f: + nb_tests.append(pytest.param(f, marks=pytest.mark.skip("Matrix-normal notebook is flaky, disabled for now"))) else: nb_tests.append(f) @@ -34,7 +36,6 @@ def mark_xfail(nb, **kwargs): nb_files[nb_index] = pytest.param(nb, marks=pytest.mark.xfail(**kwargs)) - # mark_xfail('rtcloud_notebook.ipynb', # reason="Needs to have a web server installed, " # "will probably need to run this in " From ace6f6aa343a39d334155494766f82fceb0ddba5 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 13:51:02 -0400 Subject: [PATCH 54/96] Remove code for checking "std=c++11" flags Just a test, I think this code isn't needed anymore and is obscuring errors. --- setup.py | 34 ++-------------------------------- 1 file changed, 2 insertions(+), 32 deletions(-) diff --git a/setup.py b/setup.py index ae7bd42f..c9494dd3 100644 --- a/setup.py +++ b/setup.py @@ -36,36 +36,6 @@ ] -# As of Python 3.6, CCompiler has a `has_flag` method. -# cf http://bugs.python.org/issue26689 -def has_flag(compiler, flagname): - """Return a boolean indicating whether a flag name is supported on - the specified compiler. - """ - import tempfile - with tempfile.NamedTemporaryFile('w', suffix='.cpp') as f: - f.write('int main (int argc, char **argv) { return 0; }') - try: - compiler.compile([f.name], extra_postargs=[flagname]) - except setuptools.distutils.errors.CompileError: - return False - return True - - -def cpp_flag(compiler): - """Return the -std=c++[11/14] compiler flag. - - The c++14 is prefered over c++11 (when it is available). - """ - if has_flag(compiler, '-std=c++14'): - return '-std=c++14' - elif has_flag(compiler, '-std=c++11'): - return '-std=c++11' - else: - raise RuntimeError('Unsupported compiler -- at least C++11 support ' - 'is needed!') - - class BuildExt(build_ext): """A custom build extension for adding compiler-specific options.""" c_opts = { @@ -93,8 +63,8 @@ def build_extensions(self): ext.extra_link_args = deepcopy(opts) lang = ext.language or self.compiler.detect_language(ext.sources) if lang == 'c++': - ext.extra_compile_args.append(cpp_flag(self.compiler)) - ext.extra_link_args.append(cpp_flag(self.compiler)) + ext.extra_compile_args.append("-std=c++11") + ext.extra_link_args.append("-std=c++11")) build_ext.build_extensions(self) def finalize_options(self): From 725f799743315a1c051f2be015baed8d79c1a722 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 13:57:43 -0400 Subject: [PATCH 55/96] Remove extra parentheses. --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c9494dd3..4c1f9540 100644 --- a/setup.py +++ b/setup.py @@ -64,7 +64,7 @@ def build_extensions(self): lang = ext.language or self.compiler.detect_language(ext.sources) if lang == 'c++': ext.extra_compile_args.append("-std=c++11") - ext.extra_link_args.append("-std=c++11")) + ext.extra_link_args.append("-std=c++11") build_ext.build_extensions(self) def finalize_options(self): From 46223d3382da0a9b5484e349c589175217cf92bc Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 14:06:22 -0400 Subject: [PATCH 56/96] Fix indent error --- tests/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index f7f4aa74..a100f76a 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -16,7 +16,7 @@ nb_tests.append(pytest.param(f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della"))) elif 'rtcloud' in f: nb_tests.append(pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della"))) - elif 'Matrix-normal' in f: + elif 'Matrix-normal' in f: nb_tests.append(pytest.param(f, marks=pytest.mark.skip("Matrix-normal notebook is flaky, disabled for now"))) else: nb_tests.append(f) From ce10f216f34ee1618dc191b2ad54a4fbf31530e6 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 14:14:18 -0400 Subject: [PATCH 57/96] Fix style --- tests/test_notebooks.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index a100f76a..f3347be6 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -11,13 +11,17 @@ nb_tests = [] for f in nb_files: - # Mark notebooks that need MPI to skip for now, we are having some issues on della + # Mark notebooks that need MPI to skip for now, + # we are having some issues on della if any([nb in f for nb in mpi_notebooks]): - nb_tests.append(pytest.param(f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della"))) + nb_tests.append(pytest.param(f, marks=pytest.mark.skip( + "notebooks that require MPI are WIP on della"))) elif 'rtcloud' in f: - nb_tests.append(pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della"))) + nb_tests.append(pytest.param(f, marks=pytest.mark.skip(i + "rtcloud is failing on della"))) elif 'Matrix-normal' in f: - nb_tests.append(pytest.param(f, marks=pytest.mark.skip("Matrix-normal notebook is flaky, disabled for now"))) + nb_tests.append(pytest.param(f, marks=pytest.mark.skip(i + "Matrix-normal notebook is flaky, disabled for now"))) else: nb_tests.append(f) From dc621ad501a7d1cb94705d12e855a80def7ba69f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 14:29:58 -0400 Subject: [PATCH 58/96] Fix clang paths --- .github/workflows/main.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b6336699..431dc0e7 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -21,11 +21,11 @@ jobs: ./pr-check.sh - if: ${{ contains(matrix.os, 'macos') }} run: | - export CC=$(brew --prefix)/opt/llvm/bin/clang - export CXX=$(brew --prefix)/opt/llvm/bin/clang++ - export LDFLAGS="-L/usr/local/opt/llvm/lib - -Wl,-rpath,/usr/local/opt/llvm/lib $LDFLAGS" - export CPPFLAGS="-I/usr/local/opt/llvm/include $CPPFLAGS" + export CC=$(brew --prefix llvm)/bin/clang + export CXX=$(brew --prefix llvm)/bin/clang++ + export LDFLAGS="-L$(brew --prefix llvm)/lib + -Wl,-rpath,$(brew --prefix llvm)/lib $LDFLAGS" + export CPPFLAGS="-I$(brew --prefix llvm)/include $CPPFLAGS" ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From cfc8dfb01e349c6271e1200b6197c23facd09e60 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 14:37:21 -0400 Subject: [PATCH 59/96] Fix clang path to be version 14 --- .github/workflows/main.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 431dc0e7..7e7ae91e 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -21,11 +21,11 @@ jobs: ./pr-check.sh - if: ${{ contains(matrix.os, 'macos') }} run: | - export CC=$(brew --prefix llvm)/bin/clang - export CXX=$(brew --prefix llvm)/bin/clang++ - export LDFLAGS="-L$(brew --prefix llvm)/lib - -Wl,-rpath,$(brew --prefix llvm)/lib $LDFLAGS" - export CPPFLAGS="-I$(brew --prefix llvm)/include $CPPFLAGS" + export CC=$(brew --prefix llvm@14)/bin/clang + export CXX=$(brew --prefix llvm@14)/bin/clang++ + export LDFLAGS="-L$(brew --prefix llvm@14)/lib + -Wl,-rpath,$(brew --prefix llvm@14)/lib $LDFLAGS" + export CPPFLAGS="-I$(brew --prefix llvm@14)/include $CPPFLAGS" ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From 227eeeb988a7ae05931f27882c8353111a098284 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 14:42:10 -0400 Subject: [PATCH 60/96] Fix syntax error --- tests/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index f3347be6..8ccc9698 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -17,7 +17,7 @@ nb_tests.append(pytest.param(f, marks=pytest.mark.skip( "notebooks that require MPI are WIP on della"))) elif 'rtcloud' in f: - nb_tests.append(pytest.param(f, marks=pytest.mark.skip(i + nb_tests.append(pytest.param(f, marks=pytest.mark.skip( "rtcloud is failing on della"))) elif 'Matrix-normal' in f: nb_tests.append(pytest.param(f, marks=pytest.mark.skip(i From 89e95d6bce122dbf6407601a7ae970e81aefc8d8 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 22:04:11 -0400 Subject: [PATCH 61/96] Fix syntax error and black format --- tests/test_notebooks.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 8ccc9698..8349d4ae 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -7,21 +7,31 @@ nb_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) -mpi_notebooks = ['htfa', 'FCMA'] +mpi_notebooks = ["htfa", "FCMA"] nb_tests = [] for f in nb_files: # Mark notebooks that need MPI to skip for now, # we are having some issues on della if any([nb in f for nb in mpi_notebooks]): - nb_tests.append(pytest.param(f, marks=pytest.mark.skip( - "notebooks that require MPI are WIP on della"))) - elif 'rtcloud' in f: - nb_tests.append(pytest.param(f, marks=pytest.mark.skip( - "rtcloud is failing on della"))) - elif 'Matrix-normal' in f: - nb_tests.append(pytest.param(f, marks=pytest.mark.skip(i - "Matrix-normal notebook is flaky, disabled for now"))) + nb_tests.append( + pytest.param( + f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della") + ) + ) + elif "rtcloud" in f: + nb_tests.append( + pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della")) + ) + elif "Matrix-normal" in f: + nb_tests.append( + pytest.param( + f, + marks=pytest.mark.skip( + "Matrix-normal notebook is flaky, disabled for now" + ), + ) + ) else: nb_tests.append(f) @@ -40,6 +50,7 @@ def mark_xfail(nb, **kwargs): nb_files[nb_index] = pytest.param(nb, marks=pytest.mark.xfail(**kwargs)) + # mark_xfail('rtcloud_notebook.ipynb', # reason="Needs to have a web server installed, " # "will probably need to run this in " From 74ed4f38563fe9981aa1903fd778d41cb013c84e Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 22:11:25 -0400 Subject: [PATCH 62/96] Run black with 80 for line length limit. --- tests/test_notebooks.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 8349d4ae..6037de19 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -16,12 +16,17 @@ if any([nb in f for nb in mpi_notebooks]): nb_tests.append( pytest.param( - f, marks=pytest.mark.skip("notebooks that require MPI are WIP on della") + f, + marks=pytest.mark.skip( + "notebooks that require MPI are WIP on della" + ), ) ) elif "rtcloud" in f: nb_tests.append( - pytest.param(f, marks=pytest.mark.skip("rtcloud is failing on della")) + pytest.param( + f, marks=pytest.mark.skip("rtcloud is failing on della") + ) ) elif "Matrix-normal" in f: nb_tests.append( From 7c200d2feb2f8563758949319008b0c57f3e5725 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 22:22:17 -0400 Subject: [PATCH 63/96] type: ignore to line in test_notebooks.py --- tests/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 6037de19..6d0c9993 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -38,7 +38,7 @@ ) ) else: - nb_tests.append(f) + nb_tests.append(f) # type: ignore # Helper function to mark specific notebooks as expected failure. From 3a29dbabca73fd9cbf20140864154cd7eb2517d1 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 31 Oct 2022 22:41:14 -0400 Subject: [PATCH 64/96] Fix some mypy issues. --- brainiak/image.py | 19 ++++++++++++------- brainiak/io.py | 5 +++-- tests/test_notebooks.py | 2 +- 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/brainiak/image.py b/brainiak/image.py index 16ef99b7..90877478 100644 --- a/brainiak/image.py +++ b/brainiak/image.py @@ -24,7 +24,7 @@ import itertools -from typing import Iterable, Sequence, Type, TypeVar +from typing import Optional, Iterable, Sequence, Type, TypeVar import numpy as np @@ -104,8 +104,11 @@ def extract_labels(self) -> np.ndarray: return condition_idxs[unique_epoch_idxs] -def mask_image(image: SpatialImage, mask: np.ndarray, data_type: type = None - ) -> np.ndarray: +def mask_image( + image: SpatialImage, + mask: np.ndarray, + data_type: Optional[type] = None + ) -> np.ndarray: """Mask image after optionally casting its type. Parameters @@ -137,9 +140,11 @@ def mask_image(image: SpatialImage, mask: np.ndarray, data_type: type = None return cast_data[mask] -def multimask_images(images: Iterable[SpatialImage], - masks: Sequence[np.ndarray], image_type: type = None - ) -> Iterable[Sequence[np.ndarray]]: +def multimask_images( + images: Iterable[SpatialImage], + masks: Sequence[np.ndarray], + image_type: Optional[type] = None + ) -> Iterable[Sequence[np.ndarray]]: """Mask images with multiple masks. Parameters @@ -161,7 +166,7 @@ def multimask_images(images: Iterable[SpatialImage], def mask_images(images: Iterable[SpatialImage], mask: np.ndarray, - image_type: type = None) -> Iterable[np.ndarray]: + image_type: Optional[type] = None) -> Iterable[np.ndarray]: """Mask images. Parameters diff --git a/brainiak/io.py b/brainiak/io.py index 0fdfa676..ba4fdc77 100644 --- a/brainiak/io.py +++ b/brainiak/io.py @@ -22,7 +22,7 @@ ] from pathlib import Path -from typing import Callable, Iterable, List, Union +from typing import Optional, Callable, Iterable, List, Union import logging import nibabel as nib @@ -104,7 +104,8 @@ def load_images(image_paths: Iterable[Union[str, Path]] def load_boolean_mask(path: Union[str, Path], - predicate: Callable[[np.ndarray], np.ndarray] = None + predicate: Optional[ + Callable[[np.ndarray], np.ndarray]] = None ) -> np.ndarray: """Load boolean nibabel.SpatialImage mask. diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index 6d0c9993..f455bc75 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -38,7 +38,7 @@ ) ) else: - nb_tests.append(f) # type: ignore + nb_tests.append(f) # type: ignore # Helper function to mark specific notebooks as expected failure. From 7c26a225f4451be5c9b921b663cc2ca1659d270f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 6 Mar 2023 13:57:10 -0500 Subject: [PATCH 65/96] Add new workflow for running notebook tests I have setup a github actions self-hosted runner on della. I have disabled the jenkins build. --- .github/workflows/della_notebooks.yml | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 .github/workflows/della_notebooks.yml diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml new file mode 100644 index 00000000..00e31703 --- /dev/null +++ b/.github/workflows/della_notebooks.yml @@ -0,0 +1,19 @@ +on: [pull_request] +jobs: + pypi: + env: + IGNORE_CONDA: true + runs-on: self-hosted + strategy: + matrix: + python-version: ["3.10"] + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - run: | + python3 -m pip install -U pip + - run: | + chmod a+x pr-check.sh + ./pr-check.sh From 32828e6a6b1030c0ad0d81bbfcb58f77df363373 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 6 Mar 2023 14:16:05 -0500 Subject: [PATCH 66/96] Dont setup python on della, use anaconda module. --- .github/workflows/della_notebooks.yml | 8 -------- pr-check.sh | 2 +- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index 00e31703..ffef2e62 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -4,16 +4,8 @@ jobs: env: IGNORE_CONDA: true runs-on: self-hosted - strategy: - matrix: - python-version: ["3.10"] steps: - uses: actions/checkout@v2 - - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - run: | - python3 -m pip install -U pip - run: | chmod a+x pr-check.sh ./pr-check.sh diff --git a/pr-check.sh b/pr-check.sh index 27b5d8da..c47a5610 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -33,7 +33,7 @@ if [[ "$is_della" == true ]]; then echo "Running on della, load required modules" # Load some modules we will need on della - module load anaconda3/2021.11 + module load anaconda3/2022.10 #module load rh/devtoolset/8 # Load openmpi and turn off infiniband From 35f0f3ceccd92d7702c3d9d5a4b40d65db0b4d53 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 20 Mar 2023 14:23:40 -0400 Subject: [PATCH 67/96] Fix reference to llvm@14 This is causing issues on macos runners on github actions, looks like llvm got updated. Hopefully, brew is smart enough to find the current version. --- .github/workflows/main.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 7e7ae91e..431dc0e7 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -21,11 +21,11 @@ jobs: ./pr-check.sh - if: ${{ contains(matrix.os, 'macos') }} run: | - export CC=$(brew --prefix llvm@14)/bin/clang - export CXX=$(brew --prefix llvm@14)/bin/clang++ - export LDFLAGS="-L$(brew --prefix llvm@14)/lib - -Wl,-rpath,$(brew --prefix llvm@14)/lib $LDFLAGS" - export CPPFLAGS="-I$(brew --prefix llvm@14)/include $CPPFLAGS" + export CC=$(brew --prefix llvm)/bin/clang + export CXX=$(brew --prefix llvm)/bin/clang++ + export LDFLAGS="-L$(brew --prefix llvm)/lib + -Wl,-rpath,$(brew --prefix llvm)/lib $LDFLAGS" + export CPPFLAGS="-I$(brew --prefix llvm)/include $CPPFLAGS" ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From f6a638a181e1de4d6f799487d72a8230d1d1e474 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 20 Mar 2023 14:26:24 -0400 Subject: [PATCH 68/96] Fix deprecated call to get_data() This is to fix deprecated API errors. --- tests/utils/test_fmrisim_real_time.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/utils/test_fmrisim_real_time.py b/tests/utils/test_fmrisim_real_time.py index a31759cc..36ca5df8 100644 --- a/tests/utils/test_fmrisim_real_time.py +++ b/tests/utils/test_fmrisim_real_time.py @@ -33,15 +33,15 @@ data_dict = {} # type: Dict vol = resource_stream(gen.__name__, "sim_parameters/ROI_A.nii.gz").read() -data_dict['ROI_A_file'] = Nifti1Image.from_bytes(gzip.decompress( - vol)).get_data() +data_dict['ROI_A_file'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( + vol)).dataobj) vol = resource_stream(gen.__name__, "sim_parameters/ROI_B.nii.gz").read() -data_dict['ROI_B_file'] = Nifti1Image.from_bytes(gzip.decompress( - vol)).get_data() +data_dict['ROI_B_file'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( + vol)).dataobj) vol = resource_stream(gen.__name__, "sim_parameters/sub_template.nii.gz").read() -data_dict['template_path'] = Nifti1Image.from_bytes(gzip.decompress( - vol)).get_data() +data_dict['template_path'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( + vol)).dataobj) noise_dict_file = resource_stream(gen.__name__, "sim_parameters/sub_noise_dict.txt").read() data_dict['noise_dict_file'] = noise_dict_file From 60efa07debfa8bce9a57f85c67e751f6082dc6a8 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 20 Mar 2023 14:27:43 -0400 Subject: [PATCH 69/96] Rename workflow step. --- .github/workflows/della_notebooks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index ffef2e62..6e61f6e2 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -1,6 +1,6 @@ on: [pull_request] jobs: - pypi: + notebook_tests: env: IGNORE_CONDA: true runs-on: self-hosted From e50a4323814138e22ee998e2222d06ef1549789d Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 20 Mar 2023 14:28:40 -0400 Subject: [PATCH 70/96] Some changes to pr-check.sh for notebook tests - Create python 3.10 conda environment. It was using 3.8, which is pretty old at this point. - Move path off of /tigress to /scratch/gpfs. /tigress is going away on della. --- pr-check.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index c47a5610..8a3e1dac 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -69,7 +69,7 @@ function remove_venv_venv { } function create_conda_venv { - conda create -n $1 --yes python=3.8 + conda create -n $1 --yes python=3.10 } function activate_conda_venv { @@ -150,7 +150,7 @@ $activate_venv $venv || { if [[ "$is_della" == true ]]; then # We need to fetch any data needed for running notebook examples # Update our data cache with any download_data.sh scripts found in the repo - BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/tigress/dmturner/brainiak_tests/brainiak-example-data + BRAINIAK_EXAMPLES_DATA_CACHE_DIR=/scratch/gpfs/dmturner/brainiak_tests/brainiak-example-data echo "Copying download_data.sh scripts to brainiak-example-data cache" rsync -av --prune-empty-dirs --include="*/" --include="download_data.sh" --exclude="*" $EXAMPLE_NOTEBOOKS_DIR/ $BRAINIAK_EXAMPLES_DATA_CACHE_DIR/ From b151709f954104b2391f3bef9551cab502595682 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 15 May 2023 17:54:51 -0400 Subject: [PATCH 71/96] Convert calls from get_data() to get_fdatat() https://nipy.org/nibabel/reference/nibabel.dataobj_images.html#nibabel.dataobj_images.DataobjImage.get_data --- brainiak/fcma/preprocessing.py | 2 +- brainiak/image.py | 2 +- brainiak/io.py | 2 +- brainiak/utils/fmrisim_real_time_generator.py | 10 +++---- .../FCMA_script/fcma_voxel_selection_cv.py | 26 +++++++++---------- .../get_tfa_input_from_nifti.py | 4 +-- examples/fcma/voxel_selection.py | 2 +- .../searchlight/genre_searchlight_example.py | 8 +++--- pr-check.sh | 12 ++++++--- tests/image/test_image.py | 2 +- tests/io/test_io.py | 6 ++--- 11 files changed, 40 insertions(+), 36 deletions(-) diff --git a/brainiak/fcma/preprocessing.py b/brainiak/fcma/preprocessing.py index dc80e4f7..71fc299b 100644 --- a/brainiak/fcma/preprocessing.py +++ b/brainiak/fcma/preprocessing.py @@ -370,7 +370,7 @@ def prepare_searchlight_mvpa_data(images, conditions, data_type=np.float32, logger.info('start to apply masks and separate epochs') for sid, f in enumerate(images): - data = f.get_data().astype(data_type) + data = f.get_fdata().astype(data_type) [d1, d2, d3, d4] = data.shape if random == RandomType.REPRODUCIBLE: data = data.reshape((d1 * d2 * d3, d4)) diff --git a/brainiak/image.py b/brainiak/image.py index 90877478..2db59227 100644 --- a/brainiak/image.py +++ b/brainiak/image.py @@ -130,7 +130,7 @@ def mask_image( ValueError Image data and masks have different shapes. """ - image_data = image.get_data() + image_data = image.get_fdata() if image_data.shape[:3] != mask.shape: raise ValueError("Image data and mask have different shapes.") if data_type is not None: diff --git a/brainiak/io.py b/brainiak/io.py index ba4fdc77..85e88de3 100644 --- a/brainiak/io.py +++ b/brainiak/io.py @@ -124,7 +124,7 @@ def load_boolean_mask(path: Union[str, Path], """ if not isinstance(path, str): path = str(path) - data = nib.load(path).get_data() + data = nib.load(path).get_fdata() if predicate is not None: mask = predicate(data) else: diff --git a/brainiak/utils/fmrisim_real_time_generator.py b/brainiak/utils/fmrisim_real_time_generator.py index 301648d9..0be5a496 100644 --- a/brainiak/utils/fmrisim_real_time_generator.py +++ b/brainiak/utils/fmrisim_real_time_generator.py @@ -123,7 +123,7 @@ def _generate_ROIs(ROI_file, if isinstance(ROI_file, str): logger.info('Loading', ROI_file) nii = nibabel.load(ROI_file) - ROI = nii.get_data() + ROI = nii.get_fdata() else: ROI = ROI_file @@ -305,13 +305,13 @@ def _get_input_names(data_dict): # Load in the ROIs if data_dict.get('ROI_A_file') is None: vol = resource_stream(__name__, "sim_parameters/ROI_A.nii.gz").read() - ROI_A_file = Nifti1Image.from_bytes(gzip.decompress(vol)).get_data() + ROI_A_file = Nifti1Image.from_bytes(gzip.decompress(vol)).get_fdata() else: ROI_A_file = data_dict['ROI_A_file'] if data_dict.get('ROI_B_file') is None: vol = resource_stream(__name__, "sim_parameters/ROI_B.nii.gz").read() - ROI_B_file = Nifti1Image.from_bytes(gzip.decompress(vol)).get_data() + ROI_B_file = Nifti1Image.from_bytes(gzip.decompress(vol)).get_fdata() else: ROI_B_file = data_dict['ROI_B_file'] @@ -319,7 +319,7 @@ def _get_input_names(data_dict): if data_dict.get('template_path') is None: vol = resource_stream(__name__, "sim_parameters/sub_template.nii.gz").read() - template_path = Nifti1Image.from_bytes(gzip.decompress(vol)).get_data() + template_path = Nifti1Image.from_bytes(gzip.decompress(vol)).get_fdata() else: template_path = data_dict['template_path'] @@ -381,7 +381,7 @@ def generate_data(outputDir, # Load in the template data (it may already be loaded if doing a test) if isinstance(template_path, str): template_nii = nibabel.load(template_path) - template = template_nii.get_data() + template = template_nii.get_fdata() else: template = template_path diff --git a/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py b/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py index 09ae0e2b..53c2215e 100644 --- a/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py +++ b/docs/examples/fcma/FCMA_script/fcma_voxel_selection_cv.py @@ -51,7 +51,7 @@ # create output_dir if not os.path.exists(output_dir): os.makedirs(output_dir) - + # Load in the volumes, mask and labels images = io.load_images_from_dir(data_dir, suffix=suffix) mask = io.load_boolean_mask(mask_file) @@ -60,7 +60,7 @@ # Parse the epoch data for useful dimensions epochs_per_subj = epoch_list[0].shape[1] num_subjs = len(epoch_list) - + # Preprocess the data and prepare for FCMA raw_data, _, labels = prepare_fcma_data(images, epoch_list, mask) @@ -68,48 +68,48 @@ file_str = output_dir + '/fc_no' + str(left_out_subj) + '_' start_idx = int(int(left_out_subj) * epochs_per_subj) end_idx = int(start_idx + epochs_per_subj) - + # Take out the idxs corresponding to all participants but this one subsampled_idx = list(set(range(len(labels))) - set(range(start_idx, end_idx))) labels_subsampled = [labels[i] for i in subsampled_idx] raw_data_subsampled = [raw_data[i] for i in subsampled_idx] - + # Set up the voxel selection object for fcma vs = VoxelSelector(labels_subsampled, epochs_per_subj, num_subjs - 1, raw_data_subsampled) - + # for cross validation, use SVM with precomputed kernel clf = SVC(kernel='precomputed', shrinking=False, C=1) results = vs.run(clf) - + # this output is just for result checking if MPI.COMM_WORLD.Get_rank()==0: logger.info( 'correlation-based voxel selection is done' ) - + # Load in the mask with nibabel mask_img = nib.load(mask_file) - mask = mask_img.get_data().astype(np.bool) - + mask = mask_img.get_fdata().astype(np.bool) + # Preset the volumes score_volume = np.zeros(mask.shape, dtype=np.float32) score = np.zeros(len(results), dtype=np.float32) seq_volume = np.zeros(mask.shape, dtype=np.int) seq = np.zeros(len(results), dtype=np.int) - + # Write a text document of the voxel selection results with open(file_str + 'result_list.txt', 'w') as fp: for idx, tuple in enumerate(results): fp.write(str(tuple[0]) + ' ' + str(tuple[1]) + '\n') - + # Store the score for each voxel score[tuple[0]] = tuple[1] seq[tuple[0]] = idx - + # Convert the list into a volume score_volume[mask] = score seq_volume[mask] = seq - + # Save volume io.save_as_nifti_file(score_volume, mask_img.affine, file_str + 'result_score.nii.gz') diff --git a/examples/factoranalysis/get_tfa_input_from_nifti.py b/examples/factoranalysis/get_tfa_input_from_nifti.py index d3a40638..f6236a44 100644 --- a/examples/factoranalysis/get_tfa_input_from_nifti.py +++ b/examples/factoranalysis/get_tfa_input_from_nifti.py @@ -39,7 +39,7 @@ def extract_data(nifti_file, mask_file, out_file, zscore, detrend, smoothing_fwm mask = nib.load(mask_file.name) affine = mask.get_affine() if mask_file is None: - mask_data = mask.get_data() + mask_data = mask.get_fdata() if mask_data.ndim == 4: #get mask in 3D img_data_type = mask.header.get_data_dtype() @@ -49,7 +49,7 @@ def extract_data(nifti_file, mask_file, out_file, zscore, detrend, smoothing_fwm else: mask_data = mask_data.astype(bool) else: - mask_data = mask.get_data().astype(bool) + mask_data = mask.get_fdata().astype(bool) #get voxel coordinates R = np.float64(np.argwhere(mask_data)) diff --git a/examples/fcma/voxel_selection.py b/examples/fcma/voxel_selection.py index f4bd70ae..2efdc3a1 100644 --- a/examples/fcma/voxel_selection.py +++ b/examples/fcma/voxel_selection.py @@ -86,7 +86,7 @@ ) #print(results[0:100]) mask_img = nib.load(mask_file) - mask = mask_img.get_data().astype(np.bool) + mask = mask_img.get_fdata().astype(np.bool) score_volume = np.zeros(mask.shape, dtype=np.float32) score = np.zeros(len(results), dtype=np.float32) seq_volume = np.zeros(mask.shape, dtype=np.int) diff --git a/examples/searchlight/genre_searchlight_example.py b/examples/searchlight/genre_searchlight_example.py index d3fd0ced..0dbc8ecc 100644 --- a/examples/searchlight/genre_searchlight_example.py +++ b/examples/searchlight/genre_searchlight_example.py @@ -1,4 +1,4 @@ -# The following code is designed to perform a searchlight at every voxel in the brain looking at the difference in pattern similarity between musical genres (i.e. classical and jazz). In the study where the data was obtained, subjects were required to listen to a set of 16 songs twice (two runs) in an fMRI scanner. The 16 songs consisted of 8 jazz songs and 8 classical songs. The goal of this searchlight is to find voxels that seem to represent distinct information about these different musical genres. Presumably, these voxels would be found in the auditory cortex which happens to be the most organized system in the brain for processing sound information. +# The following code is designed to perform a searchlight at every voxel in the brain looking at the difference in pattern similarity between musical genres (i.e. classical and jazz). In the study where the data was obtained, subjects were required to listen to a set of 16 songs twice (two runs) in an fMRI scanner. The 16 songs consisted of 8 jazz songs and 8 classical songs. The goal of this searchlight is to find voxels that seem to represent distinct information about these different musical genres. Presumably, these voxels would be found in the auditory cortex which happens to be the most organized system in the brain for processing sound information. import numpy as np import time @@ -25,7 +25,7 @@ d1_reshape = np.reshape(data1_rand,(91*109*91,16)) d2_reshape = np.reshape(data2_rand,(91*109*91,16)) a1 = load_img('a1plus_2mm.nii.gz') - a1_vec = np.reshape(a1.get_data(),(91*109*91)) + a1_vec = np.reshape(a1.get_fdata(),(91*109*91)) a1_idx = np.nonzero(a1_vec) for i in range(8): d1_reshape[a1_idx[0],i] += classical @@ -44,9 +44,9 @@ data1 = None data2 = None -# Load mask +# Load mask mask_img = load_img('MNI152_T1_2mm_brain_mask.nii') -mask_img = mask_img.get_data() +mask_img = mask_img.get_fdata() # Definte function that takes the difference between within vs. between genre comparisons def corr2_coeff(AB,msk,myrad,bcast_var): diff --git a/pr-check.sh b/pr-check.sh index 8a3e1dac..31826719 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -33,12 +33,11 @@ if [[ "$is_della" == true ]]; then echo "Running on della, load required modules" # Load some modules we will need on della - module load anaconda3/2022.10 - #module load rh/devtoolset/8 + module load anaconda3/2023.3 # Load openmpi and turn off infiniband # module load openmpi/gcc/2.0.2/64 - module load openmpi/gcc/4.1.0 + module load openmpi/gcc/4.1.2 export MPICC=$(which mpicc) export OMPI_MCA_btl="vader,self,tcp" @@ -69,7 +68,7 @@ function remove_venv_venv { } function create_conda_venv { - conda create -n $1 --yes python=3.10 + conda create -n $1 --yes python=3.8 } function activate_conda_venv { @@ -165,6 +164,11 @@ if [[ "$is_della" == true ]]; then rsync -av $BRAINIAK_EXAMPLES_DATA_CACHE_DIR/ $EXAMPLE_NOTEBOOKS_DIR/ # Skip upgrading pip, this was causing failures on della, not sure why. + + # Install mpi4py first, no cache director + pip install mpi4py --no-cache-dir || \ + exit_with_error_and_venv "Failed to install mpi4py." + else python3 -m pip install -U pip || \ exit_with_error_and_venv "Failed to update Pip." diff --git a/tests/image/test_image.py b/tests/image/test_image.py index e5b4d13a..47613b76 100644 --- a/tests/image/test_image.py +++ b/tests/image/test_image.py @@ -103,7 +103,7 @@ def masked_data() -> np.ndarray: @pytest.fixture def images(spatial_image: SpatialImage) -> Iterable[SpatialImage]: images = [spatial_image] - image_data = spatial_image.get_data().copy() + image_data = spatial_image.get_fdata().copy() image_data[1, 1, 1, 0] = 2 images.append(Nifti1Pair(image_data, np.eye(4))) return images diff --git a/tests/io/test_io.py b/tests/io/test_io.py index dd1d5337..1f45c423 100644 --- a/tests/io/test_io.py +++ b/tests/io/test_io.py @@ -63,7 +63,7 @@ def test_load_images_from_dir_data_shape( expected_n_subjects: int ) -> None: for i, image in enumerate(io.load_images_from_dir(in_dir, "bet.nii.gz")): - assert image.get_data().shape == (64, 64, 26, 10) + assert image.get_fdata().shape == (64, 64, 26, 10) assert i + 1 == expected_n_subjects @@ -73,7 +73,7 @@ def test_load_images_data_shape( expected_n_subjects: int ) -> None: for i, image in enumerate(io.load_images(image_paths)): - assert image.get_data().shape == (64, 64, 26, 10) + assert image.get_fdata().shape == (64, 64, 26, 10) assert i + 1 == expected_n_subjects @@ -103,4 +103,4 @@ def test_save_as_nifti_file(tmpdir) -> None: out_file = str(tmpdir / "nifti.nii") shape = (4, 4, 4) io.save_as_nifti_file(np.ones(shape), np.eye(4), out_file) - assert nib.load(out_file).get_data().shape == shape + assert nib.load(out_file).get_fdata().shape == shape From b7d4f54734fbe9551afe8df39f5febd3d8fa4df6 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 09:21:05 -0400 Subject: [PATCH 72/96] Disable SRM notebook test for now. This is an MPI test as well. --- tests/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index f455bc75..34634a51 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -7,7 +7,7 @@ nb_files = glob.glob("docs/examples/**/*.ipynb", recursive=True) -mpi_notebooks = ["htfa", "FCMA"] +mpi_notebooks = ["htfa", "FCMA", "SRM"] nb_tests = [] for f in nb_files: From 9a661391d6f7e87bb93383985c2295e974847e4f Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 09:21:58 -0400 Subject: [PATCH 73/96] Add dtype=float for Nifti1Pair image creation. See https://github.com/nipy/nibabel/issues/1089 np.array using int64 for arrays created with all integers. These arrays cannot be passed to directly to Nifti1Pair constructor anymore without explicit dtype argument specifying that the user wants a int64 image. I added a dtype=float specification to the np.array construction to get rid of this error. --- tests/image/test_image.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/image/test_image.py b/tests/image/test_image.py index 47613b76..d5a37edb 100644 --- a/tests/image/test_image.py +++ b/tests/image/test_image.py @@ -71,7 +71,7 @@ def spatial_image() -> SpatialImage: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], - [0, 0, 0, 0]]]]).reshape(4, 4, 4, 1), + [0, 0, 0, 0]]]], dtype=float).reshape(4, 4, 4, 1), np.eye(4)) From 77984421ae2f38e145f41d81f5a6f0f307dd9d0e Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 09:29:12 -0400 Subject: [PATCH 74/96] Another get_data() to get_fdata() fix. This notebook was calling get_data. --- .../fmrisim_multivariate_example.ipynb | 7728 +---------------- 1 file changed, 14 insertions(+), 7714 deletions(-) diff --git a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb index 2901251f..52f9cefd 100644 --- a/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb +++ b/docs/examples/fmrisim/fmrisim_multivariate_example.ipynb @@ -124,7 +124,7 @@ "outputs": [], "source": [ "nii = nibabel.load('Corr_MVPA/Participant_01_rest_run01.nii')\n", - "volume = nii.get_data()" + "volume = nii.get_fdata()" ] }, { @@ -194,7 +194,7 @@ "\n", "To ameliorate some of these concerns, it is possible to fit the spatial and temporal noise properties of the data. This iterates over the noise generation process and tunes parameters in order to match those that are provided. This is time consuming (especially for fitting the temporal noise) but is helpful in matching the specified noise properties. \n", "\n", - "This toolbox separates noise in two: spatial noise and temporal noise. To estimate spatial noise both the smoothness and the amount of non-brain noise of the data must be quantified. For smoothness, the Full Width Half Max (FWHM) of the volume is averaged for the X, Y and Z dimension and then averaged across a sample of time points. To calculate the Signal to Noise Ratio (SNR) the mean activity in brain voxels for the middle time point is divided by the standard deviation in activity across non-brain voxels for that time point. For temporal noise an auto-regressive and moving average (ARMA) process is estimated, along with the overall size of temporal variability. A sample of brain voxels is used to estimate the first AR component and the first MA component of each voxel's activity over time using the statsmodels package. The Signal to Fluctuation Noise Ratio (SFNR) is calculated by dividing the average activity of voxels in the brain with that voxel\u2019s noise (Friedman & Glover, 2006). That noise is calculated by taking the standard deviation of that voxel over time after it has been detrended with a second order polynomial. The SFNR then controls the amount of functional variability. Other types of noise can be generated, such as physiological noise, but are not estimated by this function.\n" + "This toolbox separates noise in two: spatial noise and temporal noise. To estimate spatial noise both the smoothness and the amount of non-brain noise of the data must be quantified. For smoothness, the Full Width Half Max (FWHM) of the volume is averaged for the X, Y and Z dimension and then averaged across a sample of time points. To calculate the Signal to Noise Ratio (SNR) the mean activity in brain voxels for the middle time point is divided by the standard deviation in activity across non-brain voxels for that time point. For temporal noise an auto-regressive and moving average (ARMA) process is estimated, along with the overall size of temporal variability. A sample of brain voxels is used to estimate the first AR component and the first MA component of each voxel's activity over time using the statsmodels package. The Signal to Fluctuation Noise Ratio (SFNR) is calculated by dividing the average activity of voxels in the brain with that voxel’s noise (Friedman & Glover, 2006). That noise is calculated by taking the standard deviation of that voxel over time after it has been detrended with a second order polynomial. The SFNR then controls the amount of functional variability. Other types of noise can be generated, such as physiological noise, but are not estimated by this function.\n" ] }, { @@ -279,777 +279,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -1096,777 +326,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -1950,777 +410,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -2797,777 +487,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -3738,777 +658,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -4571,777 +721,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -5475,7 +855,7 @@ "source": [ "#### 3.5 Estimate the voxel weight for each event\n", "\n", - "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel\u2019s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel\u2019s response to signal over time." + "According to the logic of this example, each voxel carrying signal will respond a different amount for condition A and B. To simulate this we multiply a voxel’s response to each condition by the time course of events and then combine these to make a single time course. This time course describes each voxel’s response to signal over time." ] }, { @@ -5502,777 +882,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -6310,7 +920,7 @@ "source": [ "#### 3.6 Convolve each voxel's time course with the Hemodynamic Response Function\n", "\n", - "With the time course of stimulus events it is necessary to estimate the brain\u2019s response to those events, which can be estimated by convolving it with using a Hemodynamic Response Function (HRF). By default, `convolve_hrf` assumes a double gamma HRF appropriately models a brain\u2019s response to events, as modeled by fMRI (Friston, et al., 1998). To do this convolution, each voxel\u2019s time course is convolved to make a function of the signal activity. Hence this produces an estimate of the voxel\u2019s activity, after considering the temporal blurring of the HRF. This can take a single vector of events or multiple time courses." + "With the time course of stimulus events it is necessary to estimate the brain’s response to those events, which can be estimated by convolving it with using a Hemodynamic Response Function (HRF). By default, `convolve_hrf` assumes a double gamma HRF appropriately models a brain’s response to events, as modeled by fMRI (Friston, et al., 1998). To do this convolution, each voxel’s time course is convolved to make a function of the signal activity. Hence this produces an estimate of the voxel’s activity, after considering the temporal blurring of the HRF. This can take a single vector of events or multiple time courses." ] }, { @@ -6335,777 +945,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -7281,777 +1121,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -8103,777 +1173,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox \u2265 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
');\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] From 254f6fc860bc248c5f33534788bafe4501494b25 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 12:30:38 -0400 Subject: [PATCH 75/96] Disable doc build on della --- pr-check.sh | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/pr-check.sh b/pr-check.sh index 31826719..6579612d 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -198,23 +198,27 @@ fi -# build documentation -cd docs -export THEANO_FLAGS='device=cpu,floatX=float64,blas.ldflags=-lblas' - -if [ ! -z $SLURM_NODELIST ] -then - if [[ "$is_della" == true ]]; then - make_wrapper="srun -t 00:30:00 -N 1 -n 4 " - else - make_wrapper="srun -n 1" +# build documentation, only if not della +if [[ "$is_della" == true ]]; then + echo "Skipping docs build on della" +else + cd docs + export THEANO_FLAGS='device=cpu,floatX=float64,blas.ldflags=-lblas' + + if [ ! -z $SLURM_NODELIST ] + then + if [[ "$is_della" == true ]]; then + make_wrapper="srun -t 00:30:00 -N 1 -n 4 " + else + make_wrapper="srun -n 1" + fi fi -fi -$make_wrapper make || { + $make_wrapper make || { + cd - + exit_with_error_and_venv "make docs failed" + } cd - - exit_with_error_and_venv "make docs failed" -} -cd - +fi $deactivate_venv $remove_venv $venv From 408c4cb154cb9ad7207246b79676593c803407fb Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 12:31:01 -0400 Subject: [PATCH 76/96] Set IGNORE_CONDA false on della --- .github/workflows/della_notebooks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index 6e61f6e2..ef3f416f 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -2,7 +2,7 @@ on: [pull_request] jobs: notebook_tests: env: - IGNORE_CONDA: true + IGNORE_CONDA: false runs-on: self-hosted steps: - uses: actions/checkout@v2 From 07a061f080ad4c6e80bdd641e06d597b860f534d Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 12:48:35 -0400 Subject: [PATCH 77/96] Delete IGNOR_CONDA Didn't realize IGNORE_CONDA wasn't a boolean, its mere definition causes conda to be ignored. --- .github/workflows/della_notebooks.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index ef3f416f..7e36ce9b 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -1,8 +1,6 @@ on: [pull_request] jobs: notebook_tests: - env: - IGNORE_CONDA: false runs-on: self-hosted steps: - uses: actions/checkout@v2 From aa55f156d6e6151def656f2d8f1bfa89bc4a9f30 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 12:50:45 -0400 Subject: [PATCH 78/96] Change license_file to license_files license_file has been deprecated apparently. https://github.com/pypa/pipenv/issues/5302 --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index d3fd2c63..4b4b0606 100644 --- a/setup.cfg +++ b/setup.cfg @@ -9,7 +9,7 @@ author_email = mihai.capota@intel.com maintainer = Mihai Capota maintainer_email = mihai.capota@intel.com license = Apache 2 -license_file = LICENSE +license_files = LICENSE classifiers = Development Status :: 5 - Production/Stable Intended Audience :: Developers From 5d3a349b0b50338939e8ddc10ff0f25399d2ab62 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 13:31:51 -0400 Subject: [PATCH 79/96] Fix to find clang on macos Doesn't seem like we are locating clang correctly. Trying clang 15 specifically because it says to do that in here: https://github.com/actions/runner-images/blob/main/images/macos/macos-13-Readme.md Kind of brittle unfortunately. --- .github/workflows/main.yml | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 4e907e69..5a01ac9e 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -21,11 +21,12 @@ jobs: ./pr-check.sh - if: ${{ contains(matrix.os, 'macos') }} run: | - export CC=$(brew --prefix llvm)/bin/clang - export CXX=$(brew --prefix llvm)/bin/clang++ - export LDFLAGS="-L$(brew --prefix llvm)/lib - -Wl,-rpath,$(brew --prefix llvm)/lib $LDFLAGS" - export CPPFLAGS="-I$(brew --prefix llvm)/include $CPPFLAGS" + export CLANG_PREFIX=$(brew --prefix llvm@15) + export CC=$CLANG_PREFIX/bin/clang + export CXX=$CLANG_PREFIX/bin/clang++ + export LDFLAGS="-L$CLANG_PREFIX/lib + -Wl,-rpath,$CLANG_PREFIX/lib $LDFLAGS" + export CPPFLAGS="-I$CLANG_PREFIX/include $CPPFLAGS" ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From a7135ae047e4e1ce4f60669cf1c1c47177ae6ae9 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 13:34:26 -0400 Subject: [PATCH 80/96] Add concurrency constraints to workflows --- .github/workflows/della_notebooks.yml | 5 +++++ .github/workflows/main.yml | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index 7e36ce9b..ab8473da 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -1,4 +1,9 @@ on: [pull_request] + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + jobs: notebook_tests: runs-on: self-hosted diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 5a01ac9e..ad9a688e 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,4 +1,9 @@ on: [pull_request, push] + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + jobs: pypi: env: From c749662d0a18475876bb1f95e97a1294af41cbc2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 13:56:49 -0400 Subject: [PATCH 81/96] Codestyle fix --- brainiak/utils/fmrisim_real_time_generator.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/brainiak/utils/fmrisim_real_time_generator.py b/brainiak/utils/fmrisim_real_time_generator.py index 0be5a496..1cca5e08 100644 --- a/brainiak/utils/fmrisim_real_time_generator.py +++ b/brainiak/utils/fmrisim_real_time_generator.py @@ -319,7 +319,8 @@ def _get_input_names(data_dict): if data_dict.get('template_path') is None: vol = resource_stream(__name__, "sim_parameters/sub_template.nii.gz").read() - template_path = Nifti1Image.from_bytes(gzip.decompress(vol)).get_fdata() + template_path = Nifti1Image.from_bytes( + gzip.decompress(vol)).get_fdata() else: template_path = data_dict['template_path'] From 1cffdc9bba675891f2202f2f6ade53a9c782df01 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 14:07:46 -0400 Subject: [PATCH 82/96] Install OpenMP for macos. --- .github/workflows/main.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index ad9a688e..6116283c 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -32,6 +32,7 @@ jobs: export LDFLAGS="-L$CLANG_PREFIX/lib -Wl,-rpath,$CLANG_PREFIX/lib $LDFLAGS" export CPPFLAGS="-I$CLANG_PREFIX/include $CPPFLAGS" + brew install libomp ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From cab7f57fec0a7e6656c78511be3b804879aa8d29 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 14:23:21 -0400 Subject: [PATCH 83/96] Add include and lib dirs for omp --- .github/workflows/main.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 6116283c..45dcf3a4 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -30,8 +30,8 @@ jobs: export CC=$CLANG_PREFIX/bin/clang export CXX=$CLANG_PREFIX/bin/clang++ export LDFLAGS="-L$CLANG_PREFIX/lib - -Wl,-rpath,$CLANG_PREFIX/lib $LDFLAGS" - export CPPFLAGS="-I$CLANG_PREFIX/include $CPPFLAGS" + -Wl,-rpath,$CLANG_PREFIX/lib $LDFLAGS -L/usr/local/opt/libomp/lib" + export CPPFLAGS="-I$CLANG_PREFIX/include $CPPFLAGS -I/usr/local/opt/libomp/include" brew install libomp ./pr-check.sh - uses: codecov/codecov-action@v1 From 834c41d01e961fbe13e3f2a338013970f1b3b6cd Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 23:29:45 -0400 Subject: [PATCH 84/96] Bunch of mypy fixes Not sure why these are popping up now all of a sudden. Some are related to change of get_data to get_fdata. Most of these I couldn't figure out and I set to ignore. --- brainiak/image.py | 6 ++-- brainiak/io.py | 6 ++-- tests/image/test_image.py | 43 ++++++++++++++++----------- tests/io/test_io.py | 2 +- tests/utils/test_fmrisim_real_time.py | 17 ++++++----- 5 files changed, 43 insertions(+), 31 deletions(-) diff --git a/brainiak/image.py b/brainiak/image.py index 2db59227..be7d0147 100644 --- a/brainiak/image.py +++ b/brainiak/image.py @@ -134,7 +134,7 @@ def mask_image( if image_data.shape[:3] != mask.shape: raise ValueError("Image data and mask have different shapes.") if data_type is not None: - cast_data = image_data.astype(data_type) + cast_data: np.ndarray = image_data.astype(data_type) else: cast_data = image_data return cast_data[mask] @@ -183,5 +183,5 @@ def mask_images(images: Iterable[SpatialImage], mask: np.ndarray, np.ndarray Masked image. """ - for images in multimask_images(images, (mask,), image_type): - yield images[0] + for imgs in multimask_images(images, (mask,), image_type): # type: ignore + yield imgs[0] # type: ignore diff --git a/brainiak/io.py b/brainiak/io.py index 85e88de3..298da4b3 100644 --- a/brainiak/io.py +++ b/brainiak/io.py @@ -69,7 +69,7 @@ def load_images_from_dir(in_dir: Union[str, Path], suffix: str = "nii.gz", logger.debug( 'Starting to read file %s', f ) - yield nib.load(str(f)) + yield nib.load(str(f)) # type: ignore def load_images(image_paths: Iterable[Union[str, Path]] @@ -100,7 +100,7 @@ def load_images(image_paths: Iterable[Union[str, Path]] logger.debug( 'Starting to read file %s', string_path ) - yield nib.load(string_path) + yield nib.load(string_path) # type: ignore def load_boolean_mask(path: Union[str, Path], @@ -124,7 +124,7 @@ def load_boolean_mask(path: Union[str, Path], """ if not isinstance(path, str): path = str(path) - data = nib.load(path).get_fdata() + data = nib.load(path).get_fdata() # type: ignore if predicate is not None: mask = predicate(data) else: diff --git a/tests/image/test_image.py b/tests/image/test_image.py index d5a37edb..3e4a78d4 100644 --- a/tests/image/test_image.py +++ b/tests/image/test_image.py @@ -56,23 +56,32 @@ def test_extract_labels(self, condition_spec: SingleConditionSpec @pytest.fixture def spatial_image() -> SpatialImage: - return Nifti1Pair(np.array([[[[0, 0, 0, 0], - [0, 0, 0, 0], - [0, 0, 0, 0], - [0, 0, 0, 0]], - [[0, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 1, 0], - [0, 0, 0, 0]], - [[0, 0, 0, 0], - [0, 0, 1, 0], - [0, 1, 0, 0], - [0, 0, 0, 0]], - [[0, 0, 0, 0], - [0, 0, 0, 0], - [0, 0, 0, 0], - [0, 0, 0, 0]]]], dtype=float).reshape(4, 4, 4, 1), - np.eye(4)) + return Nifti1Pair( + np.array( + [ + [ + [[0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0]], + [[0, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 0]], + [[0, 0, 0, 0], + [0, 0, 1, 0], + [0, 1, 0, 0], + [0, 0, 0, 0]], + [[0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0]], + ] + ], + dtype=float, + ).reshape(4, 4, 4, 1), + np.eye(4), + ) @pytest.fixture diff --git a/tests/io/test_io.py b/tests/io/test_io.py index 1f45c423..a3592f2c 100644 --- a/tests/io/test_io.py +++ b/tests/io/test_io.py @@ -103,4 +103,4 @@ def test_save_as_nifti_file(tmpdir) -> None: out_file = str(tmpdir / "nifti.nii") shape = (4, 4, 4) io.save_as_nifti_file(np.ones(shape), np.eye(4), out_file) - assert nib.load(out_file).get_fdata().shape == shape + assert nib.load(out_file).get_fdata().shape == shape # type: ignore diff --git a/tests/utils/test_fmrisim_real_time.py b/tests/utils/test_fmrisim_real_time.py index 36ca5df8..3f0918fa 100644 --- a/tests/utils/test_fmrisim_real_time.py +++ b/tests/utils/test_fmrisim_real_time.py @@ -31,17 +31,20 @@ with pytest.raises(TypeError): gen.generate_data() # type: ignore -data_dict = {} # type: Dict +data_dict: Dict = {} vol = resource_stream(gen.__name__, "sim_parameters/ROI_A.nii.gz").read() -data_dict['ROI_A_file'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( - vol)).dataobj) +data_dict["ROI_A_file"] = np.asanyarray( + Nifti1Image.from_bytes(gzip.decompress(vol)).dataobj +) vol = resource_stream(gen.__name__, "sim_parameters/ROI_B.nii.gz").read() -data_dict['ROI_B_file'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( - vol)).dataobj) +data_dict["ROI_B_file"] = np.asanyarray( + Nifti1Image.from_bytes(gzip.decompress(vol)).dataobj +) vol = resource_stream(gen.__name__, "sim_parameters/sub_template.nii.gz").read() -data_dict['template_path'] = np.asanyarray(Nifti1Image.from_bytes(gzip.decompress( - vol)).dataobj) +data_dict["template_path"] = np.asanyarray( + Nifti1Image.from_bytes(gzip.decompress(vol)).dataobj +) noise_dict_file = resource_stream(gen.__name__, "sim_parameters/sub_noise_dict.txt").read() data_dict['noise_dict_file'] = noise_dict_file From ca755eda8268da8892f4ac334a9ac357945f2d16 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 16 May 2023 23:43:15 -0400 Subject: [PATCH 85/96] Remove install of omp on MacOS. It isn't needed apparently, already installed. --- .github/workflows/main.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 45dcf3a4..e86a2224 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -32,7 +32,6 @@ jobs: export LDFLAGS="-L$CLANG_PREFIX/lib -Wl,-rpath,$CLANG_PREFIX/lib $LDFLAGS -L/usr/local/opt/libomp/lib" export CPPFLAGS="-I$CLANG_PREFIX/include $CPPFLAGS -I/usr/local/opt/libomp/include" - brew install libomp ./pr-check.sh - uses: codecov/codecov-action@v1 conda: From 0ec46dd4054e7dfb8e15187c15f06c9199fddf43 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 12:44:30 -0400 Subject: [PATCH 86/96] Added a some documentation --- .github/workflows/della_notebooks.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/della_notebooks.yml b/.github/workflows/della_notebooks.yml index ab8473da..50953aaa 100644 --- a/.github/workflows/della_notebooks.yml +++ b/.github/workflows/della_notebooks.yml @@ -1,3 +1,9 @@ +# Workflow file for test runs on Princeton's della cluster. This only runs on self +# hosted runners. The pr-check script detects that it is running on della and +# runs tests of notebooks that require larger resources than GitHub Actions hosted +# runners provide. It would probably be better to move a lot of that logic to this +# file in the future. + on: [pull_request] concurrency: From 2f4d08019f30dcf5d56f17afb466edef02bce19e Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 13:07:26 -0400 Subject: [PATCH 87/96] Add new errors to flake8 ignore E231 missing whitespace after ',' and E721 do not compare types, for exact checks use `is` / `is not`, for instance checks use `isinstance()` --- brainiak/factoranalysis/htfa.py | 2 +- setup.cfg | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/brainiak/factoranalysis/htfa.py b/brainiak/factoranalysis/htfa.py index 6940ab6f..10c543e8 100644 --- a/brainiak/factoranalysis/htfa.py +++ b/brainiak/factoranalysis/htfa.py @@ -498,7 +498,7 @@ def _init_prior_posterior(self, rank, R, n_local_subj): if rank == 0: idx = np.random.choice(n_local_subj, 1) - self.global_prior_, self.global_centers_cov,\ + self.global_prior_, self.global_centers_cov, \ self.global_widths_var = self.get_template(R[idx[0]]) self.global_centers_cov_scaled =\ self.global_centers_cov / float(self.n_subj) diff --git a/setup.cfg b/setup.cfg index 4b4b0606..7290452d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -85,6 +85,8 @@ max-complexity = 10 extend-ignore = # Docstrings D, + E721, + E231 [coverage:run] source = brainiak From fdd7c174499e1d27c1f63d16c69570745f297456 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 13:58:19 -0400 Subject: [PATCH 88/96] Add flake8 ignores for tests as well. --- tests/.flake8 | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/.flake8 b/tests/.flake8 index 19a46166..1f6c9b76 100644 --- a/tests/.flake8 +++ b/tests/.flake8 @@ -5,5 +5,7 @@ extend-ignore = T001, T003, T201, + E721, + E231, # Docstrings D, From af97896af41018410151736ec507e8b1f613e87a Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 17:18:01 -0400 Subject: [PATCH 89/96] Pin tensorflow to fix problems with tf probability --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 4c1f9540..b8dd77ad 100644 --- a/setup.py +++ b/setup.py @@ -96,7 +96,7 @@ def finalize_options(self): ], 'matnormal': [ - 'tensorflow', + 'tensorflow<=2.12.0', 'tensorflow_probability<=0.15.0', ], From b05a7d75b32083ae91dc1d42e4e7046f3b6acce6 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 17:18:32 -0400 Subject: [PATCH 90/96] Move TMPDIR to scratch on della. For some reason tmp is running out of space on della, lets use scratch for now. --- pr-check.sh | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pr-check.sh b/pr-check.sh index 6579612d..64a767a1 100755 --- a/pr-check.sh +++ b/pr-check.sh @@ -41,6 +41,9 @@ if [[ "$is_della" == true ]]; then export MPICC=$(which mpicc) export OMPI_MCA_btl="vader,self,tcp" + # Issues with pip using tmp on della + export TMPDIR=/scratch/gpfs/dmturner/tmp + fi if [ ! -f brainiak/__init__.py ] From a2b7f55290d6cfc551e7dbbcf6d75c5c33ef621f Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 17:37:40 -0400 Subject: [PATCH 91/96] Attempt to fix doc build error The following warning generates and error in doc build. Warning, treated as error: /home/runner/work/brainiak/brainiak/brainiak/factoranalysis/htfa.py:docstring of brainiak.factoranalysis.htfa:1:undefined label: 'metadata_routing' Seems to be discussed here: https://github.com/scikit-learn/scikit-learn/pull/26747 --- docs/conf.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/docs/conf.py b/docs/conf.py index c6836a46..8f6c94f6 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -300,3 +300,14 @@ myst_heading_anchors = 7 nb_execution_timeout = -1 nb_execution_mode = "off" + + +# Check intersphinx reference targets exist +nitpicky = True + +# Temporary solution to nilearn/nilearn#3800 +# See also scikit-learn/scikit-learn#26761 +nitpick_ignore = [ + ("py:class", "pipeline.Pipeline"), + ("py:class", "utils.metadata_routing.MetadataRequest"), +] From 1667879390523d0555d9e1960ecef9e461a01839 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 7 Aug 2023 19:08:10 -0400 Subject: [PATCH 92/96] Disable -W on Sphinx Bad reference warnings are being treated as errors. We have a ton (over 1200!) and building up the exclusion list is too much work for now. --- docs/Makefile | 2 +- docs/conf.py | 10 ---------- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/docs/Makefile b/docs/Makefile index f018a6db..ffc44f53 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -2,7 +2,7 @@ # # You can set these variables from the command line. -SPHINXOPTS = -W +SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build diff --git a/docs/conf.py b/docs/conf.py index 8f6c94f6..d85c7937 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -301,13 +301,3 @@ nb_execution_timeout = -1 nb_execution_mode = "off" - -# Check intersphinx reference targets exist -nitpicky = True - -# Temporary solution to nilearn/nilearn#3800 -# See also scikit-learn/scikit-learn#26761 -nitpick_ignore = [ - ("py:class", "pipeline.Pipeline"), - ("py:class", "utils.metadata_routing.MetadataRequest"), -] From fb5744e063cf5cfab006861c3c1718d6665204c3 Mon Sep 17 00:00:00 2001 From: David Turner Date: Tue, 5 Sep 2023 15:24:53 -0400 Subject: [PATCH 93/96] Disable conda build on Mac for now, testing. --- .github/workflows/main.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index e86a2224..c85fb1a8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -38,7 +38,8 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - os: [ubuntu-20.04, macos-latest] + os: [ubuntu-20.04] + #os: [ubuntu-20.04, macos-latest] python-version: [3.8] steps: - uses: actions/checkout@v2 From 576050f81937d097fcf50cb7e94330b8a135e2e1 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Mon, 2 Oct 2023 15:39:57 -0400 Subject: [PATCH 94/96] Fixes for building conda packages. - Trying to use mamba\boa to speed things up. - Specify llvm-openmp for mac. --- .conda/meta.yaml | 6 +++--- .github/workflows/main.yml | 11 ++++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index 230f75f2..a8ea32e0 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -36,20 +36,20 @@ requirements: - python - pip - mpich - - openmp + - llvm-openmp - setuptools>=42 - wheel - pybind11>=2.9.0 - scipy!=1.0.0 - cython - - numpy + - {{ pin_compatible('numpy') }} - setuptools_scm run: - python - {{ pin_compatible('numpy') }} - mpich - - openmp + - llvm-openmp - tensorflow - tensorflow-probability {% for req in data.get('install_requires', []) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index c85fb1a8..710ed5da 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -38,15 +38,16 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - os: [ubuntu-20.04] - #os: [ubuntu-20.04, macos-latest] + os: [ubuntu-20.04, macos-latest] python-version: [3.8] steps: - uses: actions/checkout@v2 - - uses: conda-incubator/setup-miniconda@v2 + - uses: mamba-org/setup-micromamba@v1 with: - channels: conda-forge - python-version: ${{ matrix.python-version }} + environment-name: test-env + create-args: >- + python=${{ matrix.python-version }} + boa - run: | export CONDA_HOME=$CONDA conda install conda-build From 4d4034736143295ad7bf0cc287d7ff86689ee741 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Mon, 2 Oct 2023 23:35:45 -0400 Subject: [PATCH 95/96] Pinning numpy<=1.23.1 seems to resolve SRM issues. - Numpy deprecate np.bool, this causes theano to error on first import. Then subsequent imports fail with different error. - Also, FastSRM fails with newer numpy as well for unrelated reason. np.array doesn't support automatically handle ragged arrays (dtype=object) in new numpy. These need to be made explicitly now. I tried adding making them dtype object explicitly but this was causing failures later during SVD. Need to look into this more. --- .conda/meta.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index a8ea32e0..ece47237 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -47,7 +47,7 @@ requirements: run: - python - - {{ pin_compatible('numpy') }} + - numpy<=1.23.1 - mpich - llvm-openmp - tensorflow From e51f057be6c4f6c2642eef110f167bce70e7194e Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Tue, 3 Oct 2023 01:07:17 -0400 Subject: [PATCH 96/96] Fix the numpy pin --- .conda/meta.yaml | 2 +- setup.cfg | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.conda/meta.yaml b/.conda/meta.yaml index ece47237..212234b2 100644 --- a/.conda/meta.yaml +++ b/.conda/meta.yaml @@ -42,7 +42,7 @@ requirements: - pybind11>=2.9.0 - scipy!=1.0.0 - cython - - {{ pin_compatible('numpy') }} + - numpy<=1.23.1 - setuptools_scm run: diff --git a/setup.cfg b/setup.cfg index 7290452d..15c732f5 100644 --- a/setup.cfg +++ b/setup.cfg @@ -54,7 +54,7 @@ project_urls = [options] packages = find: install_requires = - numpy>=1.13.3 + numpy<=1.23.1 # https://travis-ci.org/brainiak/brainiak/jobs/545838666 mpi4py>=3