From 3528e932b25624cfcd326afcbc6aca089a7bd1ed Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 14:47:57 +0100 Subject: [PATCH 001/112] Updating to include a small rust library --- Cargo.toml | 11 +++++++++++ pyproject.toml | 11 +++++++++-- src/lib.rs | 13 +++++++++++++ 3 files changed, 33 insertions(+), 2 deletions(-) create mode 100644 Cargo.toml create mode 100644 src/lib.rs diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 000000000..ad639a5b7 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "tiatoolbox" +version = "0.1.0" +edition = "2024" + +[lib] +name = "miscrust" +crate-type = ["cdylib"] + +[dependencies] +pyo3 = "0.29.2" diff --git a/pyproject.toml b/pyproject.toml index 18418da02..294e0dc74 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,6 +36,7 @@ dependencies = [ "opencv-python>=4.6.0", "openslide-bin>=4.0.0.2", "openslide-python>=1.4.0", + "maturin>=1.14.1", "pandas>=2.0.0", "pillow>=9.3.0", "pydicom>=2.3.1", @@ -59,6 +60,7 @@ dependencies = [ "zarr>=3.2.1", ] + [project.optional-dependencies] docs = [ "furo>=2022.12.7", @@ -132,8 +134,8 @@ torchvision = [ omit = ['tests/*', 'tiatoolbox/__main__.py', '*/utils/env_detection.py', 'tiatoolbox/typing.py'] [build-system] - requires = ["setuptools"] - build-backend = "setuptools.build_meta" + requires = ["maturin>=1.5,<2.0", "setuptools"] + build-backend = "maturin" [tool.distutils.bdist_wheel] universal = true @@ -297,3 +299,8 @@ ignore_missing_imports = true # Default local target: minimum supported Python (requires-python lower bound). # CI overrides this per job with --python-version for 3.12-3.14. python_version = "3.12" + +[tool.maturin] +python-source = "." +include = ["tiatoolbox/**/*"] +module-name = "tiatoolbox.miscrust" diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 000000000..5ae54c80d --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,13 @@ +use pyo3::prelude::*; + +#[pyfunction] +fn add(a: i32, b: i32) -> i32 { + a + b +} + +#[pymodule] +fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { + m.add_function(wrap_pyfunction!(add, m)?)?; + + Ok(()) +} From 83a6126d760c5a738eef919334d40b817c8159d5 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 16:27:25 +0100 Subject: [PATCH 002/112] Editing so that rust code is now stored under tiatoolbox/rust-library --- Cargo.toml | 2 ++ {src => tiatoolbox/rust-library}/lib.rs | 0 2 files changed, 2 insertions(+) rename {src => tiatoolbox/rust-library}/lib.rs (100%) diff --git a/Cargo.toml b/Cargo.toml index ad639a5b7..a5d6d7317 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,8 +2,10 @@ name = "tiatoolbox" version = "0.1.0" edition = "2024" +autolib = false [lib] +path = "tiatoolbox/rust-library/lib.rs" name = "miscrust" crate-type = ["cdylib"] diff --git a/src/lib.rs b/tiatoolbox/rust-library/lib.rs similarity index 100% rename from src/lib.rs rename to tiatoolbox/rust-library/lib.rs From 13c5bb810ac20ec51a15b168dd7cc751874fb492 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 16:52:50 +0100 Subject: [PATCH 003/112] Altering contrast_enhancer to use rust --- Cargo.toml | 2 + tiatoolbox/rust-library/lib.rs | 67 ++++++++++++++++++++++++++++++++++ tiatoolbox/utils/misc.py | 7 +++- 3 files changed, 75 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index a5d6d7317..c8f618d0f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,4 +10,6 @@ name = "miscrust" crate-type = ["cdylib"] [dependencies] +ndarray = "0.17.2" +numpy = "0.29.0" pyo3 = "0.29.2" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 5ae54c80d..9b2cb669e 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -1,13 +1,80 @@ use pyo3::prelude::*; +use ndarray::{Array1, Array3}; +use numpy::{IntoPyArray, PyArray3, PyReadonlyArray3}; #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b } +fn rescale_intensity(x: f32, in_range_low: f32, in_range_high: f32, range: f32) -> u8{ + //asssumes out_min = 0 and out_max = 255 + if x <= in_range_low { + 0 + } else if x >= in_range_high { + 255 + } else { + (255.0 * ((x-in_range_low)/range)) as u8 + } +} + +fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 { + /*Get tissue mask based on the luminosity of the input image. + + Args: + img: Array + Input image used to obtain tissue mask. + threshold (float): + Luminosity threshold used to determine tissue area. + + Returns: + tissue_mask + Binary tissue mask. + + */ + let img_out = img.to_owned(); + let len = img.len(); + let mut flat_img_out: Array1 = img_out.into_shape_with_order(len, ).unwrap(); + + if let Some(slice) = flat_img_out.as_slice_mut() { + slice.sort_unstable(); + } + + let lenf32: f32 = len as f32; + + let p_low_index: f32 = (lenf32 - 1.0) * low_p as f32 / 100.0; + let p_low_index_difference = p_low_index - p_low_index.floor(); + let mut p_low = (1.0 - p_low_index_difference) * flat_img_out[p_low_index.floor() as usize] as f32 + + p_low_index_difference * flat_img_out[p_low_index.ceil() as usize] as f32; + + let p_high_index: f32 = (lenf32 - 1.0) * high_p as f32 / 100.0; + let p_high_index_difference = p_high_index - p_high_index.floor(); + let mut p_high = (1.0 - p_high_index_difference) * flat_img_out[p_high_index.floor() as usize] as f32 + + p_high_index_difference * flat_img_out[p_high_index.ceil() as usize] as f32; + + if p_low >= p_high { + p_low = flat_img_out[0].into(); + p_high = flat_img_out[len - 1].into(); + } + + if p_high > p_low { + let range = p_high - p_low ; + return img.mapv(|x| rescale_intensity(x.into(), p_low, p_high, range)); + } + + return img +} + +#[pyfunction] +fn contrast_enhancer<'py>(py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p: u8, high_p: u8) -> Bound<'py, PyArray3> { + let data = img.as_array().to_owned(); + rust_contrast_enhancer(data, low_p, high_p).into_pyarray(py) +} + #[pymodule] fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; + m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; Ok(()) } diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 6c8002ed5..763b40b8c 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -31,7 +31,7 @@ from tqdm.auto import tqdm, trange from tqdm.dask import TqdmCallback -from tiatoolbox import logger +from tiatoolbox import logger, miscrust from tiatoolbox.annotation.storage import Annotation, AnnotationStore, SQLiteStore from tiatoolbox.utils.exceptions import FileNotSupportedError @@ -427,9 +427,14 @@ def contrast_enhancer(img: np.ndarray, low_p: int = 2, high_p: int = 98) -> np.n """ # check if image is not uint8 + # check if image is not uint8 + dimension_for_rust = 3 + if img.dtype != np.uint8: msg = "Image should be uint8." raise AssertionError(msg) + if img.ndim == dimension_for_rust: + return miscrust.contrast_enhancer(img, low_p, high_p) img_out = img.copy() percentiles = np.array(np.percentile(img_out, (low_p, high_p))) p_low, p_high = percentiles[0], percentiles[1] From f566c81d5958dd0b800ecfa99bd1b0c4fa3f83ab Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 17:03:31 +0100 Subject: [PATCH 004/112] Update patch_predictions_as_qupath_json to use rust code --- tiatoolbox/rust-library/lib.rs | 56 ++++++++++++++++++++++++++++++++-- tiatoolbox/utils/misc.py | 31 +++---------------- 2 files changed, 58 insertions(+), 29 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 9b2cb669e..7b35f16fb 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -1,12 +1,64 @@ use pyo3::prelude::*; use ndarray::{Array1, Array3}; -use numpy::{IntoPyArray, PyArray3, PyReadonlyArray3}; +use numpy::{IntoPyArray, PyArray3, PyReadonlyArray2, PyReadonlyArray3}; +use pyo3::types::{PyList, PyDict}; +use std::collections::HashMap; #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b } +#[pyfunction] +fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, + class_colours: HashMap>, + preds: Vec, + class_dict: HashMap, + py_patch_coords: PyReadonlyArray2<'py, f64>) + -> PyResult> { + /*Helper function to generate QuPath JSON per patch predictions.*/ + + let features = PyList::empty(py); + let patch_coords = py_patch_coords.as_array(); + for i in 0..patch_coords.nrows() { + let class_idx = preds[i]; + let class_name = &class_dict[&class_idx]; + let xmin = patch_coords[[i, 0]]; + let ymin = patch_coords[[i, 1]]; + let xmax = patch_coords[[i, 2]]; + let ymax = patch_coords[[i, 3]]; + let polygon_feat = PyDict::new(py); + polygon_feat.set_item("type", "Polygon")?; + polygon_feat.set_item( + "coordinates", + vec![vec![ + [xmin, ymin], + [xmin, ymax], + [xmax, ymax], + [xmax, ymin], + [xmin, ymin], + ]], + )?; + let feature = PyDict::new(py); + feature.set_item("type", "Feature")?; + feature.set_item("id", format!("patch_{}", i))?; + feature.set_item("geometry", polygon_feat)?; + let classification = PyDict::new(py); + classification.set_item("name", class_name)?; + classification.set_item("color", class_colours[&class_idx].clone())?; + let properties = PyDict::new(py); + properties.set_item("classification", classification)?; + feature.set_item("properties", properties)?; + feature.set_item("objectType", "annotation")?; + feature.set_item("name", class_name)?; + feature.set_item("class_value", class_idx)?; + features.append(feature)?; + } + + Ok(features.unbind()) +} + + fn rescale_intensity(x: f32, in_range_low: f32, in_range_high: f32, range: f32) -> u8{ //asssumes out_min = 0 and out_max = 255 if x <= in_range_low { @@ -75,6 +127,6 @@ fn contrast_enhancer<'py>(py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; - + m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; Ok(()) } diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 763b40b8c..8667a7faa 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1267,8 +1267,6 @@ def patch_predictions_as_qupath_json( verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" - features = [] - # pick a color for each class based on the class index, using a colormap num_classes = len(class_dict) cmap = plt.colormaps["tab20"].resampled(num_classes) class_colours = { @@ -1280,36 +1278,15 @@ def patch_predictions_as_qupath_json( for class_idx in class_dict } - tqdm_loop = tqdm( + tqdm( range(np.asarray(patch_coords).shape[0]), leave=False, desc="Converting outputs to QuPath JSON.", disable=not verbose, ) - - for i in tqdm_loop: - class_idx = int(preds[i]) - class_name = class_dict[class_idx] - polygon_geo = Polygon.from_bounds(*patch_coords[i]) - polygon_feat = mapping(polygon_geo) - - feature = { - "type": "Feature", - "id": f"patch_{i}", - "geometry": polygon_feat, - "properties": { - "classification": { - "name": class_name, - "color": class_colours[class_idx], - } - }, - "objectType": "annotation", - "name": class_name, - "class_value": class_idx, - } - - features.append(feature) - + features = miscrust.patch_predictions_as_qupath_json( + class_colours, preds, class_dict, patch_coords + ) return {"type": "FeatureCollection", "features": features} From 440709df0ec98f8e1623cc7dbb1a575b207b296f Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 17:13:32 +0100 Subject: [PATCH 005/112] Editing patch_predictions_as_annotations to use rust code --- tiatoolbox/rust-library/lib.rs | 45 ++++++++++++++++++++++++++++++++++ tiatoolbox/utils/misc.py | 29 +++++++++------------- 2 files changed, 57 insertions(+), 17 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 7b35f16fb..ddfd22b1f 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -9,6 +9,50 @@ fn add(a: i32, b: i32) -> i32 { a + b } +#[pyfunction] +fn patch_predictions_as_annotations<'py>( + py: Python<'_>, + annotation_class: &Bound<'_, PyAny>, + polygon_class: &Bound<'_, PyAny>, + preds: Vec, + keys: Vec, + class_dict: HashMap, + py_class_probs: PyReadonlyArray2<'py, f64>, + py_patch_coords: PyReadonlyArray2<'py, f64>, + classes_predicted: Vec, + labels: Vec + ) -> PyResult>>{ + /*Helper function to generate annotation per patch predictions.*/ + let class_probs = py_class_probs.as_array(); + let patch_coords = py_patch_coords.as_array(); + let mut annotations: Vec> = Vec::with_capacity(patch_coords.nrows()); + let preds_len = preds.len(); + let keys_contains_labels = keys.contains(&"labels".to_string()); + for i in 0..patch_coords.nrows() { + let props = PyDict::new(py); + if keys.contains(&"probabilities".to_string()) { + for j in &classes_predicted { + props.set_item(format!("prob_{}", class_dict[&j]), class_probs[[i, *j as usize]])?; + } + } + if keys_contains_labels { + props.set_item("label".to_string(), class_dict[&labels[i]].clone())?; + } + if preds_len > 0 { + props.set_item("type".to_string(), class_dict[&preds[i]].clone())?; + } + annotations.push(annotation_class.call1(( + polygon_class.call_method1("from_bounds", ( + patch_coords[[i, 0]], + patch_coords[[i, 1]], + patch_coords[[i, 2]], + patch_coords[[i, 3]] + ))?, + props))?.unbind()); + } + Ok(annotations) +} + #[pyfunction] fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, class_colours: HashMap>, @@ -128,5 +172,6 @@ fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; + m.add_function(wrap_pyfunction!(patch_predictions_as_annotations, m)?)?; Ok(()) } diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 8667a7faa..63ed7b09d 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1235,28 +1235,23 @@ def patch_predictions_as_annotations( verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" - annotations = [] - tqdm_loop = tqdm( + tqdm( patch_coords, leave=False, desc="Converting outputs to AnnotationStore.", disable=not verbose, ) - - for i, _ in enumerate(tqdm_loop): - if "probabilities" in keys: - props = { - f"prob_{class_dict[j]}": class_probs[i][j] for j in classes_predicted - } - else: - props = {} - if "labels" in keys: - props["label"] = class_dict[labels[i]] - if len(preds) > 0: - props["type"] = class_dict[preds[i]] - annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props)) - - return annotations + return miscrust.patch_predictions_as_annotations( + Annotation, + Polygon, + preds, + keys, + class_dict, + class_probs, + patch_coords, + classes_predicted, + labels, + ) def patch_predictions_as_qupath_json( From b1914f39032ce9bf6453564905978877346fe03d Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 17:23:31 +0100 Subject: [PATCH 006/112] In rust created library equilviant to json.dump --- Cargo.toml | 2 ++ tiatoolbox/rust-library/lib.rs | 19 +++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index c8f618d0f..65cdc62ad 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,3 +13,5 @@ crate-type = ["cdylib"] ndarray = "0.17.2" numpy = "0.29.0" pyo3 = "0.29.2" +pythonize = "0.29.0" +serde_json = "1.0.151" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index ddfd22b1f..45c1f2632 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -3,12 +3,30 @@ use ndarray::{Array1, Array3}; use numpy::{IntoPyArray, PyArray3, PyReadonlyArray2, PyReadonlyArray3}; use pyo3::types::{PyList, PyDict}; use std::collections::HashMap; +use pythonize::depythonize; +use serde_json::Value; #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b } +#[pyfunction] +fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResult<()> { + //Equilivent to json.dump(obj, save_path) + let value: Value = depythonize(obj) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + + let file = std::fs::File::create(&save_path) + .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))?; + let mut writer = std::io::BufWriter::new(file); + + serde_json::to_writer(&mut writer, &value) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + + Ok(()) +} + #[pyfunction] fn patch_predictions_as_annotations<'py>( py: Python<'_>, @@ -173,5 +191,6 @@ fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_annotations, m)?)?; + m.add_function(wrap_pyfunction!(json_dump_python_object, m)?)?; Ok(()) } From 1c3dd8407cc7fd528c4f8dd9d4898b81613ce6bc Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 19 Aug 2026 20:45:11 +0100 Subject: [PATCH 007/112] Updated patch predictions as annotations to have preds of type f64 --- tiatoolbox/rust-library/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 45c1f2632..dfc2eed52 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -32,13 +32,13 @@ fn patch_predictions_as_annotations<'py>( py: Python<'_>, annotation_class: &Bound<'_, PyAny>, polygon_class: &Bound<'_, PyAny>, - preds: Vec, + preds: Vec, keys: Vec, - class_dict: HashMap, + class_dict: HashMap, py_class_probs: PyReadonlyArray2<'py, f64>, py_patch_coords: PyReadonlyArray2<'py, f64>, classes_predicted: Vec, - labels: Vec + labels: Vec ) -> PyResult>>{ /*Helper function to generate annotation per patch predictions.*/ let class_probs = py_class_probs.as_array(); From ca5e25b00004dadae91e6407b0d335d48476a51a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 11:32:15 +0100 Subject: [PATCH 008/112] Corrected types on patch_predictions_as_annotations --- Cargo.toml | 1 + tiatoolbox/rust-library/lib.rs | 18 ++++++++++++++---- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 65cdc62ad..2c5fee497 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,7 @@ crate-type = ["cdylib"] [dependencies] ndarray = "0.17.2" numpy = "0.29.0" +ordered-float = "5.3.0" pyo3 = "0.29.2" pythonize = "0.29.0" serde_json = "1.0.151" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index dfc2eed52..0ed4e6d37 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -5,6 +5,7 @@ use pyo3::types::{PyList, PyDict}; use std::collections::HashMap; use pythonize::depythonize; use serde_json::Value; +use ordered_float::OrderedFloat; #[pyfunction] fn add(a: i32, b: i32) -> i32 { @@ -34,13 +35,22 @@ fn patch_predictions_as_annotations<'py>( polygon_class: &Bound<'_, PyAny>, preds: Vec, keys: Vec, - class_dict: HashMap, + class_dict: &Bound<'_, PyDict>, py_class_probs: PyReadonlyArray2<'py, f64>, py_patch_coords: PyReadonlyArray2<'py, f64>, classes_predicted: Vec, labels: Vec ) -> PyResult>>{ /*Helper function to generate annotation per patch predictions.*/ + let class_dict: HashMap, String> = class_dict + .iter() + .map(|(key, value)| { + let key: f64 = key.extract()?; + let value: String = value.extract()?; + + Ok((OrderedFloat(key), value)) + }) + .collect::>()?; let class_probs = py_class_probs.as_array(); let patch_coords = py_patch_coords.as_array(); let mut annotations: Vec> = Vec::with_capacity(patch_coords.nrows()); @@ -50,14 +60,14 @@ fn patch_predictions_as_annotations<'py>( let props = PyDict::new(py); if keys.contains(&"probabilities".to_string()) { for j in &classes_predicted { - props.set_item(format!("prob_{}", class_dict[&j]), class_probs[[i, *j as usize]])?; + props.set_item(format!("prob_{}", class_dict[&OrderedFloat(*j as f64)]), class_probs[[i, *j as usize]])?; } } if keys_contains_labels { - props.set_item("label".to_string(), class_dict[&labels[i]].clone())?; + props.set_item("label".to_string(), class_dict[&OrderedFloat(labels[i])].clone())?; } if preds_len > 0 { - props.set_item("type".to_string(), class_dict[&preds[i]].clone())?; + props.set_item("type".to_string(), class_dict[&OrderedFloat(preds[i])].clone())?; } annotations.push(annotation_class.call1(( polygon_class.call_method1("from_bounds", ( From 4bc7c1fff89546afaa4c64c8fc1c10c58968c1d4 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 12:02:22 +0100 Subject: [PATCH 009/112] Corrected types on patch-predictions-as-qupath-json --- tiatoolbox/rust-library/lib.rs | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 0ed4e6d37..331b7eb93 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -83,18 +83,35 @@ fn patch_predictions_as_annotations<'py>( #[pyfunction] fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, - class_colours: HashMap>, - preds: Vec, - class_dict: HashMap, + class_colours: &Bound<'_, PyDict>, + preds: Vec, + class_dict: &Bound<'_, PyDict>, py_patch_coords: PyReadonlyArray2<'py, f64>) -> PyResult> { /*Helper function to generate QuPath JSON per patch predictions.*/ + let class_colours: HashMap, Vec> = class_colours + .iter() + .map(|(key, value)| { + let key: f64 = key.extract()?; + let value: Vec = value.extract()?; + Ok((OrderedFloat(key), value)) + }) + .collect::>()?; + let class_dict: HashMap, String> = class_dict + .iter() + .map(|(key, value)| { + let key: f64 = key.extract()?; + let value: String = value.extract()?; + + Ok((OrderedFloat(key), value)) + }) + .collect::>()?; let features = PyList::empty(py); let patch_coords = py_patch_coords.as_array(); for i in 0..patch_coords.nrows() { let class_idx = preds[i]; - let class_name = &class_dict[&class_idx]; + let class_name = &class_dict[&OrderedFloat(class_idx)]; let xmin = patch_coords[[i, 0]]; let ymin = patch_coords[[i, 1]]; let xmax = patch_coords[[i, 2]]; @@ -117,7 +134,7 @@ fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, feature.set_item("geometry", polygon_feat)?; let classification = PyDict::new(py); classification.set_item("name", class_name)?; - classification.set_item("color", class_colours[&class_idx].clone())?; + classification.set_item("color", class_colours[&OrderedFloat(class_idx)].clone())?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; From d92f50127c41b5ef60b94c56244f27d3891bb6ad Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 12:32:37 +0100 Subject: [PATCH 010/112] Corrected misc.py for types --- tiatoolbox/utils/misc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 63ed7b09d..bfe6e34bb 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1247,8 +1247,8 @@ def patch_predictions_as_annotations( preds, keys, class_dict, - class_probs, - patch_coords, + np.array(class_probs).astype("float"), + np.array(patch_coords).astype("float"), classes_predicted, labels, ) @@ -1280,7 +1280,7 @@ def patch_predictions_as_qupath_json( disable=not verbose, ) features = miscrust.patch_predictions_as_qupath_json( - class_colours, preds, class_dict, patch_coords + class_colours, preds, class_dict, np.array(patch_coords) ) return {"type": "FeatureCollection", "features": features} From 79723936eefd5dd1bae2cdae7b088f6a53b77f0c Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 12:42:22 +0100 Subject: [PATCH 011/112] Corrected misc.py for types --- tiatoolbox/utils/misc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index bfe6e34bb..c7ce7420b 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1280,7 +1280,7 @@ def patch_predictions_as_qupath_json( disable=not verbose, ) features = miscrust.patch_predictions_as_qupath_json( - class_colours, preds, class_dict, np.array(patch_coords) + class_colours, preds, class_dict, np.array(patch_coords).astype("float") ) return {"type": "FeatureCollection", "features": features} From 73a8b0b1b8e6da2879b02160eafc18ab52c3f6fd Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 14:13:45 +0100 Subject: [PATCH 012/112] Updated patch_predictions_as_annotations --- tiatoolbox/rust-library/lib.rs | 48 ++++++++++++++++++++++++++-------- tiatoolbox/utils/misc.py | 7 ++++- 2 files changed, 43 insertions(+), 12 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 331b7eb93..1d5cec8eb 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -6,7 +6,13 @@ use std::collections::HashMap; use pythonize::depythonize; use serde_json::Value; use ordered_float::OrderedFloat; +use pyo3::FromPyObject; +#[derive(FromPyObject)] +enum StringOrFloat { + String(String), + Float(f64), +} #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b @@ -34,20 +40,20 @@ fn patch_predictions_as_annotations<'py>( annotation_class: &Bound<'_, PyAny>, polygon_class: &Bound<'_, PyAny>, preds: Vec, - keys: Vec, + keys_contains_labels: bool, + keys_contains_probabilities: bool, class_dict: &Bound<'_, PyDict>, py_class_probs: PyReadonlyArray2<'py, f64>, py_patch_coords: PyReadonlyArray2<'py, f64>, - classes_predicted: Vec, + classes_predicted: Vec, labels: Vec ) -> PyResult>>{ /*Helper function to generate annotation per patch predictions.*/ - let class_dict: HashMap, String> = class_dict + let class_dict: HashMap, StringOrFloat> = class_dict .iter() .map(|(key, value)| { let key: f64 = key.extract()?; - let value: String = value.extract()?; - + let value: StringOrFloat = value.extract()?; Ok((OrderedFloat(key), value)) }) .collect::>()?; @@ -55,19 +61,39 @@ fn patch_predictions_as_annotations<'py>( let patch_coords = py_patch_coords.as_array(); let mut annotations: Vec> = Vec::with_capacity(patch_coords.nrows()); let preds_len = preds.len(); - let keys_contains_labels = keys.contains(&"labels".to_string()); for i in 0..patch_coords.nrows() { let props = PyDict::new(py); - if keys.contains(&"probabilities".to_string()) { + if keys_contains_probabilities { for j in &classes_predicted { - props.set_item(format!("prob_{}", class_dict[&OrderedFloat(*j as f64)]), class_probs[[i, *j as usize]])?; + let y = &class_dict[&OrderedFloat(*j as f64)]; + let probability = match y { + StringOrFloat::String(s) => s.clone(), + StringOrFloat::Float(i) => i.to_string(), + }; + props.set_item(format!("prob_{}", probability), class_probs[[i, *j as usize]])?; } } if keys_contains_labels { - props.set_item("label".to_string(), class_dict[&OrderedFloat(labels[i])].clone())?; + let y = &class_dict[&OrderedFloat(labels[i])]; + match y { + StringOrFloat::String(s) => { + props.set_item("label".to_string(), s)?; + } + StringOrFloat::Float(i) => { + props.set_item("label".to_string(), *i)?; + } + } } if preds_len > 0 { - props.set_item("type".to_string(), class_dict[&OrderedFloat(preds[i])].clone())?; + let y = &class_dict[&OrderedFloat(preds[i])]; + match y { + StringOrFloat::String(s) => { + props.set_item("type".to_string(), s)?; + } + StringOrFloat::Float(i) => { + props.set_item("type".to_string(), *i)?; + } + } } annotations.push(annotation_class.call1(( polygon_class.call_method1("from_bounds", ( @@ -102,7 +128,7 @@ fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, .iter() .map(|(key, value)| { let key: f64 = key.extract()?; - let value: String = value.extract()?; + let value: String = value.extract::()?; Ok((OrderedFloat(key), value)) }) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index c7ce7420b..4a24759f9 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1241,11 +1241,16 @@ def patch_predictions_as_annotations( desc="Converting outputs to AnnotationStore.", disable=not verbose, ) + if len(class_probs) == 0: + class_probs = np.empty((0, 2)) + if len(patch_coords) == 0: + patch_coords = np.empty((0, 2)) return miscrust.patch_predictions_as_annotations( Annotation, Polygon, preds, - keys, + "labels" in keys, + "probabilities" in keys, class_dict, np.array(class_probs).astype("float"), np.array(patch_coords).astype("float"), From 9c0bc6365e341cb67e4daf855caef041c4068671 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 18:08:40 +0100 Subject: [PATCH 013/112] Added benchmarking --- benchmarks/implementing_misc_in_rust.ipynb | 660 +++++++++++++++++++++ 1 file changed, 660 insertions(+) create mode 100644 benchmarks/implementing_misc_in_rust.ipynb diff --git a/benchmarks/implementing_misc_in_rust.ipynb b/benchmarks/implementing_misc_in_rust.ipynb new file mode 100644 index 000000000..64ba344c7 --- /dev/null +++ b/benchmarks/implementing_misc_in_rust.ipynb @@ -0,0 +1,660 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "aqPkpRk-pT5q" + }, + "source": [ + "# Benchmarking Misc in Rust\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 1: Contrast Enhancer\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from skimage import exposure\n", + "\n", + "from tiatoolbox import rust_misc\n", + "\n", + "\n", + "def rust_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " # check if image is not uint8\n", + " dimension_for_rust = 3\n", + "\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " if img.ndim == dimension_for_rust:\n", + " return rust_misc.contrast_enhancer(img, low_p, high_p)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def py_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "DZBiw_EepT5x" + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 1\n", + "maxarraysize = 10000\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng()\n", + " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", + " start_time = time.time()\n", + " py_contrast_enhancer(temp, 2, 96)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_contrast_enhancer(temp, 2, 96)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(i)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()\n", + "plt.loglog(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 2: Patch Predictions As Annotations\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely.geometry import Polygon\n", + "from tqdm.auto import tqdm\n", + "\n", + "from tiatoolbox.annotation.storage import Annotation\n", + "\n", + "\n", + "def py_patch_predictions_as_annotations(\n", + " preds: list | np.ndarray,\n", + " keys: list,\n", + " class_dict: dict,\n", + " class_probs: list | np.ndarray,\n", + " patch_coords: list | np.ndarray,\n", + " classes_predicted: list,\n", + " labels: list,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> list:\n", + " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", + " annotations = []\n", + " tqdm_loop = tqdm(\n", + " patch_coords,\n", + " leave=False,\n", + " desc=\"Converting outputs to AnnotationStore.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for i, _ in enumerate(tqdm_loop):\n", + " if \"probabilities\" in keys:\n", + " props = {\n", + " f\"prob_{class_dict[j]}\": class_probs[i][j] for j in classes_predicted\n", + " }\n", + " else:\n", + " props = {}\n", + " if \"labels\" in keys:\n", + " props[\"label\"] = class_dict[labels[i]]\n", + " if len(preds) > 0:\n", + " props[\"type\"] = class_dict[preds[i]]\n", + " annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props))\n", + "\n", + " return annotations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rust_patch_predictions_as_annotations(\n", + " preds: list | np.ndarray,\n", + " keys: list,\n", + " class_dict: dict,\n", + " class_probs: list | np.ndarray,\n", + " patch_coords: list | np.ndarray,\n", + " classes_predicted: list,\n", + " labels: list,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> list:\n", + " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", + " tqdm(\n", + " patch_coords,\n", + " leave=False,\n", + " desc=\"Converting outputs to AnnotationStore.\",\n", + " disable=not verbose,\n", + " )\n", + " if len(class_probs) == 0:\n", + " class_probs = np.empty((0, 2))\n", + " if len(patch_coords) == 0:\n", + " patch_coords = np.empty((0, 2))\n", + " return rust_misc.patch_predictions_as_annotations(\n", + " Annotation,\n", + " Polygon,\n", + " preds,\n", + " \"labels\" in keys,\n", + " \"probabilities\" in keys,\n", + " class_dict,\n", + " np.array(class_probs).astype(\"float\"),\n", + " np.array(patch_coords).astype(\"float\"),\n", + " classes_predicted,\n", + " labels,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "num_patches = 1\n", + "num_classes = 1\n", + "max_patches = 1000\n", + "while num_patches <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng(42)\n", + " class_probs = rng.random(\n", + " (num_patches, num_classes),\n", + " dtype=np.float64,\n", + " )\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", + " labels = (\n", + " rng.integers(0, num_classes, size=num_patches).astype(np.int32).tolist()\n", + " )\n", + " x = np.arange(num_patches, dtype=np.float64) * 10\n", + " y = np.zeros(num_patches, dtype=np.float64)\n", + " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", + " keys = [\"predictions\", \"probabilities\", \"labels\"]\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + " classes_predicted = list(range(num_classes))\n", + " verbose: bool = False\n", + " start_time = time.time()\n", + " py_patch_predictions_as_annotations(\n", + " preds,\n", + " keys,\n", + " class_dict,\n", + " class_probs,\n", + " patch_coords,\n", + " classes_predicted,\n", + " labels,\n", + " verbose=False,\n", + " )\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_patch_predictions_as_annotations(\n", + " preds,\n", + " keys,\n", + " class_dict,\n", + " class_probs,\n", + " patch_coords,\n", + " classes_predicted,\n", + " labels,\n", + " verbose=False,\n", + " )\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(num_patches)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " num_patches *= 10\n", + " num_classes *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()\n", + "plt.loglog(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 3: Patch Predictions As QuPath\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from shapely.geometry import mapping\n", + "\n", + "\n", + "def py_patch_predictions_as_qupath_json(\n", + " preds: list | np.ndarray,\n", + " class_dict: dict,\n", + " patch_coords: list | np.ndarray,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> dict:\n", + " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", + " features = []\n", + " # pick a color for each class based on the class index, using a colormap\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " tqdm_loop = tqdm(\n", + " range(np.asarray(patch_coords).shape[0]),\n", + " leave=False,\n", + " desc=\"Converting outputs to QuPath JSON.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for i in tqdm_loop:\n", + " class_idx = int(preds[i])\n", + " class_name = class_dict[class_idx]\n", + " polygon_geo = Polygon.from_bounds(*patch_coords[i])\n", + " polygon_feat = mapping(polygon_geo)\n", + "\n", + " feature = {\n", + " \"type\": \"Feature\",\n", + " \"id\": f\"patch_{i}\",\n", + " \"geometry\": polygon_feat,\n", + " \"properties\": {\n", + " \"classification\": {\n", + " \"name\": class_name,\n", + " \"color\": class_colours[class_idx],\n", + " }\n", + " },\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_name,\n", + " \"class_value\": class_idx,\n", + " }\n", + "\n", + " features.append(feature)\n", + "\n", + " return {\"type\": \"FeatureCollection\", \"features\": features}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rust_patch_predictions_as_qupath_json(\n", + " preds: list | np.ndarray,\n", + " class_dict: dict,\n", + " patch_coords: list | np.ndarray,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> dict:\n", + " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " tqdm(\n", + " range(np.asarray(patch_coords).shape[0]),\n", + " leave=False,\n", + " desc=\"Converting outputs to QuPath JSON.\",\n", + " disable=not verbose,\n", + " )\n", + " features = rust_misc.patch_predictions_as_qupath_json(\n", + " class_colours, preds, class_dict, np.array(patch_coords).astype(\"float\")\n", + " )\n", + " return {\"type\": \"FeatureCollection\", \"features\": features}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "num_patches = 1\n", + "num_classes = 1\n", + "max_patches = 1000\n", + "while num_patches <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng(42)\n", + " class_probs = rng.random(\n", + " (num_patches, num_classes),\n", + " dtype=np.float64,\n", + " )\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", + " x = np.arange(num_patches, dtype=np.float64) * 10\n", + " y = np.zeros(num_patches, dtype=np.float64)\n", + " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + " classes_predicted = list(range(num_classes))\n", + " verbose: bool = False\n", + " start_time = time.time()\n", + " py_patch_predictions_as_qupath_json(\n", + " preds,\n", + " class_dict,\n", + " patch_coords,\n", + " verbose=False,\n", + " )\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_patch_predictions_as_qupath_json(\n", + " preds,\n", + " class_dict,\n", + " patch_coords,\n", + " verbose=False,\n", + " )\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(num_patches)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " num_patches *= 10\n", + " num_classes *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()\n", + "plt.loglog(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 4: Json.dump\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import time\n", + "from pathlib import Path\n", + "\n", + "example_dict = {}\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 1\n", + "maxarraysize = 10000\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for j in range(len(example_dict), i):\n", + " example_dict[str(j)] = 1\n", + " for _j in range(10):\n", + " start_time = time.time()\n", + " with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", + " json.dump(example_dict, handle)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_misc.json_dump_python_object(\"example.txt\", example_dict)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(i)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of dictionary\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()\n", + "plt.loglog(sizeofarray, timings)\n", + "plt.xlabel(\"Size of dictionary\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "interpreter": { + "hash": "a3ed8fb525a8bde66cc7655a5df08d8d0f8699a69b9eb5ccab28dc0a7837eec6" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 6a805376b3e9daa1708bdf63a2432500425afe3e Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 18:17:12 +0100 Subject: [PATCH 014/112] Changed name from miscrust to rust-misc --- Cargo.toml | 2 +- benchmarks/implementing_misc_in_rust.ipynb | 116 ++++++++++++++++++--- pyproject.toml | 2 +- tiatoolbox/rust-library/lib.rs | 2 +- tiatoolbox/utils/misc.py | 8 +- 5 files changed, 107 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2c5fee497..d4b6c2bbf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ autolib = false [lib] path = "tiatoolbox/rust-library/lib.rs" -name = "miscrust" +name = "rust_misc" crate-type = ["cdylib"] [dependencies] diff --git a/benchmarks/implementing_misc_in_rust.ipynb b/benchmarks/implementing_misc_in_rust.ipynb index 64ba344c7..e677e41ed 100644 --- a/benchmarks/implementing_misc_in_rust.ipynb +++ b/benchmarks/implementing_misc_in_rust.ipynb @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "id": "DZBiw_EepT5x" }, @@ -166,9 +166,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbrlJREFUeJzt3XdcleX/x/HXYW9QcIu49wa3pmk722VpjoYjy5alaWVly7JllllpVtpQs8y2DfcWxL23ooKIstc55/79cX/jF7nAgBsO7+fjwaPu61z3OR+OjDf3+Fw2wzAMRERERFyEm9UFiIiIiBQlhRsRERFxKQo3IiIi4lIUbkRERMSlKNyIiIiIS1G4EREREZeicCMiIiIuReFGREREXIqH1QVYwel0cuzYMQIDA7HZbFaXIyIiIgVgGAapqalUr14dN7fzH58pl+Hm2LFjhIeHW12GiIiIXIIjR45Qs2bN8z5eLsNNYGAgYL45QUFBFlcjIiIiBZGSkkJ4eHje7/HzKZfh5u9TUUFBQQo3IiIiZczFLinRBcUiIiLiUhRuRERExKUo3IiIiIhLKZfX3BSE0+kkJyfH6jLKJU9PT9zd3a0uQ0REyiiFm3PIycnhwIEDOJ1Oq0spt0JCQqhatar6EImISKEp3PyLYRgcP34cd3d3wsPDL9gkSIqeYRhkZGSQkJAAQLVq1SyuSEREyhqFm3+x2+1kZGRQvXp1/Pz8rC6nXPL19QUgISGBypUr6xSViIgUig5L/IvD4QDAy8vL4krKt7+DZW5ursWViIhIWaNwcx661sNaev9FRORSKdzIeb399tt89913VpchIiJSKLrmxkV8+umnrFy5EjBvpQ4PD+eWW26hSZMmBdr/vffeo3Llytx55515Y7/88gtRUVHceuutxVKziIhIcdCRGxexdOlSli9fTseOHWnZsiVbt26lRYsWzJ8/v0D7L1y4kNWrVxdzlSIiIsVPR25cSLVq1Rg8eDAAw4cPJy0tjRdffBE/Pz+WLl3Kq6++mm/+l19+SVxcHJUqVWLz5s0cPHgwb/+XX345b96SJUv4888/cTgc3HHHHbRt2zbf82zdupU5c+aQlJREy5YtGThwYN4dT2Ce3qpduzYVK1a84POIiEjZt+HwaXafSOWu9rUsq0FHblxY8+bNOXLkCHXr1mXChAls3bo17zGn08nYsWPx8PCgXr16VKhQgWrVqtGxY0c6duyYF06++OILXnjhBUJDQzl16hQdO3Zkw4YNec/z66+/0rZtW44fP07t2rV5//336dq1a77uzr/88guPPPLIBZ9HRETKvnkxR7nrozU8PX8La/afsqwOHbm5CMMwyMx1WPLavp7ul3zXkMPh4K+//qJ58+Y0aNCAyy67jBkzZvD2228D8Mcff3DixAkGDBhApUqVCA8Pp379+nlHbv5WsWJF/vrrr7xeM3v37uXzzz+nbdu2GIbBI488wiOPPMKbb74JwJAhQ6hTpw4ff/wxI0aMKNDziIhI2WZ3OHnt151MX3EAgKuaVqF5jWDL6lG4uYjMXAdNn1toyWtvf/Fq/LwK/k+0a9cuBg8ejN1uZ82aNSQnJ/Pzzz8DZugYOXIkr7/+Op6ensyYMYPevXtTqVKlCz7n5Zdfnq+JXqNGjTh69CgAcXFx7N27l759++Y9HhISwvXXX8/SpUvzhZsLPY+IiJRdyZm5PPx1LMt2nwTgkZ71eeyKhri5WdfSQ6elXEhQUBAdO3bk8ssvZ8qUKezfvz/vyMjtt99Obm4uP/74I0lJSSxYsID77rvvos/5z2tnANzd3fMaHf69REJYWFi+OWFhYcTHxxf4eUREpGzadzKNW6asZNnuk/h4uvF+vzaMvKqRpcEGdOTmonw93dn+4tWWvXZh/POC4n/z8fGhf//+zJgxg7i4OCpWrMi1116b9/ilnP4KDw8H4NChQ0REROSNHzp0iFq1rLuQTEREit/iXQk88nUsqVl2qgf78PHAKEtPRf2Tws1F2Gy2Qp0aKs2GDBlC27Zt2bVrF4MGDcp3mqhixYokJSUV6vkqVarEZZddxrvvvkvXrl1xc3Njx44d/PLLL8yePbuoyxcRkVLAMAymLz/AhF934DQgKqICU/tHUinQ2+rS8rjGb20pkJYtW9KmTRuio6O599578z1200030b9/f3JycggICMh3K/iFfPDBB1x11VW0bduW+vXr8+eff9KvXz9uueWW4vgURETEQlm5Dp6ev4XvNsQBcGdUOC/e3Axvj9K1wLHCjYu47777SE1Nvei8Nm3a4OPjQ8OGDfON33rrrURHR7Np0ybS09Px9fXliSeeOOt6mrvvvpv09PS87WbNmrFnzx4WLVrE6dOnGTduHK1atcq3T0GeR0RESrf4lCyGzYph45EzuLvZGHd9EwZ1rl0q1wK0GYZhWF1ESUtJSSE4OJjk5GSCgoLyPZaVlcWBAweoU6cOPj4+FlVYPFJSUoiIiGDKlCn069fP6nIuyJX/HUREyppNR84wdFY08SnZBPt6MqVfW7o2CLv4jkXsQr+//0lHbsqJUaNG8ccff1C3bl369OljdTkiIlJGfB8bx+hvN5Njd9KgcgDTBkZRO8zf6rIuSOGmnGjbti3t27fn2muvxcND/+wiInJhDqfBxIU7+WjpfgB6Na7MpLtaE+jjaXFlF6ffcuXEPxvtiYiIXEhKVi6Pfh3L4l1mY74He9Tjiasa4W5x/5qCUrgRERGRPAcS0xn8+Xr2nUzH28ONibe35KbWNawuq1AUbkRERASA5XtO8tCXG0jJslM1yIePB0bSsmaI1WUVmsKNiIhIOWcYBp+uPMjLP2/HaUCbWiF81D+SykFl825VhRsREZFyLNvu4Nn5W/kmxlzM+PbImrx8c3N8CrkEUGmicCMiIlJOJaRm8cCsGDYcPoObDZ6+rgn3d61TKhvzFYal4SYjI4MPP/yQhQsXkpaWRrNmzXj88cdp0qTJefd56aWXmDNnTr6xBg0aMH/+/OIuV0RExGVsjUtmyMxojidnEejjwfv92tK9YSWryyoSloabIUOGUKdOHcaMGYOHhwcfffQRnTp1YuPGjdSuXfuc+8TFxVG9enXefvvtvDF1sIXo6GgOHjwIgKenJzVr1qRly5Z4ehZdP4K4uDhiYmK48cYbi+w5RUSk5P246Rij5m0iK9dJ3Ur+TB8YRd1KAVaXVWQsDTeffvopXl5eedudOnXC19eXxYsXn7Ww4z8FBQXRvHnzkiixzHj//ff5+eef6d69O3a7ndjYWDw8PPjhhx9o1qxZkbzG6tWrGTx4MGfOnCmS5xMRkZLldBq89ccupizeB0CPRpWY3LcNQWWgMV9hWBpu/hlsAH7//XcMwyAyMvKC+61evZr27dsTHBxMt27dePLJJ/Hz8yvOUsuEZs2aMW/ePABycnLo3Lkzjz76KH/++ScAe/fu5cCBA1x55ZV5+8THx7Ny5UpuvfXWvLGUlBQ2bNgAmJ2Ng4KCOHnyJGvWrCE3NzfvNRo3bqyQKSJSRqRl23ls9kb+3BEPwLDL6jL6msZlpjFfYVh+QfHKlSsZNmwYKSkppKam8sMPP9CyZcvzzg8KCmLEiBF0796duLg4nn/+eRYsWMCaNWvOewomOzub7OzsvO2UlJQi/zxKGy8vL6666iqmTZuWN/bTTz8xffp0tm7dmjcWGxtLnz59sNvtACxevJjbbruNRo0aERAQwL59+5g8eTJ16tRh5cqV5ObmMnv2bABuueUWhRsRkTLg0Kl0hsyMZnd8Gl4ebrx2awtubVvT6rKKjeXhplWrVsyePZvExESmTZvG/fffz4oVK6hXr94557/66qv51kZq37499evXZ86cOfTv3/+c+0yYMIHx48dfWoGGAbkZl7bvf+XpB//hivX9+/cTFla4VVsnTJjA/fffzxtvvAFAcnIya9eupVmzZjzxxBMMHjw478iNiIiUfqv2JvLgVxs4k5FL5UBvPh4YRevwEKvLKlaWh5uAgIC8v/67d+9OkyZNmDx5Mu++++455/970ceIiAgiIiLyHY34t7FjxzJy5Mi87ZSUFMLDwwtWYG4GvFq9YHOL2tPHwKvgK6+ePHmSefPmYbfbWbt2Ld999x2zZs0q1Et6e3tz6NAhMjMz8fX1JTg4mKuuuqqwlYuIiMUMw2DWmkOM/3E7DqdBq5rBfDwwiipltDFfYVgebv7JZrNRoUIFkpOTC7xPbm4uCQkJBAUFnXeOt7c33t7eRVFiqZaQkMDs2bPJzs5m1apVXHvttdxyyy2Feo6JEydy3333UalSJbp06ULv3r0ZMmSI7kgTESlDcuxOnv9hK1+vOwLALW1qMOHWFmW6MV9hWBZuMjMzmThxIk8++ST+/ubRia+++op169YxatSovHnPP/88mzdvZv78+eTk5PDSSy8xevRoAgMDyc7O5rHHHiMnJ4c77rijeAr19DOPoFjBs3AXSf/zguL4+HiioqIYM2ZM3m3zbm5uOJ3OfPtkZWXl227SpAmrV6/m+PHjLFq0iFdeeYWFCxfy008//YdPRERESkpiWjbDv4hh/cHT2Gww5prGDL2sbplvzFcYloWbv4+m1KlTh4CAAJKTk/Hz82Pq1Kn57tyJi4tjz549gNm/JSAggHr16uHv709CQgL169dn4cKFNGjQoHgKtdkKdWqotKhSpQpvvfUW/fr1Y8iQITRp0oQaNWoQFxdHdnZ23pGspUuX5tvv+PHjVKtWjWrVqnH33XfjdDp59NFHAfMU4j8vzBYRkdJl27Fkhs6MIe5MJoHeHkzu24bLG1e2uqwSZzMMw7CyAMMwOHz4MP7+/ue8+PXYsWNkZGRQv379s/apUKHCBU9HnU9KSgrBwcEkJyeftX9WVhYHDhygTp06ZepUzD333MPBgwdZsmRJvvH27dtTvXp1vv/+e1JSUmjQoAGdO3fmlltuITo6mrlz55KYmJh3t1SvXr0IDw+nS5cuOBwO3nnnHS677DKmTZtGXFwcderU4amnnqJVq1bFeit4Wf13EBGxyi9bjvPE3E1k5jqoE+bPtIFR1K/sOo354MK/v//JrQRrOiebzUZERMR57+qpXr16vmDzz30uJdi4qnbt2tG9e/ezxidNmoSnpyfHjx8nKCiItWvXUr9+fZYsWUKjRo344YcfuO222/LmL1y4kJ49e7Ju3TpiY2MZN24cU6dOBaBGjRr8+uuvJCYmMmfOHDZt2lRin5+IiJyb02nw9h+7efDLDWTmOujWIIzvH+zicsGmMCw/cmMFVzxy42r07yAicnHp2XZGzt3Iwm1mY777u9Zh7LWN8XC3/NhFsSjokZtSdbeUiIiIFMyRpAyGzIxm54lUvNzdePmW5vSJKmCbExencCMiIlLGrNl/ige/3EBSeg5hAd58NKAtkREVrS6r1FC4ERERKUO+WHOIF37Yht1p0KJGMB8NiKR6iK/VZZUqCjciIiJlQK7Dyfgft/HFmsMA3NCqOhNva4mvV/lozFcYCjciIiKlXFJ6Dg9+GcOa/UnYbPDkVY14sEe9ctWYrzAUbs6jHN5EVqro/RcRMe08kcLgz6M5ejoTfy933r2rDVc0rWJ1WaWaws2/uLubh/dycnLw9dU5TKtkZJgrsXt6elpciYiIdRZuO8HjczaSkeOgVkU/pg+KomGVQKvLKvUUbv7Fw8MDPz8/Tp48iaenJ25urtkroLQyDIOMjAwSEhIICQnJC5siIuWJYRi8v2gvb/2xG4DO9UKZ0q8tFfy9LK6sbFC4+RebzUa1atU4cOAAhw4dsrqcciskJISqVataXYaISInLyLEz6pvN/LzlOAD3dK7NM9c3wdNFG/MVB4Wbc/Dy8qJBgwbk5ORYXUq55OnpqSM2IlIuxZ3JZMjn0Ww/noKnu40Xb2pO3/a1rC6rzFG4OQ83Nze1/RcRkRKz/mASD8yK4VR6DqH+Xnw4IJJ2tdWY71Io3IiIiFhs9rrDjFuwlVyHQdNqQUwbFEUNNea7ZAo3IiIiFrE7nLz88w4+W3UQgOtaVOXNO1rh56Vfz/+F3j0RERELnE7PYcTXG1i59xQAI69syMM966sxXxFQuBERESlhu+NTGTIzmkOnMvDzcuftPq25prnuEC0qCjciIiIl6M/t8Tw2ZyNp2XZqVvBl+qAoGlcNsrosl6JwIyIiUgIMw+CDJft48/ddGAZ0qFORqf0jqajGfEVO4UZERKSYZeY4GP3tZn7cdAyA/h1r8fwNzdSYr5go3IiIiBSj48mZDJ0Zw5a4ZDzcbLxwYzP6d4ywuiyXpnAjIiJSTGIOnWbYrBgS07Kp4OfJ1P6RdKwbanVZLk/hRkREpBh8E32EZ+ZvJcfhpHHVQKYNjCK8op/VZZULCjciIiJFyO5wMuHXnXyy4gAAVzerwtt9WuPvrV+5JUXvtIiISBFJzshlxNcbWL4nEYBHezXg0V4NcHNTY76SpHAjIiJSBPYmpDFkZjQHEtPx9XTnrT6tuK5FNavLKpcUbkRERP6jxTsTeOTrWFKz7dQI8eXjgZE0qx5sdVnllsKNiIjIJTIMg4+X7ee133ZiGNCudgWm9o8kLMDb6tLKNYUbERGRS5CV62Dsd1uYHxsHwF3twnnxpuZ4eagxn9UUbkRERAopPiWLobNi2HTkDO5uNp7r3ZSBnSK0oncpoXAjIiJSCBuPnGHozGgSUrMJ8fPkg35t6Vw/zOqy5B8UbkRERApofuxRnvp2Czl2Jw2rBDBtYBQRof5WlyX/onAjIiJyEQ6nwcTfdvLRsv0AXNGkCpPuak2AGvOVSvpXERERuYCUrFwe+TqWJbtOAjDi8vqMvLKhGvOVYpZe0p2ens7EiRPp1asXHTp04L777mPr1q0X3e/nn3/m6quvpnXr1gwYMID9+/eXQLUiIlLe7D+Zxs1TVrJk10l8PN2Y3LcNT17dSMGmlLM03AwbNoyMjAxeeOEFJk2ahMPhoHPnzhcMK7/88gs333wzV155JVOmTCEzM5Nu3bpx+vTpEqxcRERc3bLdJ7l5ykr2n0ynWrAP3wzrzI2tqltdlhSAzTAMw6oXz83NxdPTM2/bbrfj6+vLRx99xH333XfOfdq3b0+TJk34/PPPAcjJyaFq1aqMGjWKsWPHFuh1U1JSCA4OJjk5maCgoP/+iYiIiMswDINPVhzg1V924DSgba0QPhwQSeVAH6tLK/cK+vvb0iM3/ww2YB6VAWjXrt0556elpREdHc0111yTN+bl5cUVV1zB4sWLi69QEREpF7LtDkbN28zLP5vB5o7Imnw9tKOCTRlj+QXFK1asYPDgwaSkpJCZmcmPP/5IixYtzjn36NGjGIZBtWr5FyKrWrXqBa/Vyc7OJjs7O287JSWlaIoXERGXkZCaxQOzYthw+AxuNnj2+qbc26W2GvOVQZb3iG7Tpg3ff/89c+fO5cYbb2TQoEHs3bv3nHMdDgdgHq35J29vb+x2+3lfY8KECQQHB+d9hIeHF90nICIiZd7mo2e48b2VbDh8hiAfDz67tz33da2jYFNGWR5u/P39ady4MV27duWzzz6jYsWKvPfee+ecGxoaCkBiYmK+8cTExLzHzmXs2LEkJyfnfRw5cqToPgERESnTFmyM444PV3MiJYt6lfxZMKIrlzWsZHVZ8h9YHm7+yWazERwcfN7TRlWrVqVmzZqsWbMm3/jq1auJioo67/N6e3sTFBSU70NERMo35/8a8z06eyPZdieXN6rE/Ie6UCdMHYfLOsvCTWZmJuPGjcsLMoZhMHPmTNavX89NN92UN2/cuHHceOONedvDhg1j+vTp7NmzB4AZM2awd+9ehgwZUrKfgIiIlFmpWbkMnRXNB0v2ATCse12mD2pHkI/nRfaUssCyC4q9vb0JDg6mYcOGeHl5kZycTMWKFZk2bRo333xz3rzjx4/n63szZswYDh8+TPPmzQkODsZut/PZZ5/RsmVLCz4LEREpaw4mpjNkZjR7EtLw8nDj9dtacEubmlaXJUXI0j43f4uLi8Pf35+QkJCzHjtx4gSZmZnUqVMn33hKSgqnTp2iZs2aZ91SfjHqcyMiUj6t3JvIg19uIDkzlypB3nw8IIpW4SFWlyUFVNDf35bfCg5Qo0aN8z5WtWrVc47r2hkRESkowzD4fNVBXvp5Bw6nQavwED4eEEmVIPWvcUWlItyIiIgUlxy7k+cWbGX2evNO2Vvb1ODVW1vg4+lucWVSXBRuRETEZSWmZfPArBiiD53GzQZjr23C4G7qX+PqFG5ERMQlbTuWzJDPozmWnEWgjweT+7bh8kaVrS5LSoDCjYiIuJyfNx/niW82kpXrpG6YP9MGRVGvUoDVZUkJUbgRERGX4XQaTPpzN5MXmcv4XNawEu/d1YZgP/WvKU8UbkRExCWkZ9t5fM5Gft8eD8CQbnV46prGeLiXqmb8UgIUbkREpMw7kpTBkJnR7DyRipe7G6/e2oLbI9WYr7xSuBERkTJt9b5TPPhlDKczcqkU6M1HAyJpW6uC1WWJhRRuRESkzJq15hDjf9iG3WnQokYwHw+MpFqwr9VlicUUbkREpMzJsTsZ/+M2vlx7GICbWlfn9dtaqjGfAAo3IiJSxpxKy+bBLzew9kASNhuMvroxD3Svq8Z8kkfhRkREyowdx1MY/Hk0cWcyCfD24N27WtOrSRWry5JSRuFGRETKhN+2Hmfk3E1k5DiICPVj+sAoGlQJtLosKYUUbkREpFRzOg3eW7SXd/7cDUDX+mG8368NIX5eFlcmpZXCjYiIlFoZOXaemLuJX7eeAODeLrV55romaswnF6RwIyIipdLR0xkMmRnDjuMpeLrbePnm5tzZrpbVZUkZoHAjIiKlzroDSQz/IoZT6TmEBXjxYf9IompXtLosKSMUbkREpFT5et1hnluwlVyHQbPqQXw8MIoaIWrMJwWncCMiIqVCrsPJyz9t5/PVhwC4vmU13ry9Fb5easwnhaNwIyIiljudnsODX25g9f5TADx5VUMeury+GvPJJVG4ERERS+06kcrgmes5kpSJv5c779zZmquaVbW6LCnDFG5ERMQyf2yP57HZsaTnOAiv6Mu0gVE0rhpkdVlSxinciIhIiTMMgymL9/LWH7sxDOhUN5Qpd7elor8a88l/p3AjIiIlKjPHwah5m/hp83EABnaKYFzvpniqMZ8UEYUbEREpMcfOZDJ0VjRb41LwcLPx4k3N6ddBjfmkaCnciIhIiYg5lMSwWRtITMumor8XU+9uS4e6oVaXJS5I4UZERIrd3PVHeOb7LeQ6DBpXDWTawCjCK/pZXZa4KIUbEREpNnaHk1d/2cmMlQcAuLZ5Vd68oxX+3vr1I8VHX10iIlIszmTk8PDXsSzfkwjAY1c04JGeDXBzU2M+KV4KNyIiUuT2JqQy+PNoDp7KwNfTnbf7tOLaFtWsLkvKCYUbEREpUot2xvPI1xtJy7ZTI8RszNe0uhrzSclRuBERkSJhGAYfLt3PxIU7MQxoX6ciU+9uS2iAt9WlSTmjcCMiIv9ZVq6Dp77dzIKNxwDo274W429shpeHGvNJybM03Ozbt49JkyaxatUqPDw86Nq1K2PHjiUsLOy8+zzzzDN8+eWX+cYaNWrEwoULi7tcERE5hxPJWQydFc3mo8m4u9l44Yam9O8YoRW9xTKWhRuHw8H111/Pww8/zL333ktGRgajR4+mV69erFu3Dm/vcx/GPHXqFE2bNuWDDz7IG/Py0lokIiJWiD18mqGzYjiZmk2Inycf3N2WzvXO/weqSEmwLNy4u7uzbds23N3d88Y+++wzGjVqxJo1a+jevft59/Xz86N27dolUKWIiJzPtzFHGTt/Czl2J42qmI35aoWqMZ9Yz9LTUv8MNmAezTnX+L8tX76cpk2bEhwcTLdu3XjmmWcIDg4utjpFROT/OZwGr/26g2nLzcZ8Vzatwjt3tiZAjfmklChVX4nPPvssdevWpX379uedExoayrPPPkv37t2Ji4vjmWee4ZdffiEmJua8p7Kys7PJzs7O205JSSny2kVEyoPkzFwe+TqWpbtPAvBwz/o8fkVDNeaTUqXUhJtnn32WhQsXsmTJkgteQ/PSSy/h5mZefd+yZUtatWpF7dq1mT17NoMGDTrnPhMmTGD8+PHFUreISHmx72QaQz6PZn9iOj6ebrx5Ryt6t6xudVkiZykV9+i9/PLLTJo0iV9++YWoqKgLzv072PytevXqREREsH379vPuM3bsWJKTk/M+jhw5UiR1i4iUF0t2JXDzlJXsT0ynerAP8x7orGAjpZblR25eeeUVJkyYwM8//8xll11W6P2zsrI4fvw4FStWPO8cb2/v856yEhGR8zMMg+nLDzDh1x04DYiMqMCH/SOpFKifqVJ6WXrk5rXXXmPChAn88ssv9OjR45xzxowZw9VXXw1ATk4Ojz/+OAkJCQCkpaUxbNgwDMPgzjvvLKmyRUTKhaxcB09+s5lXfjGDzZ1R4Xw1pIOCjZR6lh25SUpKYuzYsfj7+591rczrr7+eF1YSExOJi4sDwNPTk/r16xMVFUVmZiYpKSlERUWxePFi3RouIlKEElKyGDorho1HzuDuZmPc9U0Y1Lm2GvNJmWAzDMOw4oWdTieHDx8+52NhYWEEBAQAZtO+7OxsqlfPf2731KlTBAUF4enpWejXTklJITg4mOTkZIKCtJibiMg/bTpyhqGzoolPySbY15Mp/drStYEa84n1Cvr727IjN25ubgU62hIaGlqocRERuXQLNsYxet5msu1O6lcOYPrAKGqH+VtdlkihWH5BsYiIWM/hNHhj4S4+XLoPgJ6NK/PuXa0J9Cn80XERqynciIiUc6lZuTw6eyOLdpo3awzvUY8nr2qEuxrzSWHlpMPaj+DIWug7Gyy6RkvhRkSkHDuQmM6QmdHsTUjD28ONibe35KbWNawuS8oaew5s+ByWToR0MySzfwnUu9ySchRuRETKqeV7TvLQlxtIybJTNciHjwdG0rJmiNVlSVnidMDmObBkApz5301CIRFw+TNQp/C964qKwo2ISDljGAafrTrIyz/vwOE0aFMrhI/6R1I5yMfq0qSsMAzY8SMsehkSd5ljAVWh+yhoMxA8zr+MUklQuBERKUey7Q7Gfb+VudFHAbitbU1euaU5Pp7uFlcmZYJhwP7F8NeLcCzWHPMJga6PQ/uh4OVnaXl/U7gRESknTqZm88AXMcQcOo2bDZ6+rgn3d62jxnxSMEfWw1/j4eByc9vTHzo9CJ0fBp9ga2v7F4UbEZFyYGtcMkNmRnM8OYtAHw/e79eW7g0rWV2WlAXx28zTT7t+MbfdvaDdYOg6EgJK59eQwo2IiIv7cdMxRs3bRFauk7qV/Jk+MIq6lQKsLktKu6T9sHgCbPkGMMDmBq3vhu5PQUi41dVdkMKNiIiLcjoN3v5jN+8v3gtA94aVmNy3DcG+aswnF5ByzLylO3YWOO3mWNOboeezENbA0tIKSuFGRMQFpWXbeXzORv7YHg/A0Mvq8tQ1jdWYT84vIwlWvA3rpoE9yxyrf6UZaqq3trS0wlK4ERFxMYdPZTB45np2x6fh5eHGa7e24Na2Na0uS0qr7FRYMxVWvQfZKeZYeEe44nmI6GxtbZdI4UZExIWs2pfIg19u4ExGLpUDvfloQCRtalWwuiwpjXKzIPoTWP4WZJwyx6q2gJ7PQYMrLVs6oSgo3IiIuADDMPhizSFe+HE7DqdBq5rBfDQgiqrBaswn/+Kww8YvYenrkBJnjlWsBz2fgaa3gJubtfUVAYUbEZEyLsfu5PkftvH1OrP9/c2tq/PabS3VmE/yczph+3xY9Aokmau/E1TDvPup9d3g7jqRwHU+ExGRcuhUWjbDv9jAuoNJ2Gzw1DWNGXZZXTXmk/9nGLDnD1j0IpzYYo75hUK3JyHqPvB0vaN7CjciImXU9mMpDJkZTdyZTAK9PXi3b2t6Nq5idVlSmhxaZS6VcHi1ue0dZHYU7jgcvAOtra0YKdyIiJRBv245zsi5m8jMdVA71I/pg6KoX9l1f1lJIR3fZIaavX+a2x4+0H6I2VXYr6K1tZUAhRsRkTLE6TR49689vPvXHgC6NQjj/b5tCfZTYz4BEveYSyVs/97cdvOAtgPhslEQVN3S0kqSwo2ISBmRnm3nibmb+G3bCQDu71qHsdc2xsO97N/dIv/RmSPm3U8bvwLDAdigxR3QYwyE1rO6uhKncCMiUgYcScpgyMxodp5IxcvdjZdvaU6fqNK9vo+UgLSTZp+a6E/AkWOONboOLn8Gqja3tjYLKdyIiJRya/efYviXG0hKzyEswJuPBrQlMsL1r5uQC8hKNjsKr/4ActPNsdrdoNdzEN7e2tpKAYUbEZFS7Mu1h3h+wTbsToPmNYL4eEAU1UN8rS5LrJKTAes+hhXvQNYZc6x6GzPU1L28THcVLkoKNyIipVCuw8mLP25n1ppDAPRuWY03bm+Fr5ca85VL9hyInQlL34A085orKjU2F7Vs3Fuh5l8KHW4OHjzI3LlzWbZsGUePHgUgPDycyy67jD59+hAREVHkRYqIlCdJ6Tk8+GUMa/abjfmevKoRD/aop8Z85ZHTAVvmwZJX4fRBcyykFvR4Glr2ATeF3XOxGYZhFGTi/v37GT16NAsWLKBJkya0a9eOKlXMZlHx8fGsW7eOnTt3cvPNN/P6669Tt27dYi38v0hJSSE4OJjk5GSCgoKsLkdEJM/OE2ZjviNJmfh7uTPprjZc2VSN+codw4Bdv5i3dSdsN8f8K0P30eat3R7e1tZnkYL+/i7wkZtOnToxdOhQ3nzzTWrXrn3OOQcPHuSTTz6hU6dOxMfHF7poEZHybOG2Ezw+ZyMZOQ5qVTQb8zWsosZ85c7+pWYDvrhoc9snGLo8Bh2GgZe/paWVFQU+cnPq1ClCQ0ML9KSFmWsFHbkRkdLEMAzeX7SXt/7YDUDneqFM6deWCv5eFlcmJepojLn+0/4l5rann7lMQueHwbeCpaWVFkV+5OZCYcUwDPbt20fVqlUJCAgo1cFGRKQ0ycixM2reZn7efByAezrX5pnrm+CpxnzlR8IO8/TTzp/MbTdPc0HLbk9AoE5JXopL+u5Zv349Dz30UN52v379aNCgAVWrVmX58uVFVpyIiCuLO5PJHR+u5ufNx/F0tzHh1ha8cGMzBZvy4vRB+G4YfNDJDDY2N2h9NzwcA9dNVLD5Dy7pVvAnn3ySV199FYDNmzfz66+/Eh0dzcKFC3nmmWdYtmxZkRYpIuJq1h9MYvgXMSSm5RDq78XU/pG0r6PGfOVC6glY9gbEfA7OXHOsyY1mV+HKja2tzUVcUriJiYmhbdu2APzxxx/ceuutREZG0qhRI1577bUiLVBExNXMWX+YZ7/fSq7DoEm1IKYNjKRmBT+ry5LilpEEK9+FtR+BPdMcq9cTeo6DGm2trc3FXFK4CQoKYv/+/TRr1owff/yR+++/H4AzZ87oAl0RkfOwO5y8/PMOPlt1EIDrWlTlzTta4eelfqouLTsN1k6Fle9BdrI5VrO92VW4Tjdra3NRl3Rit0+fPlx//fVcd911bNmyhd69ewPw22+/cd111xX4ebZv386QIUNo1qwZrVq14qGHHuLEiRMX3e+rr76iQ4cO1K5dmxtuuIGtW7deyqchIlJizmTkcM+n6/OCzcgrGzKlX1sFG1dmz4Y1H8Lk1uYFw9nJUKU59J0D9/+uYFOMLincvPnmm4waNYrmzZuzaNEiKlQwb1Hbt28fzz33XIGew+FwcOedd9KxY0e++eYbPvnkE7Zu3UqvXr3IzMw8737z5s3jnnvuYciQIfz888+EhYXRo0cPEhISLuVTEREpdnviU7lpykpW7E3Ez8udD/tH8kivBuo47Kocdoj9At6LhN+egvSTUKEO3PYJDFsOja7RcgnFrMB9boqDYRj5vrn37t1LgwYNWLx4MT169DjnPq1bt6Zdu3ZMmzYNALvdTvXq1XnooYd4/vnnC/S66nMjIiXlrx3xPDp7I2nZdmpW8GXawCiaVNPPHZfkdMKOH2DxK5Bo9iwisBp0fwra9Ad3T2vrcwEF/f1d4CM3d9xxBzt37rzovO3bt3PHHXcU6Dn//VdLdnY2AF5e525clZKSwqZNm7jyyivzxjw8POjVq5fu0BKRUsUwDD5YspfBM6NJy7bToU5FfhjRVcHGFRkG7P0TpvWAbwaZwca3Ilz1MjwSC1H3KtiUsAKf7O3YsSMdO3akTZs23HDDDURGRlKlShUMw+DEiROsX7+eH374gS1btjBu3LhCF2IYBmPGjKFhw4a0a9funHPi4uIA8ta0+luVKlXYuHHjeZ87Ozs7LziBGZJERIpLVq6D0fM288OmYwDc3aGW+te4qsNrzKUSDq00t70CoNMI6PQQ+CjIWqXA4eaJJ57gnnvu4aOPPuKzzz7jySef5O8zWjabjRYtWtC3b18WLFhwSR2KR48ezbJly1i6dCmenudOuH+/nodH/rI9PDxwOBznfe4JEyYwfvz4QtckIlJYx5MzGTozhi1xyXi42Xj+xmYM6BhhdVlS1E5sgb9egj0LzW13b2g/BLo+Dv5h1tYml37NTXJyMnFxcdhsNqpXr05wcPAlF/Hss88yefJkFi5cSKdOnc477+TJk1SuXJnvv/+em266KW980KBB7Nu3jxUrVpxzv3MduQkPD9c1NyJSpDYcPs2wWTGcTM2mgp8nH9wdSad6Wo7GpZzaZ15Ts/Vbc9vmbl5P0300BNe0trZyoMjXlvq34ODg/xRo/vbcc88xefJkfvvttwsGG4BKlSpRu3ZtVqxYkS/cLF++nJtvvvm8+3l7e+PtXT6XhxeRkjEv5ihPf7eFHIeTRlUCmT4oivCKasznMpLjYOnr5l1Qxv/OFDS/zewqHFrP2trkLJd8Ajg1NZVvv/2WN954I29sx44dFOZA0Pjx45k0aRK//fYbnTt3PuecJ554It+dUyNGjGD69OnExMTgcDh4++23OXr0KEOHDr3UT0VE5JLZHU5e/mk7T36ziRyHk6uaVuHbBzsr2LiK9ERY+AxMbgMbPjeDTYOrzVu6b5+hYFNKXdKRm507d3LllVfidDo5duwYo0aNAuC1117j6quvpl+/fhd9jqSkJF544QV8fHy49dZb8z329ttv5z1HcnIyiYmJeY+NHDmS+Ph4LrvsMpxOJ5UqVWLevHk0bqz1OESkZCVn5PLw7FiW7T4JwCO9GvBYrwa4uamHSZmXlQKrp8Dq9yEnzRyL6GJ2Fa7V0dra5KIu6Zqba6+9ljZt2vDKK6/g5uaWd7QmJiaGIUOGsGHDhos+h2EYxMfHn/Ox4OBgfH19AfP8Wm5u7lkXKdvtdlJTUwkJCSl0Iyz1uRGR/2rfyTSGfB7N/sR0fD3defOOVlzfsprVZcl/lZsJ66fD8rchM8kcq9bKDDX1eqn5nsUK+vv7ksJNSEgIBw8ezAsWfz9Feno6FStWzHfxbmmkcCMi/8XiXQk88lUsqdl2aoT48vHASJpV/+/XIIqFHLnm9TRLJ0KqeQs/oQ2g57Pmit1uuo2/NCjWC4oNw8gLMP88arJ///4iuchYRKQ0MgyDacv3M+HXnRgGREVU4MMBkYQF6IaFMsvphG3fmXdAJe03x4LDoccYaHkXuGvtr7Lokv7VrrrqKiZOnMhbb72VF24SEhIYMWIE1157bZEWKCJSGmTlOnj6uy18F2s2E72rXTgv3tQcLw/9RV8mGQbsXgiLXoL4/y2+7F8Juj1pdhT2UGAtyy7ptNSRI0fo0aMHbm5u7N27l65duxIbG0vVqlVZvnw51aqV7vPOOi0lIoURn5LF0FkxbDpyBnc3G8/1bsrAThFa+LKsOrjC7Cp8ZK257R0MXR6GDsPBO8Da2uSCivW0VHh4OJs3b+arr74iOjoap9NJv379GDBgAAEB+sIQEdex8cgZhs6MJiE1m2BfTz64uy1d6qsDbZl0LNYMNfsWmdsevtBhGHR5FPwqWlubFClLVwW3io7ciEhBzI89ylPfbiHH7qRB5QCmD4oiItTf6rKksE7ugkUvmyt2A7h5QOQ9cNkoCKxqaWlSOMXeoRjA6XSSkZFx1riO3ohIWeZwGkxcuJOPlpoXmF7RpDLv3NmaQB+t7FymnD5kdhXe9DUYTsAGLe80LxauWMfq6qQYXVK42bVrFw888ACrVq0iJyfnrMfL4cEgEXERKVm5PPp1LIt3mY35Hrq8Hk9c2UiN+cqStARY9iZEzwBnrjnWuLd5W3flJtbWJiXiksLNoEGDqFq1KgsWLCAkJKSISxIRscaBxHQGf76efSfT8fZwY+LtLbmpdQ2ry5KCyjwDqybDmqmQ+7+zCnV7QM/noGaklZVJCbukcLNp0yZ+++03BRsRcRnLdp9kxFcbSMmyUzXIh2kDo2hRU327yoScdFj7EaycBFnJ5liNSOj1PNTtbmlpYo1LCje1a9cmISFB4UZEyjzDMJix8iCv/LwdpwFtaoXw0YBIKgf6WF2aXIw9x1zMculESE8wxyo1gV7joNF1WiqhHLukcPPiiy9y77338vrrr1OvXr2zej1Uraqrz0Wk9Mu2O3h2/la+iTkKwO2RNXnlluZ4e7hbXJlckNMBm+fCklfhzGFzLCQCLn8GWtwObvr3K+8uKdyEhoaydetWunXrds7HdUGxiJR2CalZPDArhg2Hz+Bmg2eub8p9XWqrMV9pZhiw8yfztu6TO82xgKrQfRS0GQgeXtbWJ6XGJYWbBx98kOuvv54HH3xQp6ZEpMzZcjSZobOiOZ6cRZCPB+/3a8tlDStZXZacj2HA/sVmA75jseaYTwh0fRzaDwUvP0vLk9LnksLN4cOHWbdunRrgiUiZ88OmY4z6ZhPZdif1KvkzfVA76oSpMV+pdWQ9/DUeDi43tz39odOD0Plh8NEF33JulxRuGjRowNGjR2natGlR1yMiUiycToO3/tjFlMX7ALi8USXe7duGIDXmK53it5mnn3b9Ym67e0G7wdB1JAToKJtc2CWFm/79+9O/f39ef/116tevf9Y56tq1axdFbSIiRSI1K5fH52zkzx3mHTXDutdl9NWNcVdjvtInaT8sngBbvgEMsLlB67uh+1MQEm51dVJGXNLaUhe74K60X1CstaVEyo9Dp9IZ/Hk0exLS8PJw4/XbWnBLm5pWlyX/lnIMlr0BG2aC026ONb3Z7Coc1sDS0qT0KNa1pfbs2XPJhYmIlJSVexN58MsNJGfmUjnQm48HRtE6PMTqsuSfMpJgxduwbhrYs8yx+leaoaZ6a0tLk7LrksJN/fr1i7oOEZEiYxgGM1cf4sWftuNwGrQKD+HjAZFUCVJjvlIjO9VcJmHVe5CdYo6Fd4QrnoeIztbWJmVegcPN1q1bAWjevHne/59P8+bN/1tVIiKXKMfu5LkFW5m9/ggAt7apwau3tsDHU43dSoXcLHNBy+VvQUaiOValBfR6Dhpcqa7CUiQKHG5atGgBmH8R/f3/51Par7kREdeUmJbN8C9iWH/wNDYbjL22MUO61VVjvtLAYYeNX8LS1yElzhyrWA96PgNNbwE3N2vrE5dS4HBz/Pjxc/6/iEhpsO1YMkNnxhB3JpNAbw8m923D5Y0rW12WOJ2wfT4sfhVO7TXHgmqYdz+1vhvcL+nqCJELKvBXVdWqVRk8eDDTp0/X2lEiUqr8vPk4T36zicxcB3XC/Jk2MIr6lQOsLqt8MwzY8wcsehFObDHH/EKh25MQdR946vonKT6FuhXcZrO5xCkn3Qou4hqcToNJf+1h8l/mHZyXNazEe3e1IdhPjfksdWiVuVTC4dXmtneQ2VG443DwDrS2NinTivVWcBERq6Vn2xk5dyMLt8UDMLhrHcZc2xgPd127YZnjm+Cvl2DvH+a2hw+0H2J2FfaraG1tUq4o3IhImXMkKYMhM6PZeSIVL3c3XrmlOXdEqXutZRL3mEslbP/e3HbzgLYD4bJREFTd0tKkfCp0uPHwuPgudrv9kooREbmY1ftO8eCXMZzOyKVSoDcf9o8kMqKC1WWVT2eOmHc/bfwKDAdggxZ3QI8xEFrP6uqkHCt0uHn//feLow4RkYuateYQ43/Yht1p0KJGMB8PjKRasK/VZZU/aSfNPjXRn4AjxxxrdB1c/gxUVZ8zsV6hw80DDzxQHHWIiJxXrsPJCz9s48u1hwG4sVV1Jt7eUo35SlpWstlRePUHkJtujtXuZjbgC29vbW0i/6BrbkSkVEtKz2H4FzGsPZCEzQajrm7E8O711JivJOVkwLqPYcU7kHXGHKvexgw1dS9XV2EpdRRuRKTU2nE8hSEzozl6OpMAbw/evas1vZpUsbqs8sOeA7EzYekbkHbCHKvU2FzUsnFvhRoptQoVbjIzM4urDhGRfH7beoKRczeSkeMgItSP6QOjaFBFPVJKhNMBW+bBklfh9EFzLKQW9HgaWvYBN50OlNKtUOHGx0cdJUWkeBmGwXuL9vL2H7sB6FI/lCn92hLi52VxZeWAYcCuX8zbuhO2m2P+lc1buiMHgYe3tfWJFJCl3a4yMzP57LPP6NixIyEhIaxYseKi+4wcOZKQkJB8H507dy6BakWkuGXk2Hnoqw15weaezrX5/N72CjYlYf9SmH4FzO5nBhufYOj1PDy6EToMVbCRMsXSa25eeOEFTpw4wahRo7j99tsL1B8nIyOD7t278/nnn+eNubvrEKlIWXf0dAZDZsaw43gKnu42XrqpOXe1r2V1Wa7vaIy5/tP+Jea2p5+5TELnh8FX/YOkbLI03Lz22mvYbDaOHj1aqP08PT0JCQkpnqJEpMStP5jEA7NiOJWeQ1iAF1P7R9Kuttr1F6uEHebpp50/mdtunuaClt2egEBdtC1lm6Xh5lJv5fzrr7+oXr06wcHBdOvWjZdeeokqVfTNKFIWfb3uMM8t2Equw6BptSCmDYqiRoga8xWb0wdh8QTYPAcwwOYGrfpC96egQoTV1YkUiTJ3K3iNGjWYPHky3bt3Jy4ujlGjRtGlSxc2bdqEv7//OffJzs4mOzs7bzslJaWkyhWR88h1OHn5p+18vvoQANe3qMYbd7TEz6vM/VgqG1JPwLI3IOZzcOaaY01uNLsKV25sbW0iRazM/RQZN25c3v/XqlWL+fPnU7NmTWbPns39999/zn0mTJjA+PHjS6pEEbmI0+k5PPTVBlbtOwXAk1c15KHL66sxX3HISIKV78Laj8D+v3Ye9XpCz3FQo621tYkUkzIXbv6tUqVKREREsGvXrvPOGTt2LCNHjszbTklJITxcKwiLWGF3fCqDP4/mcFIGfl7uvHNna65uVtXqslxPdhqsnQor34PsZHOsZnuzq3CdbtbWJlLMyny4SU9P5+jRo1SuXPm8c7y9vfH21m2MIlb7c3s8j86OJT3HQXhFX6YNjKJx1SCry3It9myI/hSWvwnpJ82xys2g1zhoeI26Cku5YGmfm4J45JFH8vrYZGdnc++997J7924Mw+D48eMMHDgQLy8v+vbta3GlInI+hmEwZfFehsyKJj3HQce6FVnwUFcFm6LksEPsF/BeJPz2lBlsKtSB2z6BB1ZAo2sVbKTcsDTcfPXVV4SEhNCsWTMAevfuTUhICK+99lrenIyMjLwLgL29vbniiiu4/fbb8fPzo1GjRmRlZbFy5Upq1KhhyecgIheWmePg4a9jeWPhLgwDBnSMYNb9Hajor8Z8RcLphG3fw9ROsOAhSD4CgdWg9yQYsR5a3A5upf7vWJEiZTMMw7DqxXNycsjIyDhr3MfHJ2+ph8zMTOx2O4GBgWft6+V1aT8cU1JSCA4OJjk5maAg/eUoUlyOnclk6Kxotsal4OFmY/xNzbi7g243LhKGAfv+gr9ehOObzDHfitBtJLQbDJ66nV5cT0F/f1t6zY2Xl9dFA4qv77m/QS812IhIyYg5lMSwWRtITMumor8XU+9uS4e6oVaX5RoOr4W/xsOhlea2VwB0GgGdHgIf/cEmUuYvKBaR0mdu9BGenb+VHIeTxlUDmTYwivCKflaXVfad2AJ/vQR7Fprb7t7Qfgh0fRz8w6ytTaQUUbgRkSJjdziZ8OtOPllxAIBrmlXlrT6t8PfWj5r/5NQ+WPwKbP3W3La5Q5v+0H00BNe0tjaRUkg/cUSkSCRn5DLi6w0s35MIwKO9GvBorwa4uekOnUuWHAdLXzfvgjIc5ljz28yuwqH1rK1NpBRTuBGR/2xvgtmY7+CpDHw93Xm7TyuubVHN6rLKrvRTsOJtWDcNHP9bOqbB1dDzWajW0traRMoAhRsR+U8W70zgka9jSc22UyPEbMzXtLouar0kWSmwegqsfh9y0syxiC5mV+FaHa2tTaQMUbgRkUtiGAYfLdvP67/txDCgfe2KfNC/LWEB6gZeaLmZsH46LH8bMpPMsWqtzFBTr5ea74kUksKNiBRaVq6DMd9u5vuNxwDo274W429shpeHmsUViiPXvJ5m6URINd9LQhuYp5+a3KjmeyKXSOFGRArlRHIWw2ZFs+loMu5uNl64oSn9O0ZoRe/CcDph23fmHVBJ+82x4HDoMQZa3gXu+tEs8l/oO0hECiz28GmGzYohITWbED9PPujXls711V+lwAwDdi+ERS9B/FZzzC8MLhsFUfeCh07piRQFhRsRKZDvNhxlzHdbyLE7aVglgOkD21ErVI35CuzgCnOphCNrzW3vYOjyMHQYDt4B1tYm4mIUbkTkghxOg9d/28nHy8zTJ1c0qcKku1oToMZ8BXMs1gw1+xaZ2x6+0GEYdHkU/CpaW5uIi9JPJxE5r+TMXB75Opalu08CMOLy+oy8sqEa8xXEyV2w6GXY8YO57eYBkfeYp6ACq1pamoirU7gRkXPafzKNwTOj2X8yHR9PN964vRU3tKpudVml35nDsOQ12PQ1GE7ABi3vNC8WrljH6upEygWFGxE5y9LdJxnx1QZSs+xUC/Zh2sAomtcItrqs0i0tAZa9CdEzwJlrjjXubd7WXbmJtbWJlDMKNyKSxzAMPllxgFd/2YHTgMiICnzYP5JKgbqL57wyz8CqybBmKuRmmGN1e0DP56BmpJWViZRbCjciApiN+Z6Zv5VvNxwFoE9UTV66uTneHu4WV1ZK5aTD2o9g5STISjbHakRCr+ehbndLSxMp7xRuRISElCyGfRFD7OEzuNlgXO+m3NO5thrznYs9BzZ8DsvegLR4c6xSE+g1Dhpdp6USREoBhRuRcm7z0TMMnRnDiZQsgn09eb9fG7o1qGR1WaWP0wGb58KSV82LhgFCIuDyZ6DF7eCmI1wipYXCjUg5tmBjHKPnbSbb7qR+5QCmDYyiTpi/1WWVLoYBO38yb+s+udMcC6gK3UdBm4Hg4WVtfSJyFoUbkXLI4TR48/ddTF2yD4CejSsz6a7WBPl4WlxZKWIYsH+x2YDvWKw55hMCXR+H9kPBS92ZRUorhRuRciY1K5fHZm/kr50JADzQvR6jrm6Euxrz/b8j6+Gv8XBwubnt6Q+dHoTOD4OPbokXKe0UbkTKkYOJ6QyeGc3ehDS8PdyYeHtLbmpdw+qySo/4bebpp12/mNvuXhB1P3R7AgJ0HZJIWaFwI1JOrNiTyENfbSA5M5cqQd58PCCKVuEhVpdVOiTth8UTYMs3gAE2N2jdD7qPgZBwq6sTkUJSuBFxcYZh8Nmqg7z88w4cToPW4SF8PCCSykE+VpdmvZTjsGwibJgJTrs51vRms6twWANLSxORS6dwI+LCsu0Onvt+G3OijwBwa9savHpLC3w8y/ltyxlJsOIdWPcx2LPMsfpXmqGmemtLSxOR/07hRsRFnUzNZvgXMUQfOo2bDZ6+rgn3d61TvhvzZaeayySseg+yU8yx8I5wxfMQ0dna2kSkyCjciLigrXHJDJ0ZzbHkLAJ9PHivbxt6NKpsdVnWyc0yF7Rc/hZkJJpjVVpAr+egwZXqKiziYhRuRFzMT5uP8eQ3m8jKdVI3zJ9pg6KoVynA6rKs4bDDxi9h6euQEmeOVawHPZ+BpreAm5u19YlIsVC4EXERTqfBO3/u5r1FewHo3rASk/u2Idi3HDbmczph+/ew+BU4Zb4fBNWA7k9B67vBXT/6RFyZvsNFXEBatp3H52zkj+3mQo5DL6vLU9c0Ln+N+QwD9vwBi16EE1vMMb9Qs09N1P3gqTvERMoDhRuRMu7wqQyGzIxmV3wqXu5uTLi1BbdF1rS6rJJ3aJW5VMLh1ea2V6DZUbjTg+AdaG1tIlKiFG5EyrBV+xJ58MsNnMnIpVKgNx8NiKRtrQpWl1Wyjm+Cv16CvX+Y2x4+0H4IdB0JfhWtrU1ELKFwI1JGzVp9kBd+3I7DadCyZjAfD4iianA5Ou2SuMe8pmbbfHPbzQPaDoTLRkFQdWtrExFLWXqrQGpqKh9++CGtW7fGx8eHZcuWFWi/Dz74gEaNGhESEkK3bt1Yt25dMVcqUnrk2J08PX8L4xZsw+E0uKl1deYO61R+gs2ZI7BgBEzp8L9gY4MWfeChddD7HQUbEbH2yM2ECRM4deoUL7/8MjfccANOp/Oi+8ycOZORI0fyxRdf0KlTJyZOnMiVV17J9u3bqVFDCwCKazuVls3wLzew7kASNhs8dU1jhl1Wt3w05ks7CSvehvXTwZFjjjW6Di5/Bqo2t7Y2ESlVbIZhGFYXcfToUcLDw1m8eDE9evS44NxmzZrRo0cPpkyZAoDT6aRmzZrce++9vPLKKwV6vZSUFIKDg0lOTiYoKOi/li9SIrYfS2HIzGjizmQS4O3B5L6t6dm4itVlFb+sZLOj8OoPIDfdHKvdzWzAF97e2tpEpEQV9Pd3mbrm5vTp02zfvp3x48fnjbm5uXH55ZezcuVKCysTKV6/bjnOyLmbyMx1UDvUj+mDoqhf2cXvAMrJgPXTzDWgMk+bY9XbmKGm7uXqKiwi51Wmws3x48cBqFw5fxv5ypUrExMTc979srOzyc7OzttOSUkpngJFipjTaTB50R4m/bkHgK71w3i/XxtC/LwsrqwY2XMgdiYsfQPSTphjYY3MRS2b3KBQIyIXVabCzd/c/tUy3c3NjQudXZswYUK+oz0iZUF6tp0nv9nEr1vNX/D3danD09c1xsPdRZcMcDpgyzxY8iqcPmiOBdeCy8dCyzvBrZyvZC4iBVamwk2VKub1BSdPnsw3npCQkPfYuYwdO5aRI0fmbaekpBAeHl48RYoUgSNJZmO+nSdS8XS38crNLejTzkW/Zg0Ddv0Ci16GhO3mmH9l85buyEHg4W1tfSJS5pSpcBMaGkqDBg1YunQpt9xyCwCGYbB06VL69u173v28vb3x9tYPSCkb1h1I4oEvYkhKzyEswIsP+0cSVdtFm9HtX2p2FY6LNrd9gqHLY9BhGHj5W1qaiJRdpT7cDB8+nHXr1uVdU/P4448zevRobrjhBjp27MjEiRNJTExk2LBhFlcq8t99tfYwzy3Yit1p0LxGEB8PiKJ6iK/VZRW9ozHm+k/7l5jbnn7Qcbi5XIJvOeuwLCJFztJwM2vWLIYMGZK3fdVVV+Hm5sazzz7Ls88+C0Bubm6+i4GHDx/O6dOn6du3L6dOnaJJkyb89NNP1K1bt8TrFykquQ4nL/20nZmrDwHQu2U13ri9Fb5eLnadScIO8/TTzp/MbTdPiLrPXNgysBzc1i4iJcLSPjcOh4Pc3Nyzxj08PPDwMHOX3W7H6XTi5XX23SFOp/Osi4sLQn1upDQ5nZ7Dg19uYPX+UwCMuroRD/ao51qN+U4fhMUTYPMcwACbG7TqC92fggoRVlcnImVEmehz4+7ujrv7hf8y/TvknMulBBuR0mTXiVQGz1zPkaRM/L3ceefO1lzVrKrVZRWd1BOw7E2I+Qyc//tDpsmNZlfhyo0tLU1EXFepv+ZGxFX9vu0Ej8/ZSHqOg1oV/Zg2MIpGVV2kMV9GEqyaDGs+BHumOVavJ/QcBzXaWlubiLg8hRuREmYYBlMW7+XN33cD0KluKB/c3ZYK/i7QmC87DdZOhZXvQXayOVazvdlVuE43a2sTkXJD4UakBGXmOBg1bxM/bTa7bQ/qFMGzvZviWdYb89mzIfpTWP4mpP+vD1XlZtBrHDS8Rl2FRaREKdyIlJBjZzIZMjOabcdS8HCz8eJNzenXoZbVZf03Djtsng1LXoPkI+ZYhTrmUgnNbgVdFyciFlC4ESkB0QfNxnyJaTlU9Dcb87WvU4Yb8xkGbF8Ai1+BRPP0GoHVzLuf2vQHd09r6xORck3hRqSYzV1/hGe+30Kuw6Bx1UCmD4qiZgU/q8u6NIYB+/6Cv16C4xvNMd+K0G0ktBsMni7YcFBEyhyFG5FiYnc4eeWXHXy68iAA1zavylt9WuHnVUa/7Q6vhb/Gw6GV5rZXAHQaAZ0eAh/1ixKR0qOM/pQVKd3OZOQw4qtYVuxNBODxKxrycM/6uLmVwQtrT2wxj9TsWWhuu3tD+yHQ9XHwD7O2NhGRc1C4ESlie+JTGTwzmkOnMvD1dOedO1txTfNqVpdVeKf2weJXYes8c9vmbl5P0300BNe0tjYRkQtQuBEpQn/tiOfR2RtJy7ZTI8SXaQOjaFq9jJ2ySY6Dpa9D7BdgOMyx5reZXYVD61lbm4hIASjciBQBwzD4cOl+Ji7ciWFA+zoVmXp3W0IDvK0ureDST8GKt2HdNHD8b7HaBlebt3VXa2ltbSIihaBwI/IfZeU6eOrbzSzYeAyAuzvU4vkbmuHlUUZ6vGSlwOopsPp9yEkzxyK6mF2Fa3W0tjYRkUugcCPyH5xIzmLorGg2H03Gw83G8zc2Y0DHMrLKdW4mrJ8Oy9+GzCRzrForM9TU66WuwiJSZinciFyiDYdPM2xWDCdTs6ng58mUu9vSuV4ZuHvIkWteT7N0IqSaR5sIbWCefmpyo7oKi0iZp3AjcgnmxRzl6e+2kONw0qiK2ZgvvGIpb8zndMK278yuwkn7zbHgcOgxBlreBe76cSAirkE/zUQKweE0eO3XHUxbfgCAq5pW4e07WxPgXYq/lQwDdi+ERS9B/FZzzC8MLhsFUfeCRxm66FlEpABK8U9kkdIlOTOXR76OZeluc9XrR3rW57ErGpbuxnwHV8BfL8KRtea2dzB0eRg6DAfvAGtrExEpJgo3IgWw72QaQz6PZn9iOj6ebrx1R2uub1mKG/MdizVDzb5F5raHL3QYBl0eBb8yvGCniEgBKNyIXMTiXQk88nUsqVl2qgf78PHAKJrXCLa6rHM7uQsWvQw7fjC33Twg8h7zFFRgVUtLExEpKQo3IudhGAbTlx9gwq87cBoQFVGBqf0jqRRYCq9ROXMYlrwGm74GwwnYoOWd5sXCFetYXZ2ISIlSuBE5h6xcB0/P38J3G+IAuDMqnBdvboa3h7vFlf1LWgIsexOiZ4Az1xxr3Nu8rbtyE2trExGxiMKNyL/Ep2QxbFYMG4+cwd3NxrjrmzCoc21spampXeYZWDUZ1kyF3AxzrG4P6Pkc1Iy0sjIREcsp3Ij8w6YjZxg6K5r4lGyCfT354O62dKlfihrz5aTD2o9g5STISjbHakRCr+ehbndLSxMRKS0UbkT+5/vYOEZ/u5kcu5MGlQOYPiiKiFB/q8sy2XNgw+ew7A1IizfHKjWBXuOg0XVaKkFE5B8UbqTcczgNJi7cyUdLza69vRpXZtJdrQn08bS4MsDpgM1zYcmr5kXDACERcPkz0OJ2cCtl1wCJiJQCCjdSrqVk5fLo17Es3mU25nuwRz2euKoR7lY35jMM2PmTeVv3yZ3mWEBV6D4K2gwEDy9r6xMRKcUUbqTcOpCYzuDP17PvZDreHm5MvL0lN7WuYW1RhgH7l5gN+I5tMMd8QqDr49B+KHiV8vWrRERKAYUbKZeW7znJQ19uICXLTtUgHz4eGEnLmiHWFnVkPfw1Hg4uN7c9/aHTg9BpBPiGWFqaiEhZonAj5YphGHy68iAv/7wdpwFtaoXwUf9IKgf5WFdU/Dbz9NOuX8xtdy+Iuh+6PQEBlayrS0SkjFK4kXIj2+5g3PdbmRt9FIDbI2vyyi3NrWvMl7QfFk+ALd8ABtjcoHU/6D4GQsKtqUlExAUo3Ei5kJCaxfAvNhBz6DRuNnj6uibc37WONY35Uo7DsomwYSY47eZY05vNrsJhDUq+HhERF6NwIy5va1wyQ2ZGczw5iyAfD97r15buDS043ZORBCvegXUfgz3LHKt/BfQcB9Vbl3w9IiIuSuFGXNqPm44xat4msnKd1K3kz/SBUdStFFCyRWSnmsskrHoPslPMsfCO0Os5qN2lZGsRESkH3Kwu4J133iEiIgIfHx/atWvHihUrLjj/gQcewGaz5fto3rx5CVUrZYXTafDGwp08/HUsWblOejSqxPcPdSnZYJObBas/gHdbw+JXzGBTpQX0+wbu+03BRkSkmFgabj755BOeeeYZpkyZQlxcHD179uSaa67h8OHDF9zvtttuwzCMvI+tW7eWUMVSFqRl2xk6K4Ypi/cBMOyyunwyqB1BJdVx2GE3r6d5LxIWjoWMRKhYD26fAcOWQcOrtFyCiEgxsjTcvPHGGwwePJjevXsTGhrKa6+9RkhICFOnTrWyLCnDDp1K59YPVvLnjni8PNx4585WjL2uScl0HHY6Yet38EEH+OFhSDkKQTXghsnw0Dpofhu4WX6wVETE5Vn2kzYpKYldu3bRo0ePvDGbzUaPHj1YtWrVBff97bff8PPzo1q1avTp04eDBw8Wb7FSJqzam8hNU1ayOz6NyoHezB3WiVva1Cz+FzYM2PMHfNwd5t0Lp/aCXyhc/So8vAEiB4G7Lm8TESkploWbEydOAFCpUv67VipXrpz32LnUr1+fr7/+mhMnTrBo0SKSk5Pp1q0bycnJ590nOzublJSUfB/iOgzDYObqgwyYsY4zGbm0qhnMjw93pXV4SPG/+KFV8Om18OXtcGIzeAVCj6fh0U3Q6SHwtLA5oIhIOVXq/pw0DOOCvUeefPLJvP8PCgpizpw5VKtWjTlz5jB06NBz7jNhwgTGjx9f5LWK9XLsTp7/YStfrzsCwC1tajDh1hb4eBZzY77jm+Cvl2DvH+a2hw+0HwJdR4JfxeJ9bRERuSDLwk3VqlUBOHnyZL7xkydPUqVKlQI/T0hICDVr1mTPnj3nnTN27FhGjhyZt52SkkJ4uDrAlnWJadkM/yKG9QdPY7PBmGsaM/SyusXbmC9xj3nn07b55rabB7QZAN1HQ1D14ntdEREpMMvCTcWKFWnUqBGLFy/m1ltvBcyjNkuWLGHAgAEFfp4zZ85w9OhRqlc//y8Wb29vvL29/3PNUnpsO5bM0JkxxJ3JJNDbg8l923B548rF94JnjsDS12HjV2A4ABu0uAN6jIHQesX3uiIiUmiW3rrx5JNPMmPGDH7++WeSkpIYM2YMZ86c4YEHHsibM3jw4Lw+NtnZ2dxyyy2sW7eO9PR0duzYwZ133klgYCB33323VZ+GlLBfthzn9qmriTuTSZ0wf+Y/1KX4gk3aSfhtLLzXFmJnmcGm0XXwwAq4bZqCjYhIKWTpNTeDBw8mJSWF4cOHEx8fT4sWLfjtt9+IiIg453xvb28GDx7Mk08+SWxsLBUqVKBbt26sXbuWypWL8a92KRWcToNJf+1h8l/mKchuDcJ4v29bgv2KoX9NVjKseh/WfAA5aeZY7W5mV+Hw9kX/eiIiUmRshmEYVhdR0lJSUggODiY5OZmgoCCry5ECSM+2M3LuRhZuiwdgcNc6jLm2MR7uRXzwMScD1k8z14DKPG2OVW9jhpq6l6v5noiIhQr6+7vU3S0l8m9HkjIYMjOanSdS8XJ34+VbmtMnqogvCHfkml2Fl06EtP+1IghrZK7U3eQGhRoRkTJE4UZKtTX7T/HglxtISs8hLMCbjwZEEhlRoehewOmArd+ad0CdPmiOBdeCy8dCyzvBrZhvKRcRkSKncCOl1hdrDvHCD9uwOw1a1Ajm44GRVAv2LZonNwzY9QssehkStptj/pXhslFmR2EP3V0nIlJWKdxIqZPrcDL+x218scZcQPWGVtWZeFtLfL2K6CjK/qXw14sQF21u+wRDl0ehwwPg5V80ryEiIpZRuJFSJSk9hwe/jGHN/iRsNhh1dSOGd69XNI35jsbAohdh/xJz29MPOg6Hzg+DbxGe6hIREUsp3EipsfNECoM/j+bo6Uz8vdx59642XNG04N2qzythh3n6aedP5rabJ0TdB92egMAieH4RESlVFG6kVFi47QSPz9lIRo6DiFA/pg2MomGVwP/2pKcPwpLXYNNswACbG7TqC92fggrn7qUkIiJln8KNWMowDN5ftJe3/tgNQJf6oUzp15YQP69Lf9LUE7DsTYj5DJy55liTG+HyZ6By4/9etIiIlGoKN2KZjBw7o77ZzM9bjgNwT+faPHN9EzwvtTFf5mlY+S6s+RDsmeZYvZ7QcxzUaFtEVYuISGmncCOWiDuTyZDPo9l+PAVPdxsv3dScu9rXurQny06DtR/CysmQnWyO1WxvdhWu063oihYRkTJB4UZK3PqDSTwwK4ZT6TmE+nvx4YBI2tWuWPgnsmdD9Kew/E1IP2mOVW4GvcZBw2vUVVhEpJxSuJESNXvdYcYt2Equw6BptSCmDYqiRkghG/M57LB5tnmxcPIRc6xCHXOphGa3gpuli92LiIjFFG6kRNgdTl7+eQefrToIwPUtqvHGHS3x8yrEl6BhwPYF5lIJieYFyARWM+9+atMf3IthdXARESlzFG6k2J1Oz2HE1xtYufcUAE9c2ZARPesXvDGfYcC+v+Cvl+D4RnPMtyJ0GwntBoNnES3JICIiLkHhRorV7vhUhsyM5tCpDPy83Hm7T2uuaV614E9weK25VMKhFea2VwB0GgGdHgKf8y93LyIi5ZfCjRSbP7fH89icjaRl26lZwZfpg6JoXLWAgeTEFvNIzZ6F5ra7N7QfAl0fB/+w4itaRETKPIUbKXKGYfDBkn28+fsuDAM61KnI1P6RVPQvQGO+U/tg8auwdZ65bXM3r6fpPhqCaxZv4SIi4hIUbqRIZeY4GP3tZn7cdAyAAR0jeO6GphdvzJccB0tfh9gvwHCYY81vgx5PQ1j9Yq5aRERcicKNFJnjyZkMnRnDlrhkPNxsvHBjM/p3vMgaTumnYMXbsG4aOLLNsQZXm7d1V2tZ/EWLiIjLUbiRIhFz6DTDZsWQmJZNBT9PpvaPpGPd0PPvkJUCq6eYHzmp5lhEF7OrcK2OJVO0iIi4JIUb+c++iT7CM/O3kuNw0rhqINMGRhFe0e/ck3MzYf10WP42ZCaZY9VamaGmXi91FRYRkf9M4UYumd3hZMKvO/lkxQEArm5Whbf7tMbf+xxfVo5c83qapRMh1bweh9AG5umnJjeqq7CIiBQZhRu5JMkZuYz4egPL9yQC8GivBjzaqwFubv868uJ0wrbvzK7CSfvNseBw6DEGWt4F7voSFBGRoqXfLFJoexPSGDIzmgOJ6fh6uvNWn1Zc16Ja/kmGAbsXwqKXIH6rOeYXBpeNgqh7wcO75AsXEZFyQeFGCmXxrgQe+SqW1Gw7NUJ8+XhgJM2qB+efdHCF2VX4yFpz2zsYujwMHYaDd0DJFy0iIuWKwo0UiGEYfLxsP6/9thPDgHa1KzC1fyRhAf84AnMs1gw1+xaZ2x6+0GEYdHkU/CpaU7iIiJQ7CjdyUVm5DsZ+t4X5sXEA9G0fzvgbm+Pl8b+LgE/ugkUvw44fzG03D4i8xzwFFViIdaRERESKgMKNXFB8ShZDZ8Ww6cgZ3N1sPH9DUwZ0jDBX9D5zGJa8Bpu+BsMJ2KDlnebFwhXrWF26iIiUUwo3cl4bj5xh6MxoElKzCfHz5IN+belcPwzSEmDZmxA9A5y55uTGvc3buis3sbZoEREp9xRu5Jzmxx7lqW+3kGN30rBKANMGRhHhl2teU7NmKuRmmBPrdIdez0PNSGsLFhER+R+FG8nH4TSY+NtOPlpm9qS5okkVJt3agICNH8HKSZCVbE6sEWl2Fa7bw7JaRUREzkXhRvKkZOXyyNexLNl1EoBHukfwWMVVuH3UD9LizUmVmkCvcdDoOi2VICIipZLCjQCw/2Qag2dGs/9kOn6e8GX7Q7TZNca8aBggJAIufwZa3A5u7tYWKyIicgGlJtw4nU7cCrm+0KXsI2dbtvskI77aQEpWLncFbOKFgPn4xOwxHwyoCt1HQZuB4OFlbaEiIiIFYHm4mTBhApMmTSIxMZGmTZvy7rvv0rNnzyLfp7xyOA1OZ+SQlJ7DqbQcTqVn5/1/UnoOJ1Oz+X37CTrZtvBCwLc0sO+GM4BPCHR9HNoPBa/zrPAtIiJSClkabj788ENeffVV5s+fT8eOHXnjjTfo3bs327Zto06dc/dJuZR9XEmO3cnpjP8PJ3+HFfP/c0j613hKZjZ+Rhb+ZBJgyySALPz//i+ZVLJlMctjPV3ct4Ed8PSHTg9CpxHgG2L1pysiIlJoNsMwDKtevGHDhlx33XVMmjQJMFv8R0RE0LdvX15//fUi2+ffUlJSCA4OJjk5maCgoKL4VC5ZVq4jL5ScSs8mKS2b5NRU0lLPkJGSTFZ6MjkZydgzU3Bkp+GRm2YGFbLwt2URQCb+NjOoBNoy8efvIJOFP1n42bILVIfh7oUt6n7o9gQEVCrmz1pERKTwCvr727IjN6dOnWLPnj107949b8xms9G9e3dWr15dZPuUpD++m4G7PZNAX3cMp4FhOMHpIDczjdzMVBxZqZCdii0nDffcNDwdGfgaGfiTRQVbFuGY4cTT5jj/i3heYnFunuailV6B4B34v/8PMP8bHI6twwMQEn6JTy4iIlJ6WBZu4uPNW4srVcp/lKBy5cqsW7euyPYByM7OJjv7/49gpKSkXFLNF+JwGrTY/ApVSSz4Trb/fZxHjpsvDk9/nJ4B4B2IzTsAD98gPH2DsHkH/C+kBP5/SPEK+Md24D/CTAB4eJ//hURERFyI5RcUO53Os7ZtF+mfUth9JkyYwPjx4y+9yALIdThJrxLF9uR4nAYYNhvgBjYbTg8/DK8AbD6BePgE4uUXjLd/ML4BwfgHheDrH4zNJ/D/g4iX+eGlO8FEREQKzbJwU61aNQASEhLyjSckJFC16rlXkr6UfQDGjh3LyJEj87ZTUlIIDy/aUzA+nu7UGz6nSJ9TRERECs+yQwMVKlSgadOmLF68OG/M6XSyePFiunTpkjdmt9vJyckp1D7/5u3tTVBQUL4PERERcU2Wnvd46qmnmDFjBt9++y3Hjh1j5MiRpKWlMXz48Lw5DzzwAG3bti3UPiIiIlJ+WXrNzcCBA0lLS2Ps2LHEx8fTokUL/vjjD2rWrJk3x9PTE29v70LtIyIiIuWXpX1urFKa+tyIiIhIwRT097duxxERERGXonAjIiIiLkXhRkRERFyKwo2IiIi4FIUbERERcSkKNyIiIuJSFG5ERETEpSjciIiIiEtRuBERERGXYunyC1b5uylzSkqKxZWIiIhIQf39e/tiiyuUy3CTmpoKQHh4uMWViIiISGGlpqYSHBx83sfL5dpSTqeTY8eOERgYiM1mK7LnTUlJITw8nCNHjmjNqmKk97lk6H0uOXqvS4be55JRnO+zYRikpqZSvXp13NzOf2VNuTxy4+bmVqyriAcFBekbpwTofS4Zep9Ljt7rkqH3uWQU1/t8oSM2f9MFxSIiIuJSFG5ERETEpSjcFCFvb2+ef/55vL29rS7Fpel9Lhl6n0uO3uuSofe5ZJSG97lcXlAsIiIirktHbkRERMSlKNyIiIiIS1G4EREREZeicFNEDMNg27ZtbNq0CbvdbnU5ZcLJkyfZuHEjZ86cOe+cjIwMYmJi2LdvX7HPcXW7d+9mxYoVZGRknPWY3W5n06ZNbNu27bxtzYtqjivLyMggNjaW+Pj4887ZtWsXGzZsICcnp9jnuCKn08n+/fuJiYnh5MmT5513+PBhoqOjL7jMTlHNcRVbtmxh7dq1533c6XSyZcsWNm/ejMPhsHzOBRnyn+3atcto3LixUblyZSM8PNyoUaOGsWrVKqvLKrVWrVpldO3a1ahcubLRunVrw9fX1xg8eLCRm5ubb97s2bONoKAgo0GDBkZgYKDRvXt3IykpqVjmuLpdu3YZQUFBBmBs2bIl32Nr1641atasaYSHhxtVqlQxGjZsaOzYsaNY5riyCRMmGAEBAUbz5s2NunXrGkOGDDHsdnve40ePHjXatGljVKxY0ahTp44RFhZmLFy4MN9zFNUcV7VhwwajUaNGRtWqVY22bdsafn5+xu23325kZmbmzcnIyDBuuukmw8/Pz2jcuLHh6+trTJkyJd/zFNUcVzFjxgyjdevWRoUKFYzQ0NBzztm8ebNRr149o1q1akaNGjWMiIgIY8OGDZbNuRiFmyLQpk0b44Ybbsj7QTZs2DCjevXq+b7h5P99/vnnxooVK/K2d+3aZVSoUMF45ZVX8sb2799veHl5GR988IFhGIaRnJxsNG3a1BgwYECRz3F1WVlZRps2bYzRo0efFW6ysrKMmjVrGkOHDjUMwzAcDodx4403Gi1btizyOa5s0qRJhr+/v7Fy5cq8sU8++cTIyMjI277iiiuMbt26GVlZWYZhGMYzzzxjBAcHG6dOnSryOa6qffv2xvXXX5/3h9CBAweMwMBA45133smb8+STTxq1atUyTpw4YRiGYXzzzTeGzWYzoqOji3yOqxgzZowRExNjvPPOO+cMNw6Hw2jcuLFx5513Gk6n0zAMw+jfv79Rt27dvH+LkpxTEAo3/9GGDRsMwFizZk3e2JEjRwybzWbMnz/fusLKmNtvv9249tpr87ZffPFFo3LlyobD4cgb+/DDDw1vb28jLS2tSOe4uocffti45557jPXr158Vbn744QcDMI4cOZI3tmbNGgMw1q9fX6RzXFV2drYRGhpqPP300+edc/jwYQMwfvrpp7yx5ORkw9vb25g2bVqRznFlderUMV544YV8Y40aNcp7751OpxEaGmq8/PLL+eY0adLEeOihh4p0jis6X7hZtmyZARhbt27NG9u1a5cBGH/88UeJzykIXXPzH8XGxgLQtm3bvLGaNWtSrVq1vMfkwux2Oxs3bqR+/fp5Y7GxsbRp0ybfwmjt27cnOzub7du3F+kcV/bjjz/yyy+/MHny5HM+HhsbS5UqVfKttRYVFYXNZsv7+i2qOa5q06ZNnDp1ihtuuIGEhAQ2bNjA6dOn8835+z2IjIzMGwsKCqJRo0b53sOimOPKXnrpJaZNm8aMGTP4888/eeKJJ7Db7TzwwAMAHDlyhFOnTuV7fwDatWuX9/4U1ZzyJDY2Fm9vb5o1a5Y31rBhQ4KCgvJ9bZbUnIJQuPmPkpKSCAoKwtPTM994aGgoSUlJFlVVtjz77LPEx8fz2GOP5Y0lJSURGhqab97f23+/r0U1x1XFxcUxZMgQvvjiCwIDA88551zvj7u7OyEhIRd8Dy9ljqs6duwYALNnz6Zly5bcd999VK9enWHDhuF0OoH//1o719fiP9/Dopjjynr16kVUVBRjx45l9OjRfPLJJwwbNiwvVOt9Lh7n+v6Gs9+zkppTEOVyVfCi5OnpSVZW1lnjmZmZeHl5WVBR2fLuu+8yadIkvv/+e+rWrZs3fq73NTMzEyDvfS2qOa5q+PDhdO7cGbvdzooVK9i1axfw/38ZNWjQ4Lxfv1lZWRd8Dy9ljqv6+w+bHTt2cPDgQXx8fNi6dSsdOnSgZcuWPPTQQ3lzsrKy8v0h9M+fE0U1x1UZhsHVV19Nw4YNOXr0KJ6enhw6dIj27dvjcDgYM2ZMvvfnn873Hv6XOeVJQX7PleScgtCRm/8oIiKCnJwcEhMT88YcDgfx8fHUqlXLwspKv/fff5+nnnqKb7/9lmuuuSbfYxEREcTFxeUb+3v77/e1qOa4qtDQUBISEhgzZgxjxozhvffeA+Cdd97hm2++Acz3Jz4+Pt+tlklJSWRmZuZ7D4tijquqXbs2APfccw8+Pj4ANG/enK5du7J8+XLAfH+Ac34t/vM9LIo5rurw4cNs3ryZoUOH5oWPiIgIevfuzQ8//ACY39M2m+2C709RzSlPIiIiOH36dL42EtnZ2Zw6dSrf12ZJzSmQAl+dI+d06tQpw8vLy/jkk0/yxn7//XcDMLZt22ZhZaXb+++/b3h7exs//vjjOR+fPXu24e7ubhw7dixv7JFHHjHq1KlT5HPKi3NdULxjxw4DyHcr8YwZMwxPT0/j5MmTRTrHVTmdTqNWrVrGG2+8kW+8WbNmxogRIwzDMO8mCw4ONl5//fW8x/++GWHp0qVFOsdVpaWlGTabzZgxY0a+8SuvvNK48cYb87Y7duxo9O3bN287JSXF8Pf3N959990in+NqzndBcVxcnOHu7m7MmTMnb+y7774zbDabceDAgRKfUxAKN0Vg3LhxRkhIiDFt2jTjyy+/NGrWrGkMHDjQ6rJKrc8++8yw2WzGmDFjjOXLl+d9xMbG5s2x2+1Gu3btjHbt2hnfffedMWHCBMPDwyPfF3xRzSkvzhVuDMMw7r33XqNmzZrGF198YUyfPt0ICQk5686foprjqmbPnm2EhIQYU6ZMMX777TfjvvvuM/z9/fP1+Xn33XcNX19f47333jPmzp1rNGrUyLjuuuvyPU9RzXFV999/v1GpUiXjww8/NBYuXGg8/vjjhs1myxeq//rrL8PDw8N4+umnje+//97o2bOn0aBBg3x3RxbVHFexbds2Y/ny5cYjjzxiBAcH5/1MTk9Pz5vz+OOPG2FhYcann35qzJw506hSpYrx4IMP5nuekpxzMVoVvAgYhsFnn33Gt99+i91u5+qrr2bEiBFnXWQsphdeeIE///zzrPEGDRrw6aef5m0nJyczceJE1q5dS0hICPfffz/XXnttvn2Kak55sGvXLu6//35mzZpFnTp18sbtdjvvv/8+v/32Gx4eHtx8883cf//92Gy2Ip/jyn7//Xc++eQTTp8+TaNGjXjssceoV69evjlz5szh66+/JiMjg+7duzNy5Eh8fX2LZY4rcjgcfPbZZ/z++++cPn2aiIgIhgwZQvv27fPNW758OR988AEJCQm0atWKMWPGULly5WKZ4wqeeuopVq5cedb4P39WOJ1OPv74Y3744QcMw+D6669n+PDhuLu7580vyTkXo3AjIiIiLkUXFIuIiIhLUbgRERERl6JwIyIiIi5F4UZERERcisKNiIiIuBSFGxEREXEpCjciIiLiUhRuRKRI7Nq1i4ULF1pdBg6Hg+XLlzN37lx2795tdTkiYgGtCi4iBbZlyxYOHjxIlSpVaNWqFd7e3nmP/fjjj3zxxRdcffXVltVnGAZXXHEF8fHxtGzZksDAQBo2bGhZPSJiDYUbEbmohIQEbrzxRg4cOEC7du04ffo0x44dY9y4cdx3330ANG7c+KzV3Uva7t27WbJkCceOHaNatWqW1iIi1lG4EZGLGj16NJmZmRw8eDBvDaPExMR8a4Q1aNAg33pqs2fPPut53Nzc6NOnT9723r172bp1K1WqVKFt27b5jgSdT0xMDIcOHSI8PJx27drlje/evTvvNf/88088PT25+eab8fHxybf/oUOHWL16NQD+/v40bdr0rDWgtm7dSnx8PF27dmXVqlUkJiZyxx13sGjRIipVqkT16tVZu3Ytfn5+9OjRg/Xr17Nv3z4AwsLCaNWqFZUqVcp7vs2bN3PixAmuuuqqfK+zceNGTp48yZVXXnnRz1tECk7hRkQuauvWrXTq1Cnf4oxhYWHcddddedv/Pi31/fff53uODRs2cOjQIfr06YPdbmfw4MH88ssvdOjQgaNHj5Kens6CBQto0qTJOWvIyMjgxhtvZPPmzURFRbFhwwYaN27Mjz/+SGBgIPv27WP58uV5tbi5uXHttdeeFW6OHDmSV1tqairLly9n0KBBvPfee3lz5s2bx6xZs/D396dSpUpUrVqVO+64gxdffBG73U5cXBzNmjWjU6dO9OjRg9jYWBYtWgTAiRMniImJYerUqfTv3x8wj3zdcMMNxMXFERYWlvc69957L1dddZXCjUhRK9Qa4iJSLj300ENGSEiI8emnnxrx8fHnnPPGG28YrVq1OudjW7ZsMQICAoyJEycahmEYr776qtG6dWsjJSUlb85jjz1mdOnS5bw1vPDCC0atWrXyXv/kyZNG7dq1jbFjx+bNWb58uQEYmZmZBf7cDh06ZAQHBxtLlizJG3v++ecNwPjxxx/zze3evbsREhJiHDly5ILPuWDBAiMoKCjv83M6nUbdunWNd955J29ObGysARg7d+4scK0iUjC6W0pELuq1115jwIABjBw5kipVqlC3bl1GjBjBiRMnLrpvUlISN910EzfddBOjRo0C4NNPP6VVq1YsXLiQb775hrlz5xIaGsrq1avJyso65/PMnj2bwYMHU7lyZcA8cvTAAw+c8/TXxWRlZbFy5UrmzZvHqlWrqF69OuvWrcs3p06dOvTu3fusfW+55RZq1qx51nhiYiKLFi1i7ty5pKWlkZaWxs6dOwGw2Wzcd999fPrpp3nzP/nkE7p06UKjRo0KXb+IXJhOS4nIRQUEBDB58mTeeecdtmzZwrJly3jzzTf5+eef2bJlCwEBAefcz26306dPHypWrMj06dPzxg8ePEhYWBjz5s3LN/+OO+4gIyPjrFNJYF4rU7du3Xxj9erV4/DhwxiGgc1mK9DnsnLlSm699VbCwsKoV68efn5+nD59moSEhHzzzndB8rnG33vvPcaOHUvLli2pVq1a3rVH/3zOe++9l+eff57o6GhatGjBV199xRtvvFGgmkWkcBRuRKTA3N3dad26Na1bt6ZDhw507NiRVatWnXWh7N+eeOIJtm3bRnR0dL7AEhQUxM0338zo0aML/NphYWEkJSXlG0tKSiI0NLTAwQZg1KhR9O/fn7feeitvLCoqCsMw8s0733P+ezwjI4PHH3+c+fPnc8MNNwCQlpbGnDlz8j1n9erVue6665gxYwbdu3cnJycn38XVIlJ0dFpKRC7qwIEDZ439ffooJCTknPt8+umnfPTRR8yfP58aNWrke+yaa65hxowZ5OTk5BuPi4s7bw1du3blu+++yzc2b948unbtWpBPIc+JEyfynQras2cPmzdvLtRz/FNiYiIOhyPfc/77iNTfBg8ezNdff83UqVPp06fPeY94ich/oyM3InJRTz31FAkJCfTq1YtatWpx6NAhpk6dyjXXXENkZORZ848fP87w4cO57rrrOHjwIAcPHgT+/1bw119/nW7dutGhQwcGDRqEh4cHK1asIDMzkwULFpyzhpdeeol27dpx2223cc011/DHH3+wdu1a1q5dW6jP5eabb2b8+PFkZ2eTm5vLO++8g5+fX6Hfk7+Fh4fTtm1bBg0axODBg9m7dy+ffPIJbm5n/+14/fXX4+fnx9KlS3nllVcu+TVF5MIUbkTkoubOncvKlSv5/fffWbx4MWFhYXzwwQfceOONuLu7A/mb+BmGwc033wzkvyXc3d2dPn36UKNGDTZt2sTMmTOJiYkhMDCQ2267jdtuu+28NdSrV4+NGzcybdo0li9fToMGDXj99depU6dO3pxKlSpx55135tV0LhMnTqRRo0asXbsWf39/Zs2axZo1awgPD8+b07x583Pu27NnTxo3bpxvzGaz8ccff/D++++zdOlSatSowapVq3jxxRfPOmLl7u5O7969Wbp0KV26dDlvjSLy39iMf59oFhGRYuF0OqlXrx4PPfQQTz75pNXliLgsHbkRESkB33//PT///DMZGRkMHTrU6nJEXJouKBYRKQG//fYb7u7u/P777wQFBVldjohL02kpERERcSk6ciMiIiIuReFGREREXIrCjYiIiLgUhRsRERFxKQo3IiIi4lIUbkRERMSlKNyIiIiIS1G4EREREZeicCMiIiIu5f8AVHM899VVL+IAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -196,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -244,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -351,9 +372,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -381,7 +423,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -445,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -482,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -539,9 +581,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGxCAYAAACKvAkXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaNtJREFUeJzt3Xd4VGX6xvFvei9AKAlJKEnoLaELgoggYqULttVFV1fErou79t+KSrGA6651rRSxgA0EKdJrKKEGQgIJkAQCSSB1Muf3x0CGWUCHEHKSzP25Lq7dnPeck2eGkLk957zv42YYhoGIiIiIC3E3uwARERGRqqYAJCIiIi5HAUhERERcjgKQiIiIuBwFIBEREXE5CkAiIiLichSARERExOUoAImIiIjL8TS7gOrKarVy6NAhgoKCcHNzM7scERERcYJhGOTn5xMREYG7+4Wv8ygAXcChQ4eIiooyuwwRERGpgIMHDxIZGXnBcQWgCwgKCgJsb2BwcLDJ1YiIiIgz8vLyiIqKKv8cvxDTA1B2djYzZ84kMzOT9u3bM3z4cDw8PCrlmFWrVrF48WL8/f0ZNWoUjRs3drquM7e9goODFYBERERqmD96fMXUh6D37dtH+/bt+e677ygrK2PChAkMHjyYsrKySzrGarVy9913c9NNN3H8+HGOHz/O4MGD2bVrV1W8LBEREanm3MzsBj98+HCOHDnCb7/9hru7O6mpqbRo0YKPP/6Y2267rcLHTJ8+naeffprNmzcTFxcH2C6JFRYW0rBhQ6dqy8vLIyQkhNzcXF0BEhERqSGc/fw27QqQxWLhxx9/5Lbbbit/Srtp06b07duX77777pKOmT59OmPGjCkPP2C7leVs+BEREZHazbRngNLS0igqKiImJsZhe0xMDKtXr67wMfn5+ezevZtnnnmG7777jo0bNxIREcHQoUN/NwAVFxdTXFxc/nVeXt4fvgar1UpJSckf7ieVz8vL6w+fFRMREbkQ0wJQQUEBwDmXp0JCQjh16lSFj8nNzQVgypQpNGrUiF69evHDDz/w9NNPs2jRIrp163bec0+cOJEXX3zR6fpLSkrYv38/VqvV6WOkcoWGhtKoUSOt0yQiIhfNtAAUGBgIwIkTJxy2nzhx4oJT15w55sz/1q1blwULFpTvc9111zFhwgR+/fXX8557woQJPPbYY+Vfn5lGdz6GYXD48GE8PDyIior63YWWpPIZhkFBQQFZWVkAhIeHm1yRiIjUNKYFoOjoaAICAti9ezeDBg0q375r1y5at25d4WNCQkKIiIiga9euDsd27dqVzz777IL1+Pj44OPj41TtFouFgoICIiIi8Pf3d+oYqVx+fn4AZGVl0aBBA90OExGRi2LapQsPDw+GDh3KJ598Uv7sTVJSEitWrGDEiBHl+3311VdMmTLloo659dZbWbZsWfntKcMwWLp0KR06dKiU2s9Muff29q6U80nFnAmfpaWlJlciIiI1janT4A8fPsyVV15JYGAgCQkJ/PDDDwwcOJDPP/+8fJ+xY8eyZs0akpKSnD4mNzeX/v37U1ZWRs+ePVm3bh3Z2dksXrz4nAeoL+T3ptEVFRWxf/9+mjVrhq+vbyW8E1IR+nsQEZH/5ew0eFMDENgebP7hhx/KV3W+6qqrHMZ/+eUXDh06xJ/+9CenjwHbVYH58+eTlpZGdHQ0AwcOvKgPSQUg50ydOpWmTZsydOjQKv/e+nsQEZH/VWMCUHVVGwPQxx9/zMqVKwHbNPKoqCiGDBlywWeu/te0adNo0KABo0aNKt92zTXX0KVLF1599dXLUvPvqal/DyIicvlU+4UQpeotW7aM5cuX06NHDzp06EBSUhLt27fn22+/der4BQsWXHCNJhERkZrE9GaoUrXCw8MZO3YsAA888AAnT57kpZdewt/fn2XLlvHKK6847P/FF1+QkZFB/fr12bp1K6mpqeXH/9///V/5fkuXLmXRokWUlZUxYsQIEhISHM6TlJTErFmzyMnJoUOHDtx5553lM7nAfiutbt26v3seERGp+bYcPMG2jFxu79HEtBp0BcjFtWvXjoMHD9K8eXMmTpxY/rA52Fa6njBhAp6ensTExFCnTh3Cw8Pp0aMHPXr0KA8wn3/+OS+88AL16tXj2LFj9OjRg02bNpWf5+effyYhIYHDhw/TtGlTpk+fTu/evR1W0f7pp58YP378755HRERqNqvV4P3fUhj27iqem5vEhtQc02rRFaBKYBgGhaUX7mB/Ofl5eVR4JeSysjJ+/fVX2rVrR1xcHH369OGjjz5i6tSpACxcuJAjR45wxx13UL9+faKiooiNjS2/AnRG3bp1+fXXX8vX4tm7dy+ffPIJCQkJGIbB+PHjGT9+PJMnTwbg3nvvpVmzZrz33nuMGzfOqfOIiEjNlnOqhCe+2sLiXbZFbAe1bURcg/MvfFwVFIAqQWFpGW2eW/DHO14GO166Fn9v5/8ad+/ezdixY7FYLKxZs4bc3Fx+/PFHwBZMHnvsMV577TW8vLz46KOPuOGGG6hfv/7vnrNfv34OCxG2bNmS9PR0ADIyMti7dy+jR48uHw8NDeX6669n2bJlDgHo984jIiI119qUYzw8czNH8orw9nTn2RvacHv3aFNbGekWmIsJDg6mR48e9OvXj3feeYeUlJTyKyzDhw+ntLSU77//npycHObOncs999zzh+c8+1kesC1YeWaxyDPtKsLCwhz2CQsLIzMz0+nziIhIzVNmNXhrUTKj31/DkbwimtcP4Lu/9uKOHk1M7+OoK0CVwM/Lgx0vXWva974YZz8E/b98fX25/fbb+eijj8jIyKBu3bpcd9115eMV+WE9008tLS2NJk3sD7udWZ9JRERqp8y8Ih6emciaFNtzPsMSInnp5rYE+FSP6FE9qqjh3NzcLuo2VHV27733kpCQwO7du7nrrrscbknVrVuXnJyLe2Ctfv369OnTh7feeovevXvj7u7Ozp07+emnn5g5c2Zlly8iItXAkt1ZPD57CzmnSvD39uDlm9sxrHOk2WU5qB2f2lJpOnToQHx8PBs2bODuu+92GLv55pu5/fbbKSkpITAw0GEa/O/517/+xcCBA0lISCA2NpZFixYxZswYhgwZcjlegoiImKTEYmXyL7t577cUAFqHBzN9TDwx9QNNruxcCkAu5J577iE/P/8P94uPj8fX15cWLVo4bB86dCgbNmxgy5YtnDp1Cj8/Px5//PFznu+57bbbOHXqVPnXbdu2JTk5mcWLF3P8+HGeffZZOnbs6HCMM+cREZHq62BOAeNmJLLl4AkA7uzZhGcGt8b3Ih/VqCpqhXEBtbEVhjPy8vJo0qQJ77zzDmPGjDG7nN9Vm/8eRERqkp+2Hebpr7eSX2Qh2NeT14d3YFC7cFNqcbYVhq4ASbknn3yShQsX0rx5c0aOHGl2OSIiUs0VlZbx8g87+GLtAQDio0N5+9Z4our6m1zZH1MAknIJCQl069aN6667Dk9P/WiIiMiF7c06ybgvN7HriO3Rivv7xvD4wBZ4edSMFXb0KSflzl6sUERE5HwMw2DOxnSem7udwtIy6gV4M3VUJ/q2+P1Fc6sbBSARERFxysliC89+l8S3iRkAXBFTjzdHdaJBcM17DlMBSERERP5QUkYuD81IZP/RU7i7waPXtOCv/WLxcDd3ReeKUgASERGRCzIMg09WpfLKT7soKbMSHuLLW7fG061ZXbNLuyQKQCIiInJeuQWlPDlnC7/ssPVuvKZ1AyYN70idAG+TK7t0CkAiIiJyjo1pOYyfsZmME4V4ebgx4brW3N2rqelNTCuLApCIiIiUs1oN/v3bPqb8socyq0GTev5MH51A+8gQs0urVApALmTDhg2kpqYC4OXlRWRkJB06dMDLy6vSvkdGRgYbN27kpptuqrRziohI1cjOL+ax2ZtZnnwUgBs7RvDKkHYE+Vbe50R1oQDkQqZPn86PP/5I3759sVgsJCYm4unpybx582jbtm2lfI/Vq1czduxYTpw4USnnExGRqrEi+SiPzNrM0ZPF+Hq588KNbRnVNarW3PL6XwpALqZt27bMmTMHgJKSEq644goefvhhFi1aBMDevXvZv38/AwYMKD8mMzOTlStXMnTo0PJteXl5bNq0CbCtIB0cHEx2djZr1qyhtLS0/Hu0atWKdu3aVdXLExGRi2Qps/LGoj38a+k+DANaNAxk+pgEWjQMMru0y0oByIV5e3szcOBA3n///fJtP/zwAx988AFJSUnl2xITExk5ciQWiwWAJUuWMGzYMFq2bElgYCD79u3j7bffplmzZqxcuZLS0lJmzpwJwJAhQxSARESqqYwThTw8I5ENaccBGN0tiuduaIufd/Xs4F6ZFIAqg2FAaYE539vLHy7h8mRKSgphYWEXdczEiRP585//zKRJkwDIzc1l7dq1tG3blscff5yxY8eWXwESEZHqaeGOTJ74agu5haUE+ngycWh7buwYYXZZVUYBqDKUFsArJv3QPHMIvAOc3j07O5s5c+ZgsVhYu3Yt33zzDZ999tlFfUsfHx/S0tIoLCzEz8+PkJAQBg4ceLGVi4iICYotZUz8aRf/XZUKQIfIEKaNjqdJPec/S2oDBSAXk5WVxcyZMykuLmbVqlVcd911DBky5KLO8frrr3PPPfdQv359evXqxQ033MC9996Lr2/N6wUjIuJK9h89xUMzNpGUkQfAn3s34+lBrfD2rBkd3CuTAlBl8PK3XYkx63tfhLMfgs7MzKRLly787W9/Y+rUqQC4u7tjtVodjikqKnL4unXr1qxevZrDhw+zePFi/vnPf7JgwQJ++OGHS3ghIiJyOc3dnMEz32zjVEkZdfy9mDyiI/1bNzS7LNMoAFUGN7eLug1VXTRs2JApU6YwZswY7r33Xlq3bk3jxo3JyMiguLgYHx8fAJYtW+Zw3OHDhwkPDyc8PJzbbrsNq9XKww8/DEBgYCDFxcVV/lpEROT8CkosvDBvO7M3pAPQrWld3hrdifAQP5MrM5cCkIsbOXIkkydPZsKECXz33XcMGDAAX19fbr31VoYMGcKGDRuYPXu2wzG33347UVFR9OrVi7KyMt544w2GDRsGQPv27SkrK+PZZ5+lY8eOmgYvImKiXUfyGPdlInuzTuLmBg/1i2V8/zg8PVzvltf/0jvgQrp27Urfvn3P2f7mm2/i5eXF4cOHCQ4OZu3atcTGxrJ06VJatmzJvHnzygMOwIIFC7j66qtZt24diYmJPPvss7z77rsANG7cmJ9//pmjR48ya9YstmzZUmWvT0REbAzD4Iu1adw8fSV7s05SP8iHL/7cnccGtlT4Oc3NMAzD7CKqo7y8PEJCQsjNzSU4ONhhrKioiP3799OsWTM9+Gsi/T2IiJwrr6iUCd9s48ethwHo06I+U0d2JCzQx+TKqsbvfX6fTbfAREREaoktB0/w0IxEDuQU4OnuxpPXtuTeK5vj7l4721lcCgUgERGRGs5qNfhwxX5em78Li9Ugso4fb4+OJyG6jtmlVVsKQCIiIjVYzqkSHp+9mSW7swG4rl0jXh3WgRC/2tfBvTIpAImIiNRQa1KO8fDMRDLzivH2dOfZG9pwe/foWtvBvTIpAImIiNQwZVaDaYuTefvXZKwGNK8fwPTRCbSJuPBDv+JIAegSaAKdufT+i4gryswr4uGZiaxJyQFgWEIkL93clgAffaRfDL1bFeDh4QFASUkJfn6uvZKmmQoKCgDw8tJ9bhFxDUt2Z/H47C3knCrB39uD/7ulHUMTIs0uq0ZSAKoAT09P/P39yc7OxsvLC3d3LSpVlQzDoKCggKysLEJDQ8sDqYhIbVVisTL5l92891sKAK3Dg5k+Jp6Y+oEmV1ZzKQBVgJubG+Hh4ezfv5+0tDSzy3FZoaGhNGrUyOwyREQuq4M5BYybkciWgycAuKtnEyYMbo2vl/7j71IoAFWQt7c3cXFxlJSUmF2KS/Ly8tKVHxGp9X7adpinv95KfpGFYF9PXh/ekUHt9B9+lUEB6BK4u7urBYOIiFS6otIyXv5hB1+sPQBAfHQo00bHE1nH3+TKag8FIBERkWpkb1Y+475MZNeRfADu7xvD4wNb4KUmppVKAUhERKQaMAyDrzam8/zc7RSWllEvwJupozrRt0V9s0urlRSARERETHay2MI/vt3Gd5sPAdArth5vjOxEg2A9ZnG5mH49bf78+Vx//fV06dKFu+++m9TU1Es+5uWXX6Zdu3YOf4YMGXJ5XoCIiMglSMrI5cZpK/hu8yHc3eCJgS349J7uCj+XmalXgObPn8+NN97Iyy+/TM+ePXnzzTfp3bs3SUlJhIaGVviYjIwMIiIimDp1avlxelhZRESqE8Mw+GRVKq/8tIuSMivhIb68PTqerk3rml2aS3AzTOwn0L17d1q0aMFnn30GQHFxMY0aNeLpp5/mb3/7W4WPuf/++zl69Chz5sypcG15eXmEhISQm5tLcLB6q4iISOU5UVDCU3O28suOTACuad2QScM7UCfA2+TKaj5nP79NuwV28uRJ1q9fz+DBg8u3+fj4cM0117BkyZJLPmb16tV069aNAQMG8NJLL5W3TRARETHTxrQcrn97Bb/syMTLw43nbmjD+3d2VvipYqbdAsvIyMAwDMLDwx22h4eHs3379ks6Jjg4mHHjxtG3b18yMjJ4/vnnmTt3LmvWrLlg36ji4mKKi4vLv87Ly6voSxMRETmH1Wrw7rJ9TF24hzKrQZN6/kwfnUD7yBCzS3NJpgUgi8UC2FZUPpuPjw+lpaWXdMwrr7yCp6f9pXXr1o3Y2FhmzZrF7bffft5zT5w4kRdffPHiX4iIiMgfyM4v5rHZm1mefBSAmzpG8M8h7QjyVTNns5h2C6xevXoAHDt2zGH7sWPHCAsLu6Rjzg4/AE2aNKFJkyYkJSVdsJ4JEyaQm5tb/ufgwYPOvxgREZELWJF8lOveWs7y5KP4ernz2rD2vHVrJ4Ufk5kWgBo1akRERARr16512L569Wo6d+5caccAlJaWkpWV9bsPQ/n4+BAcHOzwR0REpKIsZVYmLdjFHR+t5ejJYlo0DGTeuN6M6hqNm5ub2eW5PFPXAfrLX/7CBx98QEpKCgCffvope/bsYezYseX7PP/88w5r+PzRMSUlJTz77LPk59uWEC8uLmb8+PGUlJQwYsSIqnppIiLiwjJOFHLre2t4Z8k+DANGd4tm7oO9adEwyOzS5DRT1wF65plnSE1NpVWrVoSFhVFQUMBHH31Ep06dyvfJyMggOTnZ6WO8vLwIDAwkJiaGgIAAsrKyiI2NZcGCBcTFxVXxKxQREVfzy/YjPDlnK7mFpQT5ePLK0Pbc2DHC7LLkf5i6DtAZx48f5+jRo0RHR+Pj4+MwdujQIQoKCoiNjXX6GLAtMHXgwAHq1KlTodtZWgdIREQuRrGljIk/7eK/q1IB6BAZwvTRCUTXUwf3quTs53e1CEDVkQKQiIg4a//RU4z7chPbD9mWUBnbuxlPDWqFt6fpHadcjrOf32qGKiIicgm+S8zg799u41RJGXX8vZg8oiP9Wzc0uyz5AwpAIiIiFVBQYuH5udv5amM6AN2a1eWtWzsRHuJncmXiDAUgERGRi7TrSB7jvkxkb9ZJ3NzgoavjGH91LJ4euuVVUygAiYiIOMkwDL5cd4CXvt9BscVKgyAf3ry1E1fEnH8BX6m+FIBERESckFdUyoSvt/HjtsMA9G1RnykjOxIWeO5MZKn+FIBERET+wOaDJ3hoxiYO5hTi6e7GU4NaMrZ3c9zdtaJzTaUAJCIicgFWq8GHK/bz2vxdWKwGkXX8mDY6nvjoOmaXJpdIAUhEROQ8jp0s5omvtrBkdzYA17VrxKvDOhDipyamtYECkIiIyP9Yk3KMh2cmkplXjLenO8/e0Ibbu6uJaW2iACQiInJamdVg2uJk3v41GasBzesHMH10Am0i1BGgtlEAEhERATLzinh4ZiJrUnIAGN45kpdubou/tz4qayP9rYqIiMtbsjuLx2dvIedUCf7eHvxzSDuGxEeaXZZcRgpAIiLiskosViYt2MX7y/cD0CY8mOlj4mleP9DkyuRyUwASERGXdOBYAQ/NTGTLwRMA3NWzCRMGt8bXy8PcwqRKKACJiIjL+XHrYf729Vbyiy0E+3ry+vCODGrXyOyypAopAImIiMsoKi3jpR928OXaAwAkRIfy9uh4Iuv4m1yZVDUFIBERcQl7s/IZ92Uiu47kA/DAVTE8NqAFXurg7pIUgEREpFYzDIOvNqbz/NztFJaWERbozdSRnejTor7ZpYmJFIBERKTWOlls4R/fbuO7zYcA6BVbjzdGdaJBkK/JlYnZFIBERKRWSsrI5aEZiew/egoPdzceG9CC+/vG4KEO7oICkIiI1DKGYfDJqlRe+WkXJWVWIkJ8eWt0PF2b1jW7NKlGFIBERKTWOFFQwpNztrJwRyYA17RuyOQRHQj19za5MqluFIBERKRW2JiWw0NfJnIotwgvDzcmXNeau3s1VQd3OS8FIBERqdGsVoN3l+1j6sI9lFkNmtbzZ9roBNpHhphdmlRjCkAiIlJjZecX89jszSxPPgrAzZ0i+L9b2hHk62VyZVLdKQCJiEiNtDw5m0dnbeHoyWJ8vdx56aZ2jOgSqVte4hQFIBERqVEsZVamLtzDu8v2YRjQsmEQ08fEE9cwyOzSpAZRABIRkRoj40Qh42cksjHtOACju0Xz/I1t1MFdLpoCkIiI1AgLth/hqTlbyS0sJcjHk4nD2nNDhwizy5IaSgFIRESqtWJLGRN/2sV/V6UC0CEyhOmjE4iupw7uUnEKQCIiUm3tP3qKcV9uYvuhPADG9m7GU4Na4e2pDu5yaRSARESkWvouMYO/f7uNUyVl1PH3YsrIjlzdqqHZZUktoQAkIiLVSkGJhefnbuerjekAdGtWl7du7UR4iJ/JlUltogAkIiLVxq4jeYz7MpG9WSdxc4PxV8cxvn+cOrhLpVMAEhER0xmGwZfrDvDS9zsotlhpEOTDW7fG0zOmntmlSS2lACQiIqbKLSzlmW+28eO2wwBc1bI+U0Z0pF6gj8mVSW2mACQiIqbZfPAE477cRPrxQjzd3XhqUEvG9m6Ou255yWWmACQiIlXOajX4cMV+Xpu/C4vVILKOH9NGxxMfXcfs0sRFKACJiEiVOnaymCe+2sKS3dkADG7fiIlDOxDipw7uUnUUgEREpMqs3neMR2YlkplXjLenO8/d0Ibbukerg7tUOQUgERG57MqsBm//msy0xclYDYipH8D0MQm0Dg82uzRxUQpAIiJyWR3JLeLhmYms3Z8DwPDOkbx0c1v8vfURJObRT5+IiFw2S3Zl8fhXW8g5VUKAtwf/N6QdQ+IjzS5LRAFIREQqX4nFyqQFu3h/+X4A2oQHM31MPM3rB5pcmYiNApCIiFSqA8cKeGhmIlsOngDgrp5NmDC4Nb5eHuYWJnKWahGASkpKyMvLo169ek7PBHD2mNLSUjIzMwkKCiIkJKSyShYRkfP4ceth/vb1VvKLLQT7evL68I4MatfI7LJEzuFu5je3Wq08/vjjhIaG0rRpUyIjI/n2228r9Zj77ruPqKgonn/++couX0RETisqLeOZb7fx4JebyC+20LlJHX56+EqFH6m2TA1AU6ZM4eOPP2bVqlXk5eXx9NNPM2rUKHbu3Fkpx8yYMYPt27fTtm3by/kyRERc2t6sfG55ZyVfrj2Amxv89aoYZt7Xg8g6/maXJnJBpgagd955h7Fjx9KpUyfc3d0ZP3480dHRvPfee5d8zL59+3j88cf54osv8PSsFnf6RERqFcMwmL3+IDdOW8muI/mEBXrz6T3deGpQK7w8TP14EflDpiWDrKws0tLS6NWrl8P23r17s27duks6pqSkhFtvvZWXXnqJuLi4yi9eRMTFnSy28PdvtzF38yEAeseGMXVURxoE+ZpcmYhzTAtA2dm2HjBhYWEO28PCwli1atUlHTNhwgQiIyMZO3as0/UUFxdTXFxc/nVeXp7Tx4qIuJKkjFzGfbmJ1GMFeLi78diAFjzQN0Yd3KVGMS0AubvbLo9aLBaH7aWlpXh4nH+qpDPHLF26lI8//pjFixeTnp5ePn7y5EnS09OJjDz/AlwTJ07kxRdfrPgLEhGp5QzD4JNVqbzy0y5KyqxEhPjy1uh4ujata3ZpIhfNtADUuHFjAI4cOeKwPTMzs3ysIsekpqbi7+/PDTfcUD6elZXFgQMHmD9/PmlpaecNWBMmTOCxxx4r/zovL4+oqKgKvDIRkdrnREEJT87ZysIdmQBc07ohk0d0INTf2+TKRCrGtKfUgoOD6dSpEwsXLizfZrFY+PXXX+nTp0/5tuPHj5OZmen0MX/6059IT093+NOmTRv+/Oc/k56efsGrSz4+PgQHBzv8ERER2JCaw+C3lrNwRybeHu48f2Mb3r+zs8KP1GimTo969tlnGTVqFF27dqVnz55MnjwZgAceeKB8nyeffJI1a9aQlJTk9DEiInLprFaDd5ftY+rCPZRZDZrW82f6mATaNdaislLzmTpPcejQoXz++ed88sknDBkyhLy8PJYtW0b9+vXL96lbty6NGjW6qGP+V8OGDQkNDb2cL0VEpFbJyi/izo/WMWnBbsqsBjd3iuCH8Vcq/Eit4WYYhmF2EdVRXl4eISEh5Obm6naYiLiU5cnZPDprM0dPluDn5cGLN7dlROdIp1sViZjJ2c9vrRAoIiIAWMqsTF24h3eX7cMwoGXDIN65LZ7YBkFmlyZS6RSARESEjBOFjJ+RyMa04wCM6R7Ncze0UQd3qbUUgEREXNyC7Ud4as5WcgtLCfLxZOKw9tzQIcLsskQuKwUgEREXVWwpY+JPu/jvqlQAOkaGMG10AtH11MRUaj8FIBERF5SSfZKHZiSy/ZCt7c+9VzbjyWtb4e2pJqbiGhSARERczLeJ6fzj2yROlZRRx9+LKSM7cnWrhmaXJVKlFIBERFxEQYmF5+ZuZ85GW5/E7s3q8tat8TQKUQd3cT0KQCIiLmDn4TzGfbmJfdmncHeDh66OY3z/ODzUwV1clAKQiEgtZhgGX647wEvf76DYYqVBkA9v3RpPz5h6ZpcmYioFIBGRWiq3sJRnvtnGj9sOA3BVy/pMGdGReoE+JlcmYj4FIBGRWmjzwROM+3IT6ccL8XR346lBLRnbuznuuuUlAigAiYjUKlarwQcrUnh9/m4sVoPIOn5MGx1PfHQds0sTqVYUgEREaoljJ4t5/KstLN2dDcD17cN5ZWh7Qvy8TK5MpPpRABIRqQVW7zvGI7MSycwrxsfTnedubMOYbtHq4C5yAQpAIiI1WJnV4O1fk5m2OBmrATH1A3jntgRaNQo2uzSRak0BSESkhjqSW8TDMxNZuz8HgBGdI3nx5rb4e+tXu8gf0b8SEZEaaMmuLB7/ags5p0oI8Pbg/4a0Y0h8pNllidQYCkAiIjVIicXKpAW7eH/5fgDaRgQzbXQ8zesHmlyZSM2iACQiUkMcOFbAQzM2sSU9F4A/XdGUCYNb4ePpYXJlIjWPApCISA3ww9ZDTPh6G/nFFkL8vHh9eAeubdvI7LJEaiwFIBGRaqyotIwXv9/BjHUHAOjcpA5vj46ncaifyZWJ1GwKQCIi1VRyZj7jvkxkd2Y+bm7w16tieOSaFnh5uJtdmkiNpwAkIlLNGIbBVxvSeX7edgpLywgL9OGNUR25Mq6+2aWJ1BoKQCIi1cjJYgt//3YbczcfAqB3bBhTR3WkQZCvyZWJ1C4KQCIi1URSRi7jvtxE6rECPNzdeGxACx7oG6MO7iKXgQKQiIjJDMPgv6tSmfjTLkrKrESE+PL26Hi6NK1rdmkitZYCkIiIiU4UlPDknK0s3JEJwIA2DZk0vAOh/t4mVyZSuykAiYiYZH1qDg/PSORQbhHeHu48M7gVd13RVB3cRaqAApCISBWzWg3eXbaPqQv3UGY1aFrPn+ljEmjXOMTs0kRchgKQiEgVysov4rFZW1ix9ygAt3SK4P+GtCfQR7+ORarSRf+LS01NZfbs2fz222+kp6cDEBUVRZ8+fRg5ciRNmjSp9CJFRGqD5cnZPDprM0dPluDn5cGLN7dlROdI3fISMYHTy4mmpKQwfPhw4uLi+Pzzz2nYsCGDBw9m8ODBNGjQgE8//ZTY2FhGjBhBSkrK5axZRKRGKS2z8vr8Xdz50TqOniyhZcMgvn+oFyO7RCn8iJjE6StAPXv25L777mPy5Mk0bdr0vPukpqby4Ycf0rNnTzIzMyurRhGRGiv9eAEPz9zMxrTjAIzpHs1zN7TB10sd3EXM5GYYhuHMjseOHaNevXpOnfRi9q2u8vLyCAkJITc3l+DgYLPLEZEaaMH2Izz51RbyiiwE+Xjy6rAOXN8h3OyyRGo1Zz+/nb4C9HuBxjAM9u3bR6NGjQgMDKzx4UdE5FIUlZYx8aedfLI6DYCOkSFMG51AdD1/kysTkTMq1FJ4/fr1PPjgg+Vfjxkzhri4OBo1asTy5csrrTgRkZomJfskQ/+1qjz83NenOV/df4XCj0g1U6F5l0888QSvvPIKAFu3buXnn39mw4YNLFiwgL///e/89ttvlVqkiEhN8G1iOv/4NolTJWXUDfBmyoiO9GvVwOyyROQ8KhSANm7cSEJCAgALFy5k6NChdO7cmZYtW/Lqq69WaoEiItVdQYmF5+ZuZ85G29Ig3ZvV5a1b42kUog7uItVVhW6BBQcHl091//777+nXrx8AJ06c0APDIuJSdh7O48ZpK5izMR13N3i4fxxf3ttD4UekmqvQFaCRI0dy/fXX06ZNG7Zt28YNN9wAwPz58xk8eHClFigiUh0ZhsEXaw/w0g87KLFYaRjsw5uj4ukZo0kgIjVBhQLQ5MmTiYuLIy0tjYkTJ1KnTh0A9u3bx3PPPVepBYqIVDe5haVM+GYrP207AkC/lvWZPKIj9QJ9TK5MRJzl9DpArkbrAInI+SQeOM5DMxJJP16Ip7sbTw9qxZ97N8PdXSs6i1QHzn5+O/0M0IgRI9i1a9cf7rdjxw5GjBjh7GlFRGoEq9Xgvd/2MeLfq0k/XkhUXT/mPHAF9/ZprvAjUgM5fQusR48e9OjRg/j4eG688UY6d+5Mw4YNMQyDI0eOsH79eubNm8e2bdt49tlnL2fNIiJV6tjJYh7/agtLd2cDcH37cCYOa0+wr5fJlYlIRV3ULbBjx47xn//8h5kzZ5KUlMSZQ93c3Gjfvj2jR4/m3nvvrRUrQesWmIgArN53jEdmJZKZV4yPpzvP39iW0d3UxFSkunL287vCzwDl5uaSkZGBm5sbERERhISEVLjY6kgBSMS1lVkN3vo1mWmLkzEMiKkfwDu3JdCqkX4fiFRnld4L7H+FhIRUSugpLS1l6dKlZGZm0r59ezp27Fgpx5w4cYLVq1dz8uRJ2rZtS5s2bS65VhFxDUdyixg/M5F1+3MAGNE5khdvbou/d4V/ZYpINVOhhRAB8vPz+frrr5k0aVL5tp07d3IxF5SOHTtG165deeCBB/j666/p06cP48aNu+Rjpk+fTkJCAv/+97+ZOXMmPXv2ZOTIkVgslot7kSLichbvyuS6t35j3f4cArw9eHNUJyaN6KjwI1LLVOhf9K5duxgwYABWq5VDhw7x5JNPAvDqq69y7bXXMmbMGKfOM2HCBEpLS9myZQsBAQGsX7+e7t27c/3113PddddV+JiYmBh27NiBr69tJdbdu3fTqlUrRo8ezZAhQyrykkWkliuxWHl9/i4+WLEfgLYRwUwfk0CzsACTKxORy6FCV4AeffRR7rjjDtLT0x22jx8/nsmTJzt1DqvVyqxZs7jnnnsICLD9gunatSs9evRgxowZl3TMddddVx5+AMLDw/Hw8KCkpOSiXqeIuIYDxwoY8e9V5eHnT1c05Zu/XqHwI1KLVegK0OrVq5kxY8Y5syBatWrF9u3bnTrHwYMHycvLO+fZnLZt27Jx48ZLPiY9PZ358+eTl5fHrFmzGDVqFMOGDbtgPcXFxRQXF5d/nZeX59TrEJGa7Yeth5jw9Tbyiy2E+HkxaXgHBrZtZHZZInKZVSgAGYZRHhbODkEpKSlOPxh9JmCcaaNxRt26dS8YPi7mmNzcXNasWcPRo0c5cOAA/fr1+91pqxMnTuTFF190qnYRqfmKSst48fsdzFh3AIAuTerw1uh4Gof6mVyZiFSFCt0CGzhwIK+//jpgD0BZWVmMGzfugs/u/C8/P9svmfz8fIft+fn55WOXckzbtm354IMP+O6771i5ciX/+te/+M9//nPBeiZMmEBubm75n4MHDzr1OkSk5knOzOfm6SuZse4Abm7wYL8YZt7XQ+FHxIVUKABNnTqV7777jri4OKxWK1deeSXNmzcnIyODV1991alzREdH4+XlRWpqqsP2/fv3ExsbW2nHADRv3pyEhARWr159wX18fHwIDg52+CMitYthGMxef5Abp69gd2Y+YYE+fHpPN568thWeHhWeFCsiNVCF/sVHRUWxdetWnnrqKe677z5atWrFpEmT2Lx5M+Hh4U6dw9vbm2uvvZaZM2eWT50/fPgwS5Ys4cYbbyzfb8WKFXzzzTdOH2OxWMjIyHD4Xrm5uezYsYPmzZtX5OWKSC2QX1TKI7M289TXWykqtXJlXBg/PdybK+Pqm12aiJjA1G7wO3bs4IorruDqq6+mR48efPLJJ4SGhrJ06VK8vGw9dsaOHcuaNWtISkpy6pji4mI6d+5M7969adOmDSdOnODzzz/Hx8eHpUuXOt2mQytBi9Qe29JzeWjGJlKPFeDh7sZjA1rwQN8YNTEVqYUueysMsE1LLygoOGd7YGCg0+c4cOAA//3vf8tXdb777rvx8fEpH//kk09ISUlxeED5j44pLi5m1qxZJCYmEhAQQHx8PLfccgseHh5O16UAJFLzGYbBf1el8spPOyktM4gI8eXt0fF0aVrX7NJE5DK5rAFo9+7d3H///axateq8a+uYeFGp0igAidRsJwpKeHLOVhbuyARgYJuGvD68A6H+3iZXJiKX02XtBXbXXXfRqFEj5s6dS2hoaEVrFBG5LNan5vDwjEQO5Rbh7eHO369vzZ09m6iDu4iUq1AA2rJlC/Pnz1f4EZFqpcxq8O7SvbyxKJkyq0HTev5MH5NAu8aX3rhZRGqXCgWgpk2bkpWVpQAkItVGVn4Rj87azMq9xwC4pVME/zekPYE+amIqIueq0G+Gl156ibvvvpvXXnuNmJiYcy4rN2qkZeRFpOr8tiebx2Zv5ujJEvy8PHjx5raM6BypW14ickEVCkD16tUjKSmJK6+88rzjteEhaBGp/krLrExduId3l+4DoFWjIKaPiSe2QZDJlYlIdVehAPTXv/6V66+/nr/+9a+6DSYipkg/XsD4GYlsOnACgNu6R/PsDW3w9XJ+uQsRcV0VCkAHDhxg3bp1mh4uIqZYsP0IT361hbwiC0E+nrw6rAPXd3BuFXoREahgAIqLiyM9PZ02bdpUdj0iIhdUVFrGxJ928snqNAA6RoUyfXQ8UXX9Ta5MRGqaCgWg22+/ndtvv53XXnuN2NjYcx40bNq0aWXUJiJSLiX7JOO+TGTH4TwA7uvTnCcGtsTbU01MReTiVWgl6D+aWVEbHoLWStAi1ce3ien8/dskCkrKqBvgzZSRHenXsoHZZYlINXRZV4JOTk6ucGEiIs46VWzhubnb+XpTOgA9mtflzVHxNArxNbkyEanpKhSAYmNjK7sOEREHOw/n8eCXm0jJPoW7G4zvH8dDV8fhoQ7uIlIJnA5ASUlJALRr1678/19Iu3btLq0qEXFZhmHwxdoDvPTDDkosVhoG+/DWrfH0aF7P7NJEpBZxOgC1b98esP1yOvP/L6Q2PAMkIlUvt7CUCd9s5adtRwDo17I+k0d0pF6gj8mViUht43QAOnz48Hn/v4hIZUg8cJyHZiSSfrwQLw83nh7Uint6NcNdt7xE5DJwOgA1atSIsWPH8sEHH6jXl4hUGqvV4P3lKUxasBuL1SCqrh/TRyfQMSrU7NJEpBa7qGnwbm5uLnN7S9PgRS6/YyeLefyrLSzdnQ3A9R3CmTi0PcG+XiZXJiI11WWdBi8icqlW7TvKIzM3k5VfjI+nO8/f2JbR3aLUwV1EqoQCkIhUKUuZlbcX72Xa4mQMA2IbBDJ9TDytGulKq4hUnYsOQJ6ef3yIxWKpUDEiUrsdyS1i/MxE1u3PAWBkl0heuKkt/t76bzERqVoX/Vtn+vTpl6MOEanlFu/K5PHZWzheUEqAtwevDG3PzZ0am12WiLioiw5A999//+WoQ0RqqRKLldfn7+KDFfsBaNc4mGmjE2gWFmByZSLiynTdWUQumwPHCnhoxia2pOcC8KcrmjJhcCt8PD1MrkxEXJ0CkIhcFt9vOcQz32wjv9hCiJ8Xk4Z3YGBbrSEmItXDRQWgwsLCy1WHiNQShSVlvPTDdmasOwhAlyZ1eGt0PI1D/UyuTETE7qICkK+v7+WqQ0RqgeTMfB78chN7Mk/i5gZ/vSqGR69pgaeHu9mliYg40C0wEblkhmHw1YZ0npuXRFGplbBAH94c1YnecWFmlyYicl4KQCJySfKLSvnHd0nM3XwIgCvjwpg6shP1g9TBXUSqLwUgEamwbem5PDRjE6nHCvBwd+PxgS24v0+MOriLSLWnACQiF80wDD5emcrEn3dSWmbQONSPt0d3onOTumaXJiLiFAUgEbkox0+V8OScrSzamQnAwDYNeX14B0L9vU2uTETEeQpAIuK09ak5jJ+RyOHcIrw93Pn79a25s2cTdXAXkRpHAUhE/lCZ1eDdpXt5Y1EyZVaDZmEBTBsdT7vGIWaXJiJSIQpAIvK7svKLeHTWZlbuPQbAkPjGvHxLOwJ99OtDRCrIaoWcFAiLNa0E/QYTkQv6bU82j83ezNGTJfh5efDSzW0Z3jlSt7xE5OIVHod9iyF5oe1PcT48vR+8zWmMrAAkIucoLbMydeEe3l26D4BWjYKYPiae2AZBJlcmIjWGYUBmEiT/Ygs8B9eBUWYf9w6C7N3QOMGU8hSARMRB+vECxs9IZNOBEwDc3iOaf1zfBl8vdXAXkT9QnA8pS0+HnkWQf8hxvH5riBsAcQMhqjt4mjd7VAFIRMrNTzrCU3O2kFdkIcjXk9eGdWBw+3CzyxKR6sow4Gjy6cCzANJWg7XUPu7lD836ng49AyA02rxa/4cCkIhQVFrGKz/t5NPVaQB0jApl+uh4our6m1yZiFQ7JQWQuuJ06PkFTqQ5jteNsV3hiRsATXqBV/VspK4AJOLiUrJPMu7LRHYczgPgvj7NeWJgS7w91cFdRE7L2X/64eVfIHU5WIrsYx4+0LS3PfTUizGvzougACTiwr7ZlM4/vkuioKSMugHeTBnZkX4tG5hdloiYzVIMaavsoedYsuN4SNTp21rXQrMrTZvJdSkUgERc0KliC8/N3c7Xm9IB6NG8Lm/dGk/D4Op5qVpEqkBuun2KespSKD1lH3P3hOie9geY67eCGr4chgKQiIvZeTiPB7/cREr2Kdzd4OH+LRh3dSwe6uAu4lrKSm1T089MU8/a7jge2NAeeJr3A99gc+q8TBSARFyEYRh8vvYAL/+wgxKLlYbBPrx1azw9mtczuzQRqSr5mbB3kS307FsCxbn2MTd3iOxqDz2NOtT4qzy/RwFIxAXkFpbyt6+38nPSEQCubtWAySM6UjdAHdxFajVrGWRsss/YOrzZcdy/HsReYws8MVeDf11TyjSDApBILZd44DgPzUgk/XghXh5uPD2oFX/u3UztLERqq4Ic2PurLfDsXQSFOY7jEfGnZ2wNtP1/d9dc5NT0ALRr1y7ef/99MjMzad++PQ8++CCBgYGXdExxcTEzZ85k1apVeHp60rt3b0aNGoW7u6b1iuuwWg3eX57CpAW7sVgNour6MX10Ah2jQs0uTUQqk9UKR7baZ2xlbADDah/3CYHYq22BJ/YaCNRMTwA3wzAMs775pk2buPLKKxk5ciQ9evTggw8+wGKxsGbNGnx8fCp0jNVqJS4ujj59+tCzZ08KCgqYPHkyXbp04dtvv3X6v3rz8vIICQkhNzeX4ODa9eCX1H7HThbz2OwtLNuTDcD1HcKZOLQ9wb5eJlcmIpWiKNf2DE/yQti7EE5mOo43bGd/lieyG3iYfr2jyjj7+W1qALr22mvx9PTkxx9/BODYsWNERUUxdepU7r///godYxgGhw4donHjxuXHrF69miuuuIL169fTpUsXp2pTAJKaatW+ozwyczNZ+cX4eLrz/I1tGd0tSre8RGoyw4DsXfYZWwdWg9ViH/cKgJh+ttATOwBCGl/4XLWcs5/fpkXC4uJiFi9ezHvvvVe+rV69evTv35+ffvrpvAHImWPc3Nwcwg9AZGQkAMePH79Mr0bEfJYyK28v3su0xckYBsQ2CGT6mHhaNVKAF6mRSk7B/t/soSf3oON4WAv76svRPcHz/HdO5PxMC0AHDhzAYrEQHe3YGC06Opply5ZV2jEA06ZNIzQ0lO7du19wn+LiYoqLi8u/zsvLc+ZliFQLh3MLeXjmZtbttz3sOKpLFM/f1AZ/b9e57C1SKxzbZ5+xlboCykrsY56+0KyP/Vmeus3Mq7MWMPUKEIC/v2OzxcDAQIqKis53SIWOmT17NlOmTGHGjBm/eyls4sSJvPjii07XL1Jd/Lozkye+2sLxglICvD14ZWh7bu7kupe/RWqU0iJIW2F/gDknxXE8NNrWbiJuoK3flrcaFFcW0wJQSEgIcO5tqWPHjhEaGlopx8ydO5c77riDd955h5EjR/5uPRMmTOCxxx4r/zovL4+oqKg/ehkipimxWHlt/i4+XLEfgHaNg5k+OoGmYTWvJ4+ISzmeZntwOXkhpCwDS6F9zN0Lmlxhn6YeFlerFyM0k2kBKDIykjp16rB161YGDx5cvn3r1q106NDhko/5/vvvGTVqFG+88cYFH6g+m4+PzwVnnolUN2nHTvHQjES2pttWcf3TFU2ZMLgVPp6uuZ6HSLVmKYGDa+zP8mTvchwPijir5URf8Akyp04XY1oAcnNz47bbbuPDDz/k/vvvJzQ0lGXLlrF+/XpeffXV8v3+/e9/s2fPHqZOner0MT/++CMjRoxg6tSp/PWvfzXj5YlcNt9vOcSEb7ZxsthCiJ8Xk0d0ZECbhmaXJSJnyzt8+irPL7BvKZTk28fcPCCquz30NGyrqzwmMHUafF5eHtdddx0pKSm0bt2atWvX8sgjj/DPf/6zfJ+xY8eyZs0akpKSnDomLy+PBg0aEBwcTJ8+fRy+3wMPPED//v2drk3T4KU6KSwp46UftjNjnW0mSJcmdXh7dDwRoX4mVyYilFlsCxCeeYD5yDbH8YD6tunpcQNs09X96phTpwuoEesAga1B4/r168nMzKRdu3Y0a+b4VPvGjRvJyclhwIABTh1TUlLCvHnzzvu9unTpQtOmTZ2qSwFIqpPkzHwe/HITezJP4uYGD14VyyPXxOHpodXNRUxz6qi9sejeX6HoxFmDbtC4s32aengnUDeCKlFjAlB1pQAk1YFhGMzecJDn522nqNRKWKAPb47qRO+4MLNLE3E9ViscTjyr5cQm4KyPUN9Qe2PR2P4QoH+nZqj2CyGKyO/LLyrl798mMW/LIQCujAtj6shO1A/Sw/oiVabwuGPLiVPZjuONOthnbDXu7FItJ2o6/U2JVEPb0nMZN2MTaccK8HB344mBLflLn+a4u+tBSZHLyjAgc7t9xtbBtWCU2ce9g063nDi9GGFwuHm1yiVRABKpRgzD4KOVqbz6805Kywwah/rx9uhOdG5S1+zSRGqv4nzbejxnQk/+Icfx+q3tM7aiuoOntzl1SqVSABKpJo6fKuHJOVtZtNPW1Xlgm4a8PrwDof76ZStSqQwDjibbZ2ylrQJrqX3c08+2Hs+Z0BMafeFzSY2lACRSDaxPzWH8jEQO5xbh7eHO369vzZ09m6iDu0hlKSmw9dY6E3pOpDmO121un7HVpDd4+ZpTp1QZBSARE5VZDd5dupc3FiVTZjVoFhbAtNHxtGscYnZpIjVfzn77jK3U5WA5q2ekh7ett9aZB5jrxZhXp5hCAUjEJFl5RTw6ezMr9x4DYGh8Y166pR2BPvpnKVIhlmLb7awzoedYsuN4SJT9tlazPuCtvnmuTL9pRUywbE82j8/ezNGTJfh5efDyLe0Y3jnS7LJEap7c9NOBZyGkLIXSU/Yxd0+I7mkPPfVbqeWElFMAEqlCpWVWpvyyh38v2wdAq0ZBTB+TQGyDQJMrE6khykrh4Dr7jK2s7Y7jgQ3Paix6FfjqdrKcnwKQSBVJP17A+BmJbDpwAoDbe0Tzj+vb4OulDu4ivys/095yYt8SKM61j7m5Q2TXsxqLtlfLCXGKApBIFZifdISn5mwhr8hCkK8nrw3rwOD2WkBN5LysZXAoEfYssIWew5sdx/3q2gNPzNXgr3Wy5OIpAIlcRkWlZbzy004+XW2bctspKpRpo+OJqutvcmUi1UxBjq2h6N6Ftqs9BcccxyPi7TO2IuLBXVdO5dIoAIlcJinZJxn3ZSI7DucB8Jc+zXni2pZ4qYO7iG0xwiNbbVd49vwCGRvAsNrHfUIg9mp7y4nABubVKrWSApDIZfDNpnT+8V0SBSVl1A3wZsrIjvRrqV/g4uKKcm0ztZJ/geRFcPKI43iDttDi9FWeyK7g4WVKmeIaFIBEKtGpYgvPzd3O15vSAejZvB5v3tqJhsFaVVZckGFA9i77jK0Dq8FqsY97BdhmasUNsP0J0VIQUnUUgEQqyY5DeYybsYmU7FO4u8Ej17TgwX6xeKiDu7iSklOw/zd76Mk96DheL+6slhNXgKePOXWKy1MAErlEhmHw+Zo0Xv5xJyUWKw2DfXj71ni6N69ndmkiVePYPnuPrdQVUFZiH/P0haZXng4919h6bolUAwpAIpcgt7CUv329lZ+TbM8yXN2qAZNHdKRugDq4Sy1WWgRpK+wtJ3JSHMdDoyHuWlvoadobvDXrUaofBSCRCko8cJyHZiSSfrwQLw83nh7Uij/3bqYO7lI7nThgv62VsgwshfYxdy/b7awz09TD4tRyQqo9BSCRi2S1Gry/PIVJC3ZjsRpE1/Vn2uh4OkaFml2aSOWxlMDBNfbQk73LcTwo4qyWE33BJ8icOkUqSAFI5CIcPVnM47O3sGxPNgA3dAjnlaHtCfbVdF2pBfIO2xYiTP4F9i2Fknz7mJsHRHU/q+VEW13lkRpNAUjESav2HuWRWZvJyi/Gx9OdF25qy61do3TLS2quMottAcIzDzAf2eY4HlAfYk9PUY/pB351zKlT5DJQABL5A5YyK2//msy0JXsxDIhrEMj0MQm0bKRL/lIDnTpqbyy691coOnHWoBs07myfph7eSY1FpdZSABL5HYdzC3l4xmbWpeYAMKpLFC/c1BY/b/UhkhrCarU1Ez0zYytjI2DYx31Dba0m4gZCbH8ICDOpUJGqpQAkcgG/7szkia+2cLyglABvD14Z2p6bOzU2uyyRP1Z4HPYtsYWevQvhVLbjeKP29hlbjbuAhz4KxPXop17kf5RYrLw2fxcfrtgPQLvGwUwfnUDTsACTKxO5AMOAzO32GVsH14JRZh/3DoKYq+yNRYMjTCtVpLpQABI5S9qxUzw0I5Gt6bkA3N2rKX+7rhU+nrrlJdVMcb5tPZ4zoSf/kON4/Vb2GVtRPcBTi3OKnE0BSOS077ccYsI32zhZbCHU34tJwzsyoE1Ds8sSsTEMOJpsn7GVtgqspfZxTz/bejxxA2wzt+o0Ma9WkRpAAUhcXmFJGS/9sJ0Z62xNG7s2rcNbt8YTEepncmXi8koKbL21zoSeE2mO43WaQYtrTzcW7Q1evubUKVIDKQCJS9uTmc+4LzexJ/Mkbm4wrl8sD/ePw9NDU3/FJDn77TO2UpeDpcg+5uFt66115gHmejHm1SlSwykAiUsyDINZ6w/ywvfbKSq1Uj/IhzdHdaJXrKYASxWzFNtuZ50JPceSHceDI6HF6cDTrA9462F8kcqgACQuJ7+olGe+TeL7LbaHRq+MC2PqyE7UD/IxuTJxGbnppwPPQkhZCqWn7GPunhDd0/4Ac/1WajkhchkoAIlL2Zaey7gZm0g7VoCHuxtPDGzJX/o0x91dHzByGZWVwsF19hlbWdsdxwMbntVY9CrwDTGlTBFXogAkLsEwDD5amcqrP++ktMygcagfb4+Op3MT9TaSy+Rk1lktJxZDca59zM0dIrue1Vi0vVpOiFQxBSCp9Y6fKuHJOVtYtDMLgGvbNuT1YR0J8VcHd6lE1jI4lGifsXUo0XHcr65tEcIW10LM1eBf15w6RQRQAJJabt3+HB6emcjh3CK8Pdz5xw2tuaNHE3Vwl8pRkAP7Fp++yrMICo45jod3OqvlRAK4a0FNkepCAUhqpTKrwb+W7OWNRXuwGtA8LIBpY+JpG6FnK+QSGAYc2Wp/lid9PRhW+7hPCMT0s7ecCNJCmiLVlQKQ1DpZeUU8Mmszq/bZ/mt8aHxjXr6lHQE++nGXCijKtc3USv4FkhfBySOO4w3antVyoht46NaqSE2gTwSpVZbtyeaxWZs5dqoEPy8PXr6lHcM7R5pdltQkhgHZu+xXeQ6sBqvFPu4VYJupFTfA9idEP18iNZECkNQKpWVWpvyyh38v2wdAq0ZBTB+TQGyDQJMrkxqh5BTs/80eenIPOo7Xizv9LM8AaHIFeGrNKJGaTgFIarz04wWMn5HIpgMnALi9RzT/uL4Nvl564FR+x7F99hlbqSugrMQ+5ukLTa88HXqugbrNzatTRC4LBSCp0eYnHeapOVvJK7IQ5OvJ68M6cF37cLPLkuqotAjSVthbTuSkOI6HRkPctbbQ07Q3ePubU6eIVAkFIKmRikrLeOWnnXy62tYdu1NUKNNGxxNVVx9acpYTB+y3tfb/BqUF9jF3L9vtrDPT1MPi1HJCxIUoAEmNsy/7JOO+TGTn4TwA/tK3OU8MbImXOrhLWSkcWAPJC2yhJ3uX43hQxFktJ/qCT5A5dYqI6RSApEb5emM6z85NoqCkjHoB3kwZ2ZGrWjYwuywxU95he8uJfUugJN8+5uYBUd3PajnRVld5RARQAJIa4lSxhWfnJvHNpgwAejavx5u3dqJhsK/JlUmVs5ZB+gb7A8xHtjqO+4fZp6jHXA1+6vcmIucy/Z7Be++9R9u2bQkLC6Nfv35s3Ljxko85deoUH3zwAV26dCEwMJDly5dfrvKlCuw4lMeN01fwzaYM3N3gsQEt+Hxsd4UfV3LqKGyZBXP+DJNi4KOBsHzy6fDjBo07w1UT4N7F8EQyDPk3tBum8CMiF2TqFaAvvviC8ePH89///peePXsyadIk+vfvz44dO4iIiKjwMS+//DLZ2dn84x//YMiQIZSVlVXly5JKYhgGn69J4+Ufd1JisdIo2Je3bu1E9+b1zC5NLjerFQ5vts/YytgIGPZx31CI7W+7rRXTHwLrm1SoiNRUboZhGH+82+XRrl07rrzySt59910ArFYrjRs3ZuzYsbz88suXfEx6ejpRUVEsWbKEq6666qJqy8vLIyQkhNzcXIKDgy/+xcklyS0s5W9fb+XnJFvbgf6tGjBpREfqBnibXJlcNoXHbc/wJC+EvQvhVLbjeKP2ZzUW7QIeuoMvIudy9vPbtN8gJ06cYPv27bzwwgvl29zd3bn66qtZsWJFpR0jNc+mA8d56MtEMk4U4uXhxtODWvHn3s3Uwb22MQzI3G6fpn5wLRhnXa31DoKYq+yNRYPPf1VYRKQiTAtAhw4dAqBBA8cZPA0aNLjgc0AVOcZZxcXFFBcXl3+dl5d3SeeTi2e1Gry3PIXJC3ZjsRpE1/Vn+ph4OkSGml2aVJbifEhZZg89+Yccx+u3OquxaA/w1BU/Ebk8TL+G7O7ufs7Xf3RXriLH/JGJEyfy4osvXtI5pOKOnizmsdlb+G2P7bbHDR3CeWVoe4J91Vm7RjMMOJpsn7GVtgqspfZxTz/bejxxAyB2ANRpYl6tIuJSTAtAZ67iZGc73ufPzs4+5wrPpRzjrAkTJvDYY4+Vf52Xl0dUVNQlnVOcs2rvUR6etZns/GJ8vdx54ca2jOoapVteNVVJga231pnQcyLNcbxOM2hx7enGor3BS7P5RKTqmRaAwsLCiI2N5bfffmPIkCHl25ctW8bIkSMr7Rhn+fj44OOjDs9VyVJm5e1fk5m2ZC+GAXENApk+JoGWjbQ6b42Ts98+Yyt1OViK7GMe3tCk1+nQMxDqxZhXp4jIaabeAnvkkUeYMGECt9xyC927d2fSpElkZWVx//33l+8zbtw41q1bx7p165w+Rqq/w7mFPDxjM+tScwAY1SWKF25qi5+3OrjXCJZi2+2sMzO2ju5xHA+OhBYDbbe1mvUBn0Bz6hQRuQBTA9CDDz7IsWPHGDJkCLm5ucTFxTFv3jxiYuz/hVhUVERBQcFFHfPFF1/wl7/8pfy5oOuuuw4PDw+eeeYZnnnmmap7gXJev+7M5ImvtnC8oJRAH0/+OaQdN3dqbHZZ8kdyM2xhZ88vkLIUSk/Zx9w8ILqn7bZWi2ttDzPrFqaIVGOmrgN0ttLSUry8zn3gtbi4GKvVip+fn9PHWCwWioqKztnu7e2Nt7dzs0q0DlDlK7FYefXnXXy0cj8A7RuHMG10PE3DAkyuTM6rzALp6+wztjKTHMcDG9qu8MQNgJh+4BtiTp0iImep9usA/a/zBRngd5/LudAxnp6eBAbqknt1knbsFOO+TGRbRi4A9/RqxtPXtcTHU7e8qpWTWfbGonsXQ3HuWYNuENn19GKEA6BRB3A3vZuOiEiFVJsAJLXXvC2HeOabbZwsthDq78Xk4R25pk1Ds8sSsDUWPZRon7F1KNFx3K+ubRHCuIG2xqIBakMiIrWDApBcNoUlZbz4/XZmrj8IQNemdXjr1ngiQs+9nSlVqCAH9i0+fZVnERQccxwP73RWy4kEcNdVOhGpfRSA5LLYk5nPuC83sSfzJG5uMK5fLA/3j8PTQ7dMqpxh2Lqmn3mWJ309GFb7uE+w7erOmZYTQbo6JyK1nwKQVCrDMJi1/iAvfL+dolIr9YN8eHNUJ3rFhpldmmspyrXN1Er+BZIXwckjjuMN2p7VcqIbeGjFbRFxLQpAUmnyi0p55tskvt9i6+90ZVwYU0d2on6QFpi87AwDsnfZr/IcWA1Wi33cKwCaX3U69AyAkEjTShURqQ4UgKRSbE0/wUMzEkk7VoCHuxtPDGzJX/o0x91da8FcNiWnYP9v9tCTe9BxvF6cfcZWkyvAU0FUROQMBSC5JIZh8NHKVF79eSelZQaNQ/14e3Q8nZvUMbu02unYPvuMrdSVUFZsH/P0haZXng4910Dd5ubVKSJSzSkASYUdP1XCE19t4dddWQAMatuI14Z1IMRfz5NUmtIiSFth77OVk+I4HhoNcad7bDXtDd7+5tQpIlLDKABJhazbn8PDMxM5nFuEt6c7z17fmtt7NFEH98pw4sDpwLMQ9i+DUnsrGNy9oElP+zT1sBZqOSEiUgEKQHJRyqwG/1qylzcW7cFqQPOwAKaNiadthNogVFhZKRxYY3+WJ3un43hQuH3GVrO+4KvWLCIil0oBSJyWlVfEI7M2s2qfbeG8oQmNefnmdgT46MfoouUdtrec2LcESvLtY27uENXdHnoattNVHhGRSqZPLnHKsj3ZPDZrM8dOleDv7cHLN7djWGdNpXaatQzSN9gfYD6y1XHcP8w+RT3mavDTQ+QiIpeTApD8LkuZlcm/7OHfy/YB0KpREO/clkBMfTWb/UOnjsLeX09f5fkVCo+fNehmazNxZpp6eLwai4qIVCEFILmg46dKGDdjEyv32m553dGjCX+/vjW+XuoNdV5WKxzebJ+xlbERMOzjvqEQ2/90Y9H+EFjfpEJFREQBSM5r5+E87vtsAwdzCvH39mDS8I5c3yHc7LKqn8ITpxuLLoS9C+FUtuN4o/ZnNRbtAh76JyciUh3ot7Gc46dth3l89hYKS8uIruvPe3d2plUjzTwCbC0nMrfbZ2wdXAtGmX3cOwhirrI3Fg2OMK1UERG5MAUgKWe1GkxZuJt3ltie9+kdG8b0MfGE+nubXJnJivMhZZk99OQfchwPa2l7jqfFtRDVAzxd/P0SEakBFIAEgLyiUh6ZuZnFp1d1vvfKZjw9qBWeHi74YK5hwNFk+4yttFVgLbWPe/pBsz72WVt1mppWqoiIVIwCkLAv+yT3frqBlOxT+Hi68+qw9gyJd7Ep7qWFkLrCHnqOpzqO12l6VsuJXuDlZ0aVIiJSSRSAXNyvOzN5ZOZm8osthIf48t4dXWgf6SKrOufsty9GuP83sBTZxzy8oUkv+wPM9WK0GKGISC2iAOSiDMPgnSV7mbJwD4YBXZvW4V+3daZ+kI/ZpV0+lmI4sNo+Tf3oHsfx4MizWk70AR+tdSQiUlspALmgU8UWnpyzhZ+2HQHg9h7RPHdDW7w9a+HzPrkZtunpyQshZSmUnLSPuXlAdE976GnQWld5RERchAKQizlwrID7PtvAriP5eHm48dLN7RjdLdrssipPmQXS19lnbGUmOY4HNLCvvtz8KvALNaNKERExmQKQC1mRfJRxMzZxoqCU+kE+/Pv2BDo3qWt2WZfuZNZZjUUXQ1HuWYNuENnVHnoadVDLCRERUQByBYZh8OGK/bzy006sBnSMCuU/t3emUYiv2aVVjLUMDiXaZ2wdSnQc96trW4QwbqCtsWhAPXPqFBGRaksBqJYrKi3jmW+28U1iBgDDO0fyf7e0q3n9vApyTrec+MV2tafgmON4eKezWk4kgHsNe30iIlKlFIBqsUMnCrn/841sTc/Fw92Nf1zfmj9d0RS3mvCgr2HAka32Z3nS14NhtY/7BNuu7pxpORHU0LxaRUSkxlEAqqXWp+bwwOcbOXqyhDr+XrxzWwJXxISZXdbvK8q1zdRK/gWSF8HJI47jDdraV1+O6g4eXqaUKSIiNZ8CUC30xdo0Xpi3ndIyg9bhwbx3R2ei6vqbXda5DAOyd0PyAttVngOrwWqxj3v522ZqnZmmHuJiq1OLiMhlowBUi5RYrDw/bzsz1h0A4IYO4bw+vAP+3tXor7nklG3V5eTTa/PkHnAcrxdrn7HVpBd41uKFGUVExDTV6JNRLkVWfhF//XwTG9KO4+YGT13bivv7Nq8ez/sc22dffTl1BZQV28c8fKDZlfZneerFmFeniIi4DAWgWmDLwRP85bONHMkrIsjXk7dHx9OvZQPzCiotgrSV9tCTs89xPCQaWpyesdX0SvCuhrfnRESkVlMAquHmbEznmW+3UWKxEtsgkPfu6Ezz+ib0sDpxwH5ba/8yKC2wj7l7QpMr7NPUw1qo5YSIiJhKAaiGspRZ+edPO/l4ZSoA17RuyBujOhLkW0Uzo8pK4cAa+zT17J2O40HhZzUW7Qu+wVVTl4iIiBMUgGqgnFMljPtyE6v22RYDHN8/jkf6x+HufpmvquQfsd/WSlkKxXn2MTd329T0M6GnYTtd5RERkWpLAaiG2XEoj/s+20D68UL8vT2YOrIjg9qFX55vZrVCxkbYM98Weo5sdRz3D7Ovy9O8H/jXgr5iIiLiEhSAapAfth7iya+2UlhaRnRdf96/swstGwVV7jcpyoOUJbBnge1PwdGzBt1sbSbOTFMPj1djURERqZEUgGqAMqvBlF9286+lttlUV8aFMW10PKH+3pXzDXJSTgee+ZC6Eqyl9jGfYIjtf3qa+gAIrF8531NERMRECkDVXG5hKY/MTGTJ7mwA7uvTnKeubYmnxyVceSmzwMG1sOdnW/A5usdxvF4stBgELa6F6J5qOSEiIrWOAlA1tjcrn/s+3UjK0VP4eLrz+vAO3NypccVOVpADe3+1XeXZu9DWd+sMd09b0Gl5HcRdC2GxlfMCREREqikFoGpq0Y5MHpm1mZPFFhqH+vGfOzrTrnGI8yc402drz3zbVZ6Daxy7qfvVtd3WanGtrau6X2ilvwYREZHqSgGomrFaDd5Zspepi/ZgGNCtWV3+dVsCYYFO9MSyFNtWYD7zPM/xVMfxBm1tgafFIIjsAu4el+U1iIiIVHcKQNXIqWILj8/ewvztRwC4s2cTnr2hDV6/97zPySzbFPU982HfEig5aR/z8IZmfezP84RGX+ZXICIiUjMoAFUTacdOcd+nG9mdmY+3hzsv39KWUV3PE1gMA45sO31ra75tnZ6zBTa0X+Vp1hd8TGiLISIiUs0pAFUDy5OzGfdlIrmFpTQI8uHd2zvTuUkd+w4lBbD/N/vzPPmHHE8Q3sn2AHOLa6FRR63NIyIi8geqRQA6ePAgmZmZtGjRguBg53pGOXNMRc5blaxWg//8lsKkBbuwGtApKpT/3NGZhsG+kJthDzz7l4GlyH6gl79t5eUW19oeZA6+TCtBi4iI1FKmBqCioiJuu+02fv75Z5o0aUJaWhqvvfYaDz300CUdU5HzVrXDuYU8PntLeT+vkQkRvNytBJ8Nk23B58g2xwNCok4/yzMImvYGL18TqhYREakdTA1AL774IuvWrWPfvn2Eh4fz3XffMWTIELp160b37t0rfExFzluVftx6mGe+3YZReIKbvXbwcHQKzdJW4bYj+6y93CCq2+nnea6DBq3VXFRERKSSuBmGYZj1zRs1asQDDzzA888/X76tffv29OrVi3//+98VPqYi5/1feXl5hISEkJubW2m3z04VlfD+7G+x7F5IX48tJLjvxYOz1uY503aixSBb24mAepXyfUVERFyFs5/fpl0BOnToEJmZmXTu3Nlhe7du3UhMTKzwMRU5L0BxcTHFxcXlX+fl5V3U63FKWSl/SRmPn9dZz/OEtbQ1FlXbCRERkSpjWgDKyckBoF49x6sc9erVKx+ryDEVOS/AxIkTefHFFy/iFVy8gIAAjscMorC0gLodBtuu9mhtHhERkSpnWgDy8rJd6SgqKnLYXlhYiLf3+bucO3NMRc4LMGHCBB577LHyr/Py8oiKinLmpVyUOnd8UunnFBERkYtjWgCKiorC3d2djIwMh+0ZGRlER5//qogzx1TkvAA+Pj74+DjRbkJERERqPNNWzPP39+eKK65g3rx55dtOnTrFokWLGDBgQPm2vXv3lj+748wxzp5XREREXJeps8CWLVvGgAEDePzxx+nZsyfTpk1j//79bN68mcBAWwuHsWPHsmbNGpKSkpw+xpl9/sjlmAUmIiIil5ezn9+m9kzo27cvS5YsIS0tjbfeeou2bduyYsUKh5ASFxdHQkLCRR3jzD4iIiLiuky9AlSd6QqQiIhIzVMjrgCJiIiImEEBSERERFyOApCIiIi4HAUgERERcTkKQCIiIuJyFIBERETE5SgAiYiIiMtRABIRERGXY1oz1OruzPqQeXl5JlciIiIizjrzuf1H6zwrAF1Afn4+YOsuLyIiIjVLfn4+ISEhFxxXK4wLsFqtHDp0iKCgINzc3CrtvHl5eURFRXHw4EG12LiM9D5XDb3PVUfvddXQ+1w1Luf7bBgG+fn5RERE4O5+4Sd9dAXoAtzd3YmMjLxs5w8ODtY/riqg97lq6H2uOnqvq4be56pxud7n37vyc4YeghYRERGXowAkIiIiLkcBqIr5+Pjw/PPP4+PjY3YptZre56qh97nq6L2uGnqfq0Z1eJ/1ELSIiIi4HF0BEhEREZejACQiIiIuRwFIREREXI4CUBXKzc1lw4YNHDx40OxSaqy8vDwSExPJysq64D4Wi4UtW7awffv2Cy6F7sw+ApmZmaxYsYLDhw+fd3zv3r1s3LiRwsLCC57DmX1c3e7du9m5c+cFfxazsrJYv3492dnZFzyHM/u4spycHDZt2kRycjJlZWXn3efUqVNs3LiRlJSUC57HmX1cSW5uLitXrrzg7wiA7Oxs1q9f/7u/tytrn4tiSJV4++23DT8/P6N169aGn5+fMXToUKOoqMjssmqM5ORkY8iQIUZoaKgRHx9vBAYGGoMHDzaOHTvmsN+qVauMxo0bG1FRUUaDBg2MVq1aGbt3777ofcQwCgsLjY4dOxpubm7GtGnTHMays7ONK664wggJCTFiY2ONkJAQ45tvvrnofVzdihUrjLi4OCMiIsKIj483OnfubCQnJ5ePW61W46GHHjJ8fHyMNm3aGD4+Psbjjz/ucA5n9nFlFovFuOeeeww/Pz8jPj7eaNy4sdG0aVPjt99+c9jviy++MIKCgowWLVoYQUFBRr9+/YwTJ05c9D6uYv/+/ca9995rNGrUyPDw8Djnd8QZTzzxhMPP5kMPPWRYrdbLss/FUgCqAmvWrDHc3NyMefPmGYZhGBkZGUZERIQxYcIEkyurOebPn29888035T/wR48eNdq0aWOMHj26fJ+CggIjIiLC+Otf/2oYhu0X3+DBg42EhISL2kdsHnjgAePBBx80AgICzvnlNnz4cCMhIcE4efKkYRiGMWnSJMPPz89IT0+/qH1c2d69e42AgADj73//e/nP9bZt24xly5aV7/PBBx8YgYGBxtatWw3DMIz169cbPj4+xhdffHFR+7iyTz/91PDy8jK2b99uGIZhlJWVGbfddpsRExNTvk9ycrLh5eVlvPfee4ZhGMbx48eNli1bGnffffdF7eNK5s+fb/znP/8x8vPzjZCQkPMGoM8//9zw8/MzNm7caBiGYWzZssXw9/c3Pvzww0rfpyIUgKrAfffdZ3Tq1Mlh2z/+8Q+jYcOGJlVUO7zwwgtGVFRU+dfffPON4ebmZhw6dKh824oVKwzASExMdHofsb1PrVu3NgoKCs4JQDk5OYaHh4fx+eefl28rLi42QkJCjEmTJjm9j6u79957jbi4OKOsrOyC+1xxxRXG7bff7rDtlltuMfr3739R+7iyKVOmGGFhYQ7bpk2bZgQHB5d//dxzzxnh4eEOVxSmT59u+Pr6GgUFBU7v46ouFICuvvpqY/jw4Q7bbr31VqNXr16Vvk9F6BmgKpCYmEjnzp0dtnXr1o3MzMzfvW8qv2/9+vXExsaWf52YmEhERATh4eHl27p161Y+5uw+ru7AgQM88MADfPHFF/j5+Z0zvm3bNsrKyhx+pr29venYsWP5e+jMPq7u119/ZfDgwZSWlrJx40bS0tLOeQboQr87zn4PndnHld155500bNiQ+++/n4ULF/LZZ58xZcoUXn311fJ9EhMTSUhIcGh83a1bN4qKiti1a5fT+4ijyvr5vVw/42qGWgVycnKoV6+ew7YzX+fk5Dh8GItzPv/8c37++Wd++eWX8m3ne5+9vLwICgoiJyfH6X1cWVlZGWPGjOGJJ54gPj7+vPuceZ/O9zN99vv8R/u4ukOHDpGVlUWrVq0IDQ3l4MGDNG3alJkzZxIbG0tRURGFhYXnfQ+PHz+OYRgUFxf/4T5nf2C7orCwMMaNG8ff//531qxZQ3Z2Nm3atGHw4MHl++Tk5BATE+Nw3Nm/o53dR+wMw+DEiRPn/dksKCiguLgYb2/vStmnoqtJ6wpQFfDy8qKoqMhh25kZMd7e3maUVKP9/PPP/PnPf+bNN9+kf//+5dvP9z4DFBUVlb/Pzuzjyt566y0OHz5M9+7dWbFiBStWrMBqtZKSksKGDRsA23sInPdn+uz3+Y/2cXVeXl788MMPzJ8/n8TERA4cOEBQUBB33313+Tic/z309PTEzc3NqX1c3X/+8x+eeuopli9fzubNmzlw4ADNmjXj6quvpqSkBHDud7R+j18cNzc3PD09L/ieeXl5Vdo+FaUAVAWaNGlCRkaGw7aMjAzc3d2JjIw0qaqaaf78+QwdOpRXX32Vhx56yGGsSZMmHDlyBKvVWr4tKyuL0tJSoqOjnd7HlXl6ehIeHs6ECRP429/+xt/+9jeKi4uZO3cur732GmB7D4Hz/kyf/T7/0T6urmnTpvTr14+WLVsC4O/vz5133smaNWsoLS3Fw8ODxo0bn/c9PPP+OrOPq/vhhx/o168fbdq0AWzv2QMPPEBKSgpJSUnAhX9HAw4/03+0jziKjo4+73sWGRmJu7t7pe5TEQpAVWDAgAEsWrSIgoKC8m1z586lV69e533GQs7vl19+YciQIfzzn//k0UcfPWd8wIAB5OXlsXTp0vJtc+fOxdvbmz59+ji9jysbP358+ZWfM3/8/Px49NFH+eqrrwBo06YNERERzJs3r/y4lJQUtm3bxoABA5zex9Vde+215/xST09PJzQ0tPy/agcMGMD3339f/myQ1Wrl+++/d3gPndnHldWvX5/09HSHbWfWYqtfvz5gew/Xrl3rsL7M3LlziYuLKw+SzuwjjgYMGMAPP/xQ/rNpGAbz5s075+e3MvapkEt6hFqckpeXZzRv3twYOHCgMXfuXOPpp582PD09Haa7yu9bsWKF4efnZ4wcOdJYvnx5+Z8VK1Y47HfHHXcY0dHRxhdffGG8//77RkhIiPHcc89d9D5id75p8J988onh5eVlTJ482fj666+NTp06Gb1793aY0eTMPq7syJEjRnh4uHH//fcbCxYsMN566y0jKCjIYZbcnj17jODgYONPf/qTMW/ePGPMmDFGnTp1jNTU1Ivax5WtW7fO8PT0NMaOHWv8/PPPxscff2xERUUZN998c/k+paWlRkJCgtGjRw/jm2++Mf75z38aHh4expw5cy5qH1eSn59f/ns4MDDQePTRR43ly5cbO3fuLN9n//79Rp06dYzbbrvNmDdvnnHXXXcZwcHBDmtdVdY+FaFu8FXkyJEjvPrqq2zbto2GDRvy4IMP0qtXL7PLqjE+/fRT3nvvvXO2e3p6OlzNKS0tZfr06SxYsABPT0+GDRvGn/70J4dnIZzZR+wGDhzI/fffz9ChQx22z5s3j08++YS8vDx69uzJk08+SVBQ0EXv48oOHjzI66+/zo4dO2jUqBGjRo3ipptucthnx44dTJkyhf379xMTE8OTTz5JixYtLnofV7Zt2zbeffdd9u3bR3BwMH379uW+++5zeHbnxIkTvPbaa6xfv546deowduxYrr32WofzOLOPq9i9ezd//vOfz9ner18/Xn755fKv9+zZw6RJk9i3bx/NmjXjiSeeoHXr1g7HVNY+F0sBSERERFyOngESERERl6MAJCIiIi5HAUhERERcjgKQiIiIuBwFIBEREXE5CkAiIiLichSARERExOUoAIlIldm9ezcLFiwwuwzKyspYvnw5s2fPZs+ePWaXIyIm8DS7ABGpXbZt20ZqaioNGzakY8eO+Pj4lI99//33fP7556aunmsYBtdccw2ZmZl06NCBoKAgrZos4oIUgESkUmRlZXHTTTexf/9+unbtyvHjxzl06BDPPvss99xzDwCtWrVi0KBBpta5Z88eli5dyqFDhwgPDze1FhExjwKQiFSKp556isLCQlJTU/Hz8wPg6NGjLFq0qHyfuLi48k7nADNnzjznPO7u7owcObL8671795KUlETDhg1JSEhwuKJ0IRs3biQtLY2oqCi6du1avn3Pnj3l33PRokV4eXlxyy234Ovr63B8Wloaq1evBiAgIIA2bdoQExPjsE9SUhKZmZn07t2bVatWcfToUUaMGMHixYupX78+ERERrF27Fn9/f6666irWr1/Pvn37AAgLC6Njx47l3cgBtm7dypEjRxg4cKDD99m8eTPZ2dnq7i5SyRSARKRSJCUl0bNnz/LwA7YP+ltvvbX86/+9Bfbdd985nGPTpk2kpaUxcuRILBYLY8eO5aeffqJ79+6kp6dz6tQp5s6de8EmiAUFBdx0001s3bqVLl26sGnTJlq1asX3339PUFAQ+/btY/ny5eW1uLu7c911150TgA4ePFheW35+PsuXL+euu+5i2rRp5fvMmTOHzz77jICAAOrXr0+jRo0YMWIEL730EhaLhYyMDNq2bUvPnj256qqrSExMZPHixYCtOfLGjRt59913uf322wHbFbQbb7yRjIwMwsLCyr/P3XffzcCBAxWARCrbJfWSFxE57cEHHzRCQ0ONjz/+2MjMzDzvPpMmTTI6dux43rFt27YZgYGBxuuvv24YhmG88sorRqdOnYy8vLzyfR555BGjV69eF6zhhRdeMKKjo8u/f3Z2ttG0aVNjwoQJ5fssX77cAIzCwkKnX1taWpoREhJiLF26tHzb888/bwDG999/77Bv3759jdDQUOPgwYO/e865c+cawcHB5a/ParUazZs3N954443yfRITEw3A2LVrl9O1iohzNAtMRCrFq6++yh133MFjjz1Gw4YNad68OePGjePIkSN/eGxOTg4333wzN998M08++SQAH3/8MR07dmTBggV89dVXzJ49m3r16rF69WqKiorOe56ZM2cyduxYGjRoANiuQN1///3nvdX2R4qKili5ciVz5sxh1apVREREsG7dOod9mjVrxg033HDOsUOGDCEyMvKc7UePHmXx4sXMnj2bkydPcvLkSXbt2gWAm5sb99xzDx9//HH5/h9++CG9evWiZcuWF12/iPw+3QITkUoRGBjI22+/zRtvvMG2bdv47bffmDx5Mj/++CPbtm0jMDDwvMdZLBZGjhxJ3bp1+eCDD8q3p6amEhYWxpw5cxz2HzFiBAUFBefctgLbszvNmzd32BYTE8OBAwcwDAM3NzenXsvKlSsZOnQoYWFhxMTE4O/vz/Hjx8nKynLY70IPUZ9v+7Rp05gwYQIdOnQgPDy8/Fmos89599138/zzz7Nhwwbat2/Pl19+yaRJk5yqWUQujgKQiFQqDw8POnXqRKdOnejevTs9evRg1apV5zzce8bjjz/O9u3b2bBhg0OoCQ4O5pZbbuGpp55y+nuHhYWRk5PjsC0nJ4d69eo5HX4AnnzySW6//XamTJlSvq1Lly4YhuGw34XO+b/bCwoKePTRR/n222+58cYbATh58iSzZs1yOGdERASDBw/mo48+om/fvpSUlDg8EC4ilUe3wESkUuzfv/+cbWduVYWGhp73mI8//pj//Oc/fPvttzRu3NhhbNCgQXz00UeUlJQ4bM/IyLhgDb179+abb75x2DZnzhx69+7tzEsod+TIEYfbTsnJyWzduvWiznG2o0ePUlZW5nDO/72ydcbYsWOZMWMG7777LiNHjrzglTMRuTS6AiQileLpp58mKyuL/v37Ex0dTVpaGu+++y6DBg2ic+fO5+x/+PBhHnjgAQYPHkxqaiqpqamAfRr8a6+9xpVXXkn37t2566678PT0ZMWKFRQWFjJ37tzz1vDyyy/TtWtXhg0bxqBBg1i4cCFr165l7dq1F/VabrnlFl588UWKi4spLS3ljTfewN/f/6LfkzOioqJISEjgrrvuYuzYsezdu5cPP/wQd/dz/xv0+uuvx9/fn2XLlvHPf/6zwt9TRH6fApCIVIrZs2ezcuVKfvnlF5YsWUJYWBj/+te/uOmmm/Dw8AAcF0I0DINbbrkFcJwO7+HhwciRI2ncuDFbtmzh008/ZePGjQQFBTFs2DCGDRt2wRpiYmLYvHkz77//PsuXLycuLo7XXnuNZs2ale9Tv359Ro0aVV7T+bz++uu0bNmStWvXEhAQwGeffcaaNWuIiooq36ddu3bnPfbqq6+mVatWDtvc3NxYuHAh06dPZ9myZTRu3JhVq1bx0ksvnXPly8PDgxtuuIFly5bRq1evC9YoIpfGzfjfm9oiImIaq9VKTEwMDz74IE888YTZ5YjUWroCJCJSTXz33Xf8+OOPFBQUcN9995ldjkitpoegRUSqifnz5+Ph4cEvv/xCcHCw2eWI1Gq6BSYiIiIuR1eARERExOUoAImIiIjLUQASERERl6MAJCIiIi5HAUhERERcjgKQiIiIuBwFIBEREXE5CkAiIiLichSARERExOX8P2UlAwucjq1hAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -569,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -604,9 +667,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", diff --git a/pyproject.toml b/pyproject.toml index 680c83244..9d97f797f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -303,4 +303,4 @@ python_version = "3.12" [tool.maturin] python-source = "." include = ["tiatoolbox/**/*"] -module-name = "tiatoolbox.miscrust" +module-name = "tiatoolbox.rust_misc" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 1d5cec8eb..b15cb21c3 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -239,7 +239,7 @@ fn contrast_enhancer<'py>(py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p } #[pymodule] -fn miscrust(m: &Bound<'_, PyModule>) -> PyResult<()> { +fn rust_misc(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 4a24759f9..f614da4bd 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -31,7 +31,7 @@ from tqdm.auto import tqdm, trange from tqdm.dask import TqdmCallback -from tiatoolbox import logger, miscrust +from tiatoolbox import logger, rust_misc from tiatoolbox.annotation.storage import Annotation, AnnotationStore, SQLiteStore from tiatoolbox.utils.exceptions import FileNotSupportedError @@ -434,7 +434,7 @@ def contrast_enhancer(img: np.ndarray, low_p: int = 2, high_p: int = 98) -> np.n msg = "Image should be uint8." raise AssertionError(msg) if img.ndim == dimension_for_rust: - return miscrust.contrast_enhancer(img, low_p, high_p) + return rust_misc.contrast_enhancer(img, low_p, high_p) img_out = img.copy() percentiles = np.array(np.percentile(img_out, (low_p, high_p))) p_low, p_high = percentiles[0], percentiles[1] @@ -1245,7 +1245,7 @@ def patch_predictions_as_annotations( class_probs = np.empty((0, 2)) if len(patch_coords) == 0: patch_coords = np.empty((0, 2)) - return miscrust.patch_predictions_as_annotations( + return rust_misc.patch_predictions_as_annotations( Annotation, Polygon, preds, @@ -1284,7 +1284,7 @@ def patch_predictions_as_qupath_json( desc="Converting outputs to QuPath JSON.", disable=not verbose, ) - features = miscrust.patch_predictions_as_qupath_json( + features = rust_misc.patch_predictions_as_qupath_json( class_colours, preds, class_dict, np.array(patch_coords).astype("float") ) return {"type": "FeatureCollection", "features": features} From 0fedda488605b73c2991ab48229e78a455f715f5 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 18:36:10 +0100 Subject: [PATCH 015/112] Corrected to find mypy error --- tiatoolbox/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tiatoolbox/__init__.py b/tiatoolbox/__init__.py index dd3806fdc..5f522b0c1 100644 --- a/tiatoolbox/__init__.py +++ b/tiatoolbox/__init__.py @@ -14,6 +14,8 @@ from logging import LogRecord from types import ModuleType + from tiatoolbox import rust_misc + __author__ = """TIA Centre""" __email__ = "TIA@warwick.ac.uk" __version__ = "2.1.3" From ccb483388d769de6c106f40ad9e651ac50c35dfb Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 20 Aug 2026 19:19:25 +0100 Subject: [PATCH 016/112] Corrected to fix mypy error --- tiatoolbox/rust_misc.pyi | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 tiatoolbox/rust_misc.pyi diff --git a/tiatoolbox/rust_misc.pyi b/tiatoolbox/rust_misc.pyi new file mode 100644 index 000000000..968ffd9af --- /dev/null +++ b/tiatoolbox/rust_misc.pyi @@ -0,0 +1,36 @@ +from typing import Any + +import numpy as np +from numpy.typing import NDArray +from shapely.geometry import Polygon + +from tiatoolbox.annotation.storage import Annotation + +def add(a: int, b: int) -> int: ... +def json_dump_python_object( + save_path: str, + obj: object, +) -> None: ... +def patch_predictions_as_annotations( + annotation_class: type[Annotation], + polygon_class: type[Polygon], + preds: list[float], + keys_contains_labels: bool, + keys_contains_probabilities: bool, + class_dict: dict[float, str | float], + py_class_probs: NDArray[np.float64], + py_patch_coords: NDArray[np.float64], + classes_predicted: list[float], + labels: list[float], +) -> list[Any]: ... +def patch_predictions_as_qupath_json( + class_colours: dict[float, list[int]], + preds: list[float], + class_dict: dict[float, str], + py_patch_coords: NDArray[np.float64], +) -> list[dict[str, Any]]: ... +def contrast_enhancer( + img: NDArray[np.uint8], + low_p: int, + high_p: int, +) -> NDArray[np.uint8]: ... From 10a96054dd9c303578b59753dd1aa8e9685bfa7c Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Fri, 21 Aug 2026 13:02:54 +0100 Subject: [PATCH 017/112] Corrected types error --- tiatoolbox/__init__.py | 2 +- tiatoolbox/rust-library/lib.rs | 14 ++--- tiatoolbox/utils/misc.py | 106 +++++++++++++++++++++++++++++++++ 3 files changed, 114 insertions(+), 8 deletions(-) diff --git a/tiatoolbox/__init__.py b/tiatoolbox/__init__.py index 5f522b0c1..e488b5f9b 100644 --- a/tiatoolbox/__init__.py +++ b/tiatoolbox/__init__.py @@ -14,7 +14,7 @@ from logging import LogRecord from types import ModuleType - from tiatoolbox import rust_misc + from . import rust_misc __author__ = """TIA Centre""" __email__ = "TIA@warwick.ac.uk" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index b15cb21c3..fb99bfdc9 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -146,13 +146,13 @@ fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, polygon_feat.set_item("type", "Polygon")?; polygon_feat.set_item( "coordinates", - vec![vec![ - [xmin, ymin], - [xmin, ymax], - [xmax, ymax], - [xmax, ymin], - [xmin, ymin], - ]], + (( + (xmin, ymin), + (xmin, ymax), + (xmax, ymax), + (xmax, ymin), + (xmin, ymin), + ),), )?; let feature = PyDict::new(py); feature.set_item("type", "Feature")?; diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index f614da4bd..bf0ee8837 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1233,6 +1233,53 @@ def patch_predictions_as_annotations( labels: list, *, verbose: bool = True, +) -> list: + """Helper function to generate annotation per patch predictions.""" + preds = np.array(preds) + if np.issubdtype(preds.dtype, np.number): + return rust_patch_predictions_as_annotations( + preds.astype("float").tolist(), + keys, + class_dict, + class_probs, + patch_coords, + classes_predicted, + labels, + ) + annotations = [] + tqdm_loop = tqdm( + patch_coords, + leave=False, + desc="Converting outputs to AnnotationStore.", + disable=not verbose, + ) + + for i, _ in enumerate(tqdm_loop): + if "probabilities" in keys: + props = { + f"prob_{class_dict[j]}": class_probs[i][j] for j in classes_predicted + } + else: + props = {} + if "labels" in keys: + props["label"] = class_dict[labels[i]] + if len(preds) > 0: + props["type"] = class_dict[preds[i]] + annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props)) + + return annotations + + +def rust_patch_predictions_as_annotations( + preds: list[float], + keys: list, + class_dict: dict, + class_probs: list | np.ndarray, + patch_coords: list | np.ndarray, + classes_predicted: list, + labels: list, + *, + verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" tqdm( @@ -1265,6 +1312,65 @@ def patch_predictions_as_qupath_json( patch_coords: list | np.ndarray, *, verbose: bool = True, +) -> dict: + """Helper function to generate QuPath JSON per patch predictions.""" + preds = np.array(preds) + if np.issubdtype(preds.dtype, np.number): + return rust_patch_predictions_as_qupath_json( + preds.astype("float").tolist(), class_dict, patch_coords + ) + features = [] + # pick a color for each class based on the class index, using a colormap + num_classes = len(class_dict) + cmap = plt.colormaps["tab20"].resampled(num_classes) + class_colours = { + class_idx: [ + int(cmap(class_idx)[0] * 255), + int(cmap(class_idx)[1] * 255), + int(cmap(class_idx)[2] * 255), + ] + for class_idx in class_dict + } + + tqdm_loop = tqdm( + range(np.asarray(patch_coords).shape[0]), + leave=False, + desc="Converting outputs to QuPath JSON.", + disable=not verbose, + ) + + for i in tqdm_loop: + class_idx = int(preds[i]) + class_name = class_dict[class_idx] + polygon_geo = Polygon.from_bounds(*patch_coords[i]) + polygon_feat = mapping(polygon_geo) + + feature = { + "type": "Feature", + "id": f"patch_{i}", + "geometry": polygon_feat, + "properties": { + "classification": { + "name": class_name, + "color": class_colours[class_idx], + } + }, + "objectType": "annotation", + "name": class_name, + "class_value": class_idx, + } + + features.append(feature) + + return {"type": "FeatureCollection", "features": features} + + +def rust_patch_predictions_as_qupath_json( + preds: list[float], + class_dict: dict, + patch_coords: list | np.ndarray, + *, + verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" num_classes = len(class_dict) From 882a859a58df43fa48a70497ec06dea9874977da Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 15:54:53 +0100 Subject: [PATCH 018/112] Edited so that json.dump using rust instead of python --- Cargo.toml | 2 +- ...ring_misc_functions_in_rust_v_python.ipynb | 1635 +++++++++++++++++ benchmarks/implementing_misc_in_rust.ipynb | 744 -------- pyproject.toml | 2 +- tiatoolbox/__init__.py | 2 +- tiatoolbox/{rust_misc.pyi => rmisc.pyi} | 0 tiatoolbox/rust-library/lib.rs | 104 +- tiatoolbox/utils/misc.py | 104 +- 8 files changed, 1751 insertions(+), 842 deletions(-) create mode 100644 benchmarks/comparing_misc_functions_in_rust_v_python.ipynb delete mode 100644 benchmarks/implementing_misc_in_rust.ipynb rename tiatoolbox/{rust_misc.pyi => rmisc.pyi} (100%) diff --git a/Cargo.toml b/Cargo.toml index d4b6c2bbf..6e7fd940b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ autolib = false [lib] path = "tiatoolbox/rust-library/lib.rs" -name = "rust_misc" +name = "rmisc" crate-type = ["cdylib"] [dependencies] diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb new file mode 100644 index 000000000..a239de3d5 --- /dev/null +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -0,0 +1,1635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "aqPkpRk-pT5q", + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Benchmarking Misc in Rust\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This work focuses on converting code in tiatoolbox/utils/misc.py from Python to Rust with the aim of reducing the time it takes to run the code. This Juypter notebook shows the speedup that certain functions are having being written in rust.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 1: Contrast Enhancer\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from skimage import exposure\n", + "\n", + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " # check if image is not uint8\n", + " dimension_for_rust = 3\n", + "\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " if img.ndim == dimension_for_rust:\n", + " return rmisc.contrast_enhancer(img, low_p, high_p)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def py_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DZBiw_EepT5x" + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 1\n", + "maxarraysize = 10000\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng()\n", + " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", + " start_time = time.time()\n", + " python_result = py_contrast_enhancer(temp, 2, 96)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(i)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 2: Patch Predictions As Annotations\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Patch predictions as annotations written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from shapely.geometry import Polygon\n", + "from tqdm.auto import tqdm\n", + "\n", + "from tiatoolbox.annotation.storage import Annotation\n", + "\n", + "\n", + "def py_patch_predictions_as_annotations(\n", + " preds: list | np.ndarray,\n", + " keys: list,\n", + " class_dict: dict,\n", + " class_probs: list | np.ndarray,\n", + " patch_coords: list | np.ndarray,\n", + " classes_predicted: list,\n", + " labels: list,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> list:\n", + " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", + " annotations = []\n", + " tqdm_loop = tqdm(\n", + " patch_coords,\n", + " leave=False,\n", + " desc=\"Converting outputs to AnnotationStore.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for i, _ in enumerate(tqdm_loop):\n", + " if \"probabilities\" in keys:\n", + " props = {\n", + " f\"prob_{class_dict[j]}\": class_probs[i][j] for j in classes_predicted\n", + " }\n", + " else:\n", + " props = {}\n", + " if \"labels\" in keys:\n", + " props[\"label\"] = class_dict[labels[i]]\n", + " if len(preds) > 0:\n", + " props[\"type\"] = class_dict[preds[i]]\n", + " annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props))\n", + "\n", + " return annotations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Patch Predictions As Annotations with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rust_patch_predictions_as_annotations(\n", + " preds: list | np.ndarray,\n", + " keys: list,\n", + " class_dict: dict,\n", + " class_probs: list | np.ndarray,\n", + " patch_coords: list | np.ndarray,\n", + " classes_predicted: list,\n", + " labels: list,\n", + ") -> list:\n", + " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", + " if len(class_probs) == 0:\n", + " class_probs = np.empty((0, 2))\n", + " if len(patch_coords) == 0:\n", + " patch_coords = np.empty((0, 2))\n", + " return rmisc.patch_predictions_as_annotations(\n", + " Annotation,\n", + " Polygon,\n", + " preds,\n", + " \"labels\" in keys,\n", + " \"probabilities\" in keys,\n", + " class_dict,\n", + " np.array(class_probs).astype(\"float\"),\n", + " np.array(patch_coords).astype(\"float\"),\n", + " classes_predicted,\n", + " labels,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "num_patches = 1\n", + "num_classes = 1\n", + "max_patches = 1000\n", + "while num_patches <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng(42)\n", + " class_probs = rng.random(\n", + " (num_patches, num_classes),\n", + " dtype=np.float64,\n", + " )\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", + " labels = (\n", + " rng.integers(0, num_classes, size=num_patches).astype(np.int32).tolist()\n", + " )\n", + " x = np.arange(num_patches, dtype=np.float64) * 10\n", + " y = np.zeros(num_patches, dtype=np.float64)\n", + " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", + " keys = [\"predictions\", \"probabilities\", \"labels\"]\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + " classes_predicted = list(range(num_classes))\n", + " verbose: bool = False\n", + " start_time = time.time()\n", + " python_object = py_patch_predictions_as_annotations(\n", + " preds,\n", + " keys,\n", + " class_dict,\n", + " class_probs,\n", + " patch_coords,\n", + " classes_predicted,\n", + " labels,\n", + " verbose=False,\n", + " )\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_object = rust_patch_predictions_as_annotations(\n", + " preds,\n", + " keys,\n", + " class_dict,\n", + " class_probs,\n", + " patch_coords,\n", + " classes_predicted,\n", + " labels,\n", + " verbose=False,\n", + " )\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(num_patches)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " num_patches *= 10\n", + " num_classes *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 3: Patch Predictions As QuPath\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Patch predictions as qupath written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from shapely.geometry import mapping\n", + "\n", + "\n", + "def py_patch_predictions_as_qupath_json(\n", + " preds: list | np.ndarray,\n", + " class_dict: dict,\n", + " patch_coords: list | np.ndarray,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> dict:\n", + " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", + " features = []\n", + " # pick a color for each class based on the class index, using a colormap\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " tqdm_loop = tqdm(\n", + " range(np.asarray(patch_coords).shape[0]),\n", + " leave=False,\n", + " desc=\"Converting outputs to QuPath JSON.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for i in tqdm_loop:\n", + " class_idx = int(preds[i])\n", + " class_name = class_dict[class_idx]\n", + " polygon_geo = Polygon.from_bounds(*patch_coords[i])\n", + " polygon_feat = mapping(polygon_geo)\n", + "\n", + " feature = {\n", + " \"type\": \"Feature\",\n", + " \"id\": f\"patch_{i}\",\n", + " \"geometry\": polygon_feat,\n", + " \"properties\": {\n", + " \"classification\": {\n", + " \"name\": class_name,\n", + " \"color\": class_colours[class_idx],\n", + " }\n", + " },\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_name,\n", + " \"class_value\": class_idx,\n", + " }\n", + "\n", + " features.append(feature)\n", + "\n", + " return {\"type\": \"FeatureCollection\", \"features\": features}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Patch Predictions As QuPath Json with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rust_patch_predictions_as_qupath_json(\n", + " preds: list | np.ndarray,\n", + " class_dict: dict,\n", + " patch_coords: list | np.ndarray,\n", + ") -> dict:\n", + " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " features = rmisc.patch_predictions_as_qupath_json(\n", + " class_colours, preds, class_dict, np.array(patch_coords).astype(\"float\")\n", + " )\n", + " return {\"type\": \"FeatureCollection\", \"features\": features}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "num_patches = 1\n", + "num_classes = 1\n", + "max_patches = 1000\n", + "while num_patches <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(10):\n", + " rng = np.random.default_rng(42)\n", + " class_probs = rng.random(\n", + " (num_patches, num_classes),\n", + " dtype=np.float64,\n", + " )\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", + " x = np.arange(num_patches, dtype=np.float64) * 10\n", + " y = np.zeros(num_patches, dtype=np.float64)\n", + " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + " classes_predicted = list(range(num_classes))\n", + " verbose: bool = False\n", + " start_time = time.time()\n", + " python_object = py_patch_predictions_as_qupath_json(\n", + " preds,\n", + " class_dict,\n", + " patch_coords,\n", + " verbose=False,\n", + " )\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_object = rust_patch_predictions_as_qupath_json(\n", + " preds,\n", + " class_dict,\n", + " patch_coords,\n", + " verbose=False,\n", + " )\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(num_patches)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " num_patches *= 10\n", + " num_classes *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 4: Json.dump\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'rmisc' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 22\u001b[39m json.dump(example_dict, handle)\n\u001b[32m 23\u001b[39m python_end_time = time.time() - start_time\n\u001b[32m 24\u001b[39m python_times = np.append(python_times, python_end_time)\n\u001b[32m 25\u001b[39m start_time = time.time()\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m rmisc.json_dump_python_object(\u001b[33m\"example.txt\"\u001b[39m, example_dict)\n\u001b[32m 27\u001b[39m rust_end_time = time.time() - start_time\n\u001b[32m 28\u001b[39m rust_times = np.append(rust_times, rust_end_time)\n\u001b[32m 29\u001b[39m sizeofarray.append(len(example_dict))\n", + "\u001b[31mNameError\u001b[39m: name 'rmisc' is not defined" + ] + } + ], + "source": [ + "import json\n", + "import time\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "\n", + "example_dict = {}\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 10\n", + "maxarraysize = 10000\n", + "with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", + " json.dump({\"a\": 1}, handle)\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for j in range(len(example_dict), i):\n", + " example_dict[str(j)] = 1\n", + " for _j in range(10):\n", + " start_time = time.time()\n", + " with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", + " json.dump(example_dict, handle)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rmisc.json_dump_python_object(\"example.txt\", example_dict)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(len(example_dict))\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 100, 1000, 10000]\n", + "[[np.float64(0.0008439064025878906), np.float64(0.000819706916809082)], [np.float64(0.0009901285171508788), np.float64(0.0008368015289306641)], [np.float64(0.001258087158203125), np.float64(0.0010589838027954101)], [np.float64(0.005210328102111817), np.float64(0.0035884857177734377)]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "print(sizeofarray)\n", + "print(timings)\n", + "plt.xlabel(\"Size of dictionary\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 5: String To Tuple\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def py_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return tuple(substring.strip() for substring in in_str.split(\",\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return rmisc.string_to_tuple(in_str)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "i = 1\n", + "in_str = \"\"\n", + "max_patches = 100000\n", + "while i <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for j in range(int(len(in_str) / 2), i):\n", + " in_str += \" , \" + str(j)\n", + " for _j in range(10):\n", + " start_time = time.time()\n", + " python_object = py_string_to_tuple(in_str)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_object = rust_string_to_tuple(in_str)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " sizeofarray.append(len(in_str))\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGxCAYAAAB2qSLdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAb11JREFUeJzt3Xd0VNX+/vH3zKRDCr0GQi+hBRABAekdKVIEUb92VEAFG3JtqCCCSFPw2r1emkgTQZTeQSCE3qRDCCWd9Jnz+2Ou+RkNkISZzIQ8r7WylvvM3vt8ZgzMwyn7mAzDMBARERGRLMyuLkBERETEHSkkiYiIiGRDIUlEREQkGwpJIiIiItlQSBIRERHJhkKSiIiISDYUkkRERESyoZAkIiIikg0PVxdQkNlsNi5evIi/vz8mk8nV5YiIiEgOGIZBQkIC5cuXx2y+8fEihaTbcPHiRYKDg11dhoiIiOTBuXPnqFix4g1fV0i6Df7+/oD9Qw4ICHBxNSIiIpIT8fHxBAcHZ36P34hC0m348xRbQECAQpKIiEgBc6tLZXThtoiIiEg2FJJEREREsqGQJCIiIpINXZPkZDabjbS0NFeXUSh5enpisVhcXYaIiBRQCklOlJaWxqlTp7DZbK4updAKCgqibNmyWsdKRERyTSHJSQzDIDIyEovFQnBw8E0XqxLHMwyDpKQkLl++DEC5cuVcXJGIiBQ0CklOkpGRQVJSEuXLl8fPz8/V5RRKvr6+AFy+fJnSpUvr1JuIiOSKDm84idVqBcDLy8vFlRRufwbU9PR0F1ciIiIFjUKSk+laGNfS5y8iInmlkCRON2XKFBYtWuTqMkRERHJF1yRJFl9//TVbtmwB7LfQBwcH07dvX+rUqZOj8TNmzKB06dIMGjQoc9uKFSto2rQp/fr1c0rNIiIizqAjSZLFhg0b2LRpE82bN6dBgwYcOHCA+vXrs3jx4hyNX7VqFdu2bXNylSIiIs6nI0nyD+XKleOJJ54A4JlnniExMZFx48bh5+fHhg0bGD9+fJb+//3vf7lw4QKlSpVi3759nD59OnP8e++9l9lv/fr1rF69GqvVyoABA2jcuHGWeQ4cOMD8+fOJjo6mQYMGPPzww5l3qIH9tF1ISAjFixe/6TwiIlLwRZyLZf+FOIY2r+yyGnQkSW6pXr16nDt3jqpVqzJhwgQOHDiQ+ZrNZmPMmDF4eHhQrVo1ihUrRrly5WjevDnNmzfPDDnff/89b7/9NiVKlODatWs0b96cPXv2ZM6zcuVKGjduTGRkJCEhIcycOZNWrVplWa18xYoVjBw58qbziIhIwWYYBl9sOkn/2Vt5c+kBdp2OdlktOpKUTwzDIDnd6pJ9+3pa8nyXl9VqZc2aNdSrV48aNWrQpk0bvvrqK6ZMmQLAb7/9xqVLl3jooYcoVaoUwcHBVK9ePfNI0p+KFy/OmjVrMtcqOnHiBN9++y2NGzfGMAxGjhzJyJEjmTx5MgBPPvkkVapU4d///jfDhw/P0TwiIlKwRV9P46UfIlh7xL4QcLd6ZalRxt9l9Sgk5ZPkdCt131zlkn0fGtcFP6+c/68+evQoTzzxBBkZGWzfvp24uDh+/vlnwB5eRo0axcSJE/H09OSrr76iZ8+elCpV6qZztmvXLstijrVq1eL8+fMAXLhwgRMnTjB48ODM14OCgujRowcbNmzIEpJuNo+IiBRcO05e4/l5e7kUn4KXh5k3etZl6N2VXLqUi063yT8EBATQvHlz2rVrxyeffMLJkyczj9T079+f9PR0fvrpJ6Kjo1m6dCmPPfbYLef867VFABaLJXPBzT8fHVKyZMksfUqWLElUVFSO5xERkYLHajOYtvo4gz/fzqX4FKqWKsKSZ+/hoeaVXb7WnY4k5RNfTwuHxnVx2b5z468Xbv+dj48PQ4cO5auvvuLChQsUL16cbt26Zb6el1/o4OBgAM6cOUPlyv//Ar0zZ85QqVKlXM8nIiIFw+X4FJ6ft5dtJ68BcH/jiozrHUoRb/eIJ+5RRSFgMplydcrLnT355JM0btyYo0eP8sgjj2Q5/VW8eHGio3N3kV2pUqVo06YN06ZNo1WrVpjNZg4fPsyKFSuYN2+eo8sXERE3sP7oZUYviODa9TT8vCy827se9zep6OqysrgzvrUlXzVo0ICwsDB27drFo48+muW13r17M3ToUNLS0ihatGiWJQBu5tNPP6Vz5840btyY6tWrs3r1aoYMGULfvn2d8RZERMRF0q02Jv96lM82nASgTrkAZg4Jo1qpoi6u7J8UkiSLxx57jISEhFv2CwsLw8fHh5o1a2bZ3q9fP3bt2kVERATXr1/H19eX0aNH/+N6owcffJDr169ntkNDQzl+/Dhr164lJiaGN954g4YNG2YZk5N5RETEfZ2LTmLkvHDCz8YC8FDzyoztUQefXF4Wkl9MhmEYri6ioIqPjycwMJC4uDgCAgKyvJaSksKpU6eoUqUKPj4+LqrQOeLj46lcuTKffPIJQ4YMcXU5N3Un/38QESlIfjkQySsL9xGfkoG/jwcf3t+AbvXLuaSWm31//5WOJEmuvPzyy/z2229UrVqVgQMHurocERFxcynpVsavOMx3284A0Cg4iBmDwwgu7ufiym5NIUlypXHjxjRr1oxu3brh4aFfHxERubGTVxJ5bk44hyPjAXj63qq81LkWnpaCsQKRvuUkV/664KOIiMiNLNpznn8tOUBSmpUSRbz4aGBD2tYq7eqyckUhSURERBzmemoGby49yI977E9DaFG1BFMfaESZgIJ3XahCkoiIiDjE4ch4npuzh5NXrmM2wfMdajK8fXUsZteunJ1XCkkiIiJyWwzD4PsdZ3l3+SHSMmyUCfBm2gNhNK9awtWl3RaXh6SYmBgWLlxIVFQU9evX57777rvloy1yMuZWfZYtW8bOnTuzjClTpgwjRoxw3JsTERG5w8Ulp/Paj/tYeeASAO1rl2bygIYUL+Ll4spun0svLz9z5gz169fnu+++49q1a4wYMYLevXtjs9lua0xO+qxYsYIlS5bg4+OT+ePt7e3U9ysiInInCT8bQ4/pm1h54BKeFhP/6lGHLx5uekcEJHDxkaRXXnmF4OBg1q1bh4eHB8OHD6d27dosWLCABx54IM9jcjpv7dq1+de//pUv71VEROROYbMZfLH5JB/+cpQMm0FwcV9mDm5Mw+AgV5fmUC47kpSRkcFPP/3EQw89lLneTrVq1WjTpg2LFi3K85jczHvmzBnGjx/PJ598QkREhLPeaoGya9cuFi5cyMKFC1m6dCm7d+8mPT3dofu4cOECy5Ytc+icIiKSP64lpvLYt78zfsURMmwGPRqU4+eRre+4gAQuDElnz54lOTmZ6tWrZ9leo0YNjh49mucxuZnXbDYTGxvL1q1badasGa+99tpNa05NTSU+Pj7Lz51m5syZPPPMM8ybN4+vv/6afv36Ubt2bQ4ePOiwfWzbto2HH37YYfOJiEj+2PbHNbpP38T6o1fw9jAzvm99Zg4OI8DH09WlOYXLTrf9+VDSvz8zJTAw8IYPLM3JmJzOO2rUqCwPZ33wwQfp0aMH3bp149577812/xMmTOCdd9655Xsr6EJDQ1m4cCEAaWlptGzZkueff57Vq1cDcOLECU6dOkWnTp0yx0RFRbFlyxb69euXuS0+Pp49e/YA9pW6AwICuHLlCtu3byc9PT1zH7Vr16ZevXr59fZERCSXrDaD6WuOM2PtcWwGVCtVhE8ebEztsjd+7tmdwGVHkooWLQpAXFxclu2xsbGZr+VlTE7n/fvT67t3706FChXYsGHDDWseM2YMcXFxmT/nzp27Yd87hZeXF507d85yOnL58uW8+OKLWfqFh4dneZbbunXrCAkJYcyYMbz//vs0atSI5cuXc/nyZbZs2UJ6ejrz5s1j3rx5OtUpIuLGLsWlMOTz7UxbYw9IA5pU5KcRre74gAQuPJJUqVIl/Pz8OHbsGF26dMncfuzYMWrXrp3nMXmZ9082m43k5OQbvu7t7Z33O+AMA9KT8jb2dnn6wS2WVbiZkydPUrJkyVyNmTBhAo8//jiTJk0C7KF1x44dhIaGMnr0aJ544onMI0kiIuKe1h29zOgFEURfT6OIl4X3+9anT1gFV5eVb1wWkiwWC7179+a7775j2LBheHp6cvToUTZt2sS8efMy+y1ZsoRz584xYsSIHI3JSZ+MjAzCw8O56667suwnMjKSDh06OOcNpyfB+PLOmftWXr8IXkVy3P3KlSssXLiQjIwMduzYwaJFi/jPf/6Tq116e3tz5swZkpOT8fX1JTAwkM6dO+e2chERcYG0DBuTVh3h802nAAgtH8CMwWFULZX9mZ47lUuXAJg4cSKtW7fmnnvuoWnTpixZsoQ+ffpw//33Z/ZZvnw527dvz1zkMSdjbtXHZDLx4osv4ufnR2hoKGfPnmX58uW8+uqrdOzYMX8/BDd0+fJl5s2bR2pqKlu3bqVbt2707ds3V3N8+OGHPPbYY5QqVYp77rmHnj178uSTT+LjU/Ce3SMiUpici05i+NxwIs7FAvB/LUMY07023h4W1xbmAi4NScHBwezfv5/FixcTFRXFV199RZcuXbKsjN23b1+aNWuWqzG36mOxWNi8eTMbN24kPDycsLAwPvjgA2rUqOG8N+vpZz+i4wqefrnq/tcLt6OiomjatCmvvfYaU6ZMAex3Bf59wc+UlJQs7Tp16rBt2zYiIyNZu3Yt77//PqtWrWL58uW38UZERMSZVuyP5NUf95GQkkGAjwcf9m9I13plXV2Wy7j8sST+/v43vR28R48euR6T0z5t2rShTZs2OSv0dplMuTrl5S7KlCnDRx99xJAhQ3jyySepU6cOFSpU4MKFC6SmpmZeo/X3C94jIyMpV64c5cqV48EHH8Rms/H8888D9ovrU1NT8/29iIhI9lLSrby7/BD/3XEWgMaVgpg+OIyKxXL3j2yHijkDkRFQ9z6XleDykCTub+DAgUyePJkxY8awZMkSOnXqhI+PDw888AB9+/Zl165dLFiwIMuYoUOHEhwczD333IPVauXjjz/OPN1Zv359rFYrb7zxBg0bNtQSACIiLnTiciLD5+zhyKUEAJ5pW41RnWriaXHRDfCGAXu+hVVjwZYBpetASSee6bkJlz67TdzPXXfdle06UVOnTsXT05PIyEgCAgLYsWMH1atXZ/369dSqVYtly5ZluS5s1apVtG/fnp07dxIeHs4bb7zBrFmzAKhQoQIrV67k6tWrzJ8/X0sAiIi4yMLd5+k1YzNHLiVQsqgX3z3WjFe71nZdQIq7AP/tDz89D2mJUK4RmF13PMdkGIbhsr0XcPHx8QQGBhIXF/ePxStTUlI4deoUVapU0cXKLqT/DyIi/5SYmsGbSw6wKPwCAPdUL8HHgxpR2t9Ff08aBkTMg5WvQmocWLyhwxvQ/FkwO/6C8Zt9f/+VTreJiIgUIgcvxjFiTjgnr17HbIJRnWryTNvqWMx5X0/vtiREwfIX4OgKe7t8Y+g7G0rVck09f6GQJCIiUggYhsF/tp/hvZ8Pk5Zho1ygD9MHh3FXSHHXFXXgR/h5NCTHgNkT2r4G97wAFveIJ+5RhYiIiDhNXFI6r/wYwaqDUQB0rFOaSf0bUqyIl2sKun7VHo4OLbG3yzawHz0qE+qaem5AIUlEROQOtvtMDCPnhnMhNhlPi4nXutXhsXtCsqwvmK8O/wTLX4TrV+wXZbd+Cdq8BBZP19RzEwpJIiIidyCbzeDfm04yadVRrDaDyiX8mDE4jAYVg1xTUHIMrHgF9v9vyZhSdexHj8o3ck09OaCQ5GS6edC19PmLSGF0NTGVUQsi2HjsCgC9GpZnfN96+Pu46GjNsV9h2QhIvAQmM9zzPLQdAx55fGh8PlFIchKLxX7LYlpaGr6+vi6upvBKSkoCwNPT/Q7jiog4w9YTV3l+/l6uJKTi42nm7V6hDLor2DWn11LiYNXrEP69vV2iBvSZBcF33Xycm1BIchIPDw/8/Py4cuUKnp6emM1atzM/GYZBUlISly9fJigoKDO0iojcqTKsNqavOc6MdScwDKhRuigzhzSmVll/1xT0xzpYOhzizwMm+5pHHd4Az4Jz4EAhyUlMJhPlypXj1KlTnDlzxtXlFFpBQUGULVt4H84oIoVDZFwyz8/dy87T0QAMahrM2/eF4uvlgn8gpibCb2/Cri/t7WIh9qNHlVvmfy23SSHJiby8vKhRowZpaWmuLqVQ8vT01BEkEbnjrTkcxUs/RBCTlE4RLwvj+9Wnd6MKrinm9GZY8izE/u/gwF1PQMd3wLuoa+q5TQpJTmY2m/U4DBERcbi0DBsTfznCl5tPAVCvQgAzBzcmpGQRFxSTBGvGwQ77MzoJDIbeM6Fq2/yvxYEUkkRERAqYM9euM2JuOPvOxwHw6D0hvNatNt4eLjh6fm4nLB4G0X/Y240fhs7vg8+Nn4lWUCgkiYiIFCA/RVzk9UX7SUjNINDXk8kDGtKpbpn8LyQ9BdaPh60zwLCBfzm4bwbU6JT/tTiJQpKIiEgBkJJu5Z2fDjF351kAmlYuxvTBYZQPcsHdYhf2wJJn4MoRe7vBA9DtA/Atlv+1OJFCkoiIiJs7HpXA8DnhHI1KwGSC59pW54WONfCw5PPyMhlpsPFD2DQFDCsUKQW9pkHtHvlbRz5RSBIREXFThmHww67zvLnsACnpNkoW9WbqoEa0qlEy/4u5tB8WPwNR++3t0H7QfTIUKZH/teQThSQRERE3lJiawdjF+1m69yIArWuUZMrARpTyz+dHeVgzYPPHsGEi2NLBtzj0nAKhffO3DhdQSBIREXEzBy7EMXzOHk5fS8JiNjGqU02eubcaZnM+P1rk8hFYMgwuhtvbtXtCz4+haOn8rcNFFJJERETchGEYfLP1NBNWHCHNaqN8oA/TB4fRNKR4/hZis8K2mbD2fbCmgk8gdJsEDQaCK54B5yIKSSIiIm4gNimNlxfu47dDUQB0qluGSf0bEOTnlb+FXPvDfufauR32dvVOcN90CCifv3W4AYUkERERF9t9JpoRc8K5GJeCl8XM691r80jLEEz5edTGZoOd/4bVb0NGMnj5Q9fxEPZQoTp69FcKSSIiIi5isxnM2vAHU347htVmEFLCj5lDGlOvQmD+FhJzGpY8B2c229tV28J9MyEoOH/rcDMKSSIiIi5wJSGVUQv2sun4VQB6NyrP+33rU9Q7H7+aDQN2fQW/vgHp18GzCHQeB00fL7RHj/5KIUlERCSfbT5+lRfm7+VqYio+nmbG9a7HgCYV8/f0Wtx5WDocTq6ztyvfA70/geJV8q8GN6eQJCIikk8yrDamrj7OJ+tPYBhQq4w/M4eEUaOMf/4VYRiw97/wyxhIjQcPH+jwFtw9DMz5vIK3m1NIEhERyQcXY5MZOTecXWdiABjcrBJv9aqLj6cl/4qIj4TlL8CxX+ztindBn1lQskb+1VCAKCSJiIg42W+Honh5YQSxSen4e3swvl99ejXMx1vqDQP2/wArXoaUWLB4QbvXoeVIMOdjSCtgFJJEREScJDXDygcrj/D1ltMANKgYyMzBjalUwi//iki8Yj96dGS5vV2uIfSZDWXq5l8NBZRCkoiIiBOcvnqd4XP3cOBCPACPt6rCq11r4+WRj9f9HFwCP4+CpGtg9oA2r0DrUWDxzL8aCjCFJBEREQdbuvcCYxcfIDE1gyA/Tz4a0JAOdcrkXwFJ0bDiJTjwo71dOhT6zrIfRZIcU0gSERFxkOQ0K28vO8j8XecAaBZSnGmDG1Eu0Df/iji6En56HhKjwGSBVi/Cva+CRz4/3uQOoJAkIiLiAMeiEnjuv3s4fjkRkwlGtKvOyA418LDk0+m15Fj7bf0Rc+ztkrXsR48qNMmf/d+BFJJERERug2EYzPv9HO/8dJCUdBul/L2ZNqgRLauXzL8iTqyGpSMg4SJggpbDod2/wNMn/2q4AykkiYiI5FFCSjqvLz7ATxEXAWhTsxRTBjakZFHv/CkgNQFWjYU939rbxava71yrdHf+7P8Op5AkIiKSB/vOxzJibjhnriVhMZt4uUstnmpdFbM5nx4tcmqj/aG0cWft7buH2VfO9srH5QXucApJIiIiuWAYBl9tOc0HKw+TbjWoEOTL9MFhNKlcLH8KSLsOq9+Gnf+2t4MqQe9PoUrr/Nl/IaKQJCIikkMx19N4eWEEqw9fBqBLaBk+vL8hgX75tO7Q2e2w5BmIPmlvN3kUOr8L3vn47LdCRCFJREQkB34/Hc3IueFExqXgZTHzr551eKh5ZUymfDi9lp4Ma9+DbZ8ABgRUgPtmQPUOzt93IaaQJCIichNWm8Gs9Sf4ePVxrDaDqiWLMGNIGKHlA/OngPO7YckwuHrM3m70IHQZD75B+bP/QkwhSURE5AYux6fw4oK9bDlxDYB+YRUY16ceRb3z4eszIxU2TITNH4Nhg6JloNd0qNXV+fsWQCFJREQkWxuPXWHUgr1cTUzD19PCu33q0b9JxfzZeWQELH4GLh+0t+sPgG4fgl/x/Nm/AApJIiIiWaRbbUz57Riz1v8BQO2y/swcEkb10vlwcbQ1HTZ9BBsngS0D/EpCzylQt7fz9y3/oJAkIiLyP+djkhg5N5w9Z2MBePDuSrzRsy4+nhbn7zzqkP3ao8gIe7vOfdBjChQt5fx9S7YUkkRERIBVBy/x8g8RxKdk4O/twQf3N6BHg3LO37E1A7ZOh/UTwJoGPkHQ4yOodz/kx51zckMKSSIiUqilpFuZsOIw3247A0DD4CBmDg4juHg+rFx95Zh93aMLu+ztml2h1zTwL+v8fcstKSSJiEihdfJKIiPmhnPwYjwAT7Wpykuda+HlYXbujm1W2D4L1r4LGSngHQBdP4BGQ3T0yI0oJImISKG0JPwCYxfv53qaleJFvPhoQEPa1S7t/B1Hn4Qlz8LZbfZ2tfb2hSED8+nOOckxhSQRESlUktIyeGvpQX7YfR6Au6sUZ9oDYZQN9HHujm022PUl/PYmpCeBZxHo8p790SI6euSW3CIkXb58mcuXL1O1alX8/HJ2DjgnY3I6b2JiIkeOHKFMmTIEBwfn6T2IiIj7O3IpnuFzwjlxORGzCUa0r8HIDjWwmJ0cUmLPwtLn4NRGezukNfSeCcVCnLtfuS1OPul6c2lpaTz44INUqlSJXr16Ubp0aT7//PPbHpPbeR966CGaNWvGRx995JD3JSIi7sUwDP674wy9Z27hxOVESvt7898nmvNip5rODUiGAbu/hU9b2gOSh699UciHlykgFQAuPZL03nvvsW7dOo4fP05wcDDz589n8ODBNG7cmCZNmuR5TG7mnTlzJgkJCdSvX9/p71dERPJffEo6Yxbt5+d9kQC0rVWKjwY0pERRbyfv+CIsGwknfrO3g++GPrOgRDXn7lccxqVHkr744gueeOKJzFNcgwYNok6dOnz55Ze3NSan80ZERDBhwgS+/fbb/HmKs4iI5KuIc7H0nL6Zn/dF4mE28Xr32nz1yF3ODUiGARHz4NPm9oBk8YbO78GjKxWQChiXHUmKjIwkMjKSu+66K8v2u+++mz179uR5TE7nvX79Og888ADTpk2jQoUKjnhLIiLiJmw2gy83n2LiL0fIsBlULObLjMFhhFUq5twdJ0TB8hfh6M/2dvnG0Hc2lKrl3P2KU7gsJF27Zn+icokSJbJsL1myZOZreRmT03mHDx9OixYt6N+/f45rTk1NJTU1NbMdHx+f47EiIpI/oq+n8dIPEaw9chmA7vXLMqFfAwJ9PZ274wM/ws8vQXI0mD2h7WtwzwtgcYt7pCQPXPZ/ztPT/sv619ABkJycnPlaXsbkpM+KFStYvHgxS5YsYdeuXZmvX758mV27dtG0adNs9z9hwgTeeeedHL9HERHJXztOXuP5eXu5FJ+Cl4eZN3rWZejdlZx7ScX1a/DzKDi0xN4uWx/6zIay9Zy3T8kXLgtJFStWxGQycfHixSzbL168SKVKlfI8Jid9EhMTqV69Oi+99FLm6+fOnSM2NpZjx46xY8cOLJZ/PsxwzJgxjBo1KrMdHx+vJQNERNyA1WYwc+0Jpq05hs2AqqWKMHNwY+qWD3Dujg8vh+UvwPUrYLJAm5eg9Uvg4eXc/Uq+cNmF20WKFKF58+b8/PPPmduSk5NZs2YNHTp0yNx25swZDh48mOMxOekzcOBAdu3aleWnZs2aDB48mF27dmUbkAC8vb0JCAjI8iMiIq4VFZ/C0C928PFqe0C6v3FFfhreyrkBKTkGFj0F8x+0B6RSdeDJNdDudQWkO4hLT5S+++67dO3alVq1atGiRQumTZtGUFAQTz/9dJY+27dv58CBA7kac6s+IiJS8K0/epnRCyK4dj0NPy8L7/WpR7/GTn68x/HfYNkISIgEkxlajvxfOHLykgKS71y6BECHDh1YtWoVERERvPPOOwQHB7N58+YsR2hCQkKoV69ersbkpM/fhYaG3vA0n4iIuJd0q40JKw/zf1//zrXradQpF8BPI1o5NyClxMPS4fDf/vaAVKI6PPYrdHpHAekOZTIMw3B1EQVVfHw8gYGBxMXF6dSbiEg+ORedxMh54YSfjQXg4RaVeb17HXw8s79UwiFOrrcHpLhzgAmaPwvt/wVeOXuUlriXnH5/675EEREpMH45EMkrC/cRn5KBv48Hk/o3oGu9cs7bYWqi/YG0u/63GHGxEOj9KYTc47x9ittQSBIREbeXkm7l/Z8P85/tZwAIqxTE9AfCCC7uxCM5p7fA0mch5rS9fdcT0PEd8C7qvH2KW1FIEhERt/bHlUSGzwnncKR9Ad+n763KS51r4Wlx0mW1aUmw9l3YPgswIDAY7psB1do5Z3/ithSSRETEbf24+zxvLD1AUpqVEkW8+GhgQ9rWKu28HZ7bCUuegWsn7O2wh6DLePDRdaeFkUKSiIi4neupGbyx9ACL9lwAoEXVEkx9oBFlAnycs8P0FFg/HrbOAMMG/uWg13So2dk5+5MCQSFJRETcyqGL8Qyfu4eTV65jNsELHWvyXLvqWMxOerTIxXBYPAyuHLG3GzwA3T4AXyc/DFfcnkKSiIi4BcMw+H7HWd5dfoi0DBtlAryZ/kAYd1ctcevBeZGRBhsnwaaPwLBCkVLQaxrU7uGc/UmBo5AkIiIuF5eczms/7mPlgUsAtK9dmskDGlK8iJMe8XHpACwZBpf229uhfaH7R1DESYFMCiSFJBERcanwszGMmBvO+ZhkPC0mXu1am8dbVcFkcsLpNWsGbPkY1k8EWzr4FoceH0G9fo7flxR4CkkiIuISNpvB55tOMmnVUTJsBsHFfZk5uDENg4Ocs8MrR+3XHl3cY2/X6gG9pkJRJ94tJwWaQpKIiOS7a4mpjP4hgvVHrwDQo0E5JvSrT4CPp+N3ZrPCtk9g7XtgTQWfQOg2CRoMBGccrZI7hkKSiIjkq21/XOOF+eFExafi7WHmrV6hDG4W7JzTa9f+sK97dG6HvV29E9w3HQLKO35fcsdRSBIRkXxhtRlMX3OcGWuPYzOgeumizBwSRu2yTlio0WaDnf+G1W9DRjJ4+UPX8fbFIXX0SHJIIUlERJzuUlwKz88LZ8epaAAGNq3I2/eF4uflhK+hmNOwdDic3mRvV7kXes+EoEqO35fc0RSSRETEqdYduczoHyKIvp5GES8L7/etT5+wCo7fkWHA7q/h1zcgLRE8/aDTOGj6OJid9Jw3uaMpJImIiFOkZdiYtOoIn286BUBo+QBmDmlMlZJFHL+zuPOwbAT8sdbertQS+nwCxas6fl9SaCgkiYiIw529lsSIeeFEnIsF4P9ahjCme228PSyO3ZFhwN458MtrkBoPHj7Q4U24+xkdPZLbppAkIiIO9fO+SF77cR8JqRkE+HgwaUBDuoSWdfyOEi7BT8/DsV/s7QpNoe9sKFnD8fuSQkkhSUREHCIl3cq7yw/x3x1nAWhSuRjTHmhExWJ+jt2RYcD+hbDiJUiJBYsXtB0DLUeCRV9r4jj6bRIRkdt24nIiw+fs4cilBEwmeObearzYqSaeFgef8kq8Aj+/CId/srfLNYQ+s6FMXcfuRwSFJBERuQ2GYbBw93neXHqQ5HQrJYt6MWVgI9rULOX4nR1aCstfhKRrYPaANq9A61FgccIq3SIoJImISB4lpmbwxpIDLA6/AMA91Uvw8aBGlPb3ceyOkqJhxctwYKG9XToU+s6yH0UScSKFJBERybWDF+MYPiecU1evYzbBqE41eaZtdSxmB69mfXSl/eLsxCgwWaDVi3Dvq+Dh5dj9iGRDIUlERHLMMAz+s/0M7y0/TJrVRrlAH6YPDuOukOKO3VFyLPwyBiLm2Nsla9mPHlVo4tj9iNyEQpKIiORIXFI6r/wYwaqDUQB0rFOaSf0bUqyIg4/qnFgNy0ZC/AXABC2HQ7t/gaeDT+OJ3IJCkoiI3NLuMzGMnBvOhdhkPC0mxnSrw6P3hGBy5MNiUxPg13/B7m/s7eJVoc8sqNTccfsQyQWFJBERuSGbzeCzjSeZ/OtRrDaDyiX8mDE4jAYVgxy7o1MbYelzEGtfY4lmT0PHt8DLCY8wEckhhSQREcnW1cRURi2IYOOxKwD0alie8X3r4e/jwFvu067D6ndg52f2dlAl6P0JVGnjuH2I5JFCkoiI/MPWE1d5fv5eriSk4uNp5u1eoQy6K9ixp9fOboclz0D0SXu7yf9B5/fA299x+xC5DQpJIiKSKcNqY9qa48xcdwLDgBqli/LJg42pWcaBwSU9Bda9B1tnAgb4l4feM6B6R8ftQ8QBFJJERASAyLhknp+7l52nowF44K5g3uoViq+XxXE7Ob8blgyDq8fs7UYPQpfx4BvkuH2IOIhCkoiIsOZwFC/9EEFMUjpFvT0Y368+9zUs77gdZKTChomweSoYVihaBnpNg1rdHLcPEQdTSBIRKcTSMmxM/OUIX24+BUD9CoHMGBxGSEkH3lUWuQ8WD4PLB+3tev2h+yTwc/AClCIOppAkIlJInbl2nRFzw9l3Pg6Ax+6pwqvdauHt4aDTa9Z02DQFNn4ItgzwKwE9P4a6vR0zv4iTKSSJiBRCP0VcZMyi/SSmZhDk58mk/g3pVLeM43Zw+bD96FHkXnu7Ti/o8TEULeW4fYg4mUKSiEghkpxmZdzyg8zdeQ6AppWLMX1wGOWDfB2zA2sGbJsB68aDNQ18gqD7ZKjfHxy5fIBIPlBIEhEpJI5HJfDcnD0ci0rEZILn2lbnhY418LCYHbODq8ftR48u7LK3a3SxX5wdUM4x84vkM4UkEZE7nGEY/LDrPG8uO0BKuo2SRb2ZOqgRrWqUdMwObDbYMQvWjIOMFPAOgK4T7Lf36+iRFGAKSSIid7CElHT+teQAS/deBKB1jZJMGdiIUv7ejtlB9ElY8hyc3WpvV2sP982AwIqOmV/EhRSSRETuUAcuxDF8zh5OX0vCYjYxunNNhrWphtnsgKM7Nhvs+hJ+exPSk8CzCHR5D5o8qqNHcsdQSBIRucMYhsE3W08zYcUR0qw2ygf6MH1wGE1DHLQuUexZWDocTm2wt0NaQ++ZUCzEMfOLuAmFJBGRO0hsUhovL9zHb4eiAOhctwwf9m9AkJ/X7U9uGLDnO1g1FtISwMMXOr0Ddz0JZgdd/C3iRhSSRETuELtORzNybjgX41Lwsph5vXttHmkZgskRp7/iL8KykXDiN3s7+G7oMwtKVLv9uUXclEKSiEgBZ7MZzNrwB1N+O4bVZhBSwo+ZQxpTr0Lg7U9uGLBvPqx8BVLiwOIN7f8FLZ4DswMffCvihhSSREQKsCsJqYxasJdNx68C0KdRed7rW5+i3g746z3xMvz0Ahz92d4u39h+9Kh07dufW6QAUEgSESmgNh+/ygvz93I1MRVfTwvv9A5lQJOKjjm9dmAR/DwakqPB7AltX4V7XgSLvjak8NBvu4hIAZNhtfHx6mN8uv4PDANqlfFn5pAwapTxv/3Jr1+DFaPh4GJ7u0x96DsLyta//blFChiFJBGRAuRibDIj54az60wMAIObVeKtXnXx8XTA9UFHfoafnofrV8Bkgdajoc3L4OGAO+NECiCFJBGRAuK3Q1G89EMEccnp+Ht7MOH++vRsUP72J06OgZWvwb559nap2vZrjyo0vv25RQowhSQRETeXmmFlwoojfLP1NAANKgYyc3BjKpXwu/3Jj/8Gy0ZAQiSYzNByJLQdA54+tz+3SAGnkCQi4sZOX73O8Ll7OHAhHoAnWlXhla618fK4zcUbU+Jh1esQ/h97u0R1+9Gj4Ga3WbHInUMhSUTETS3de4Gxiw+QmJpBMT9PJg9oSIc6ZW5/4pPr7Y8ViTsHmKD5M9D+DfBywJEpkTuIy9eRX7BgAffccw/Vq1enb9++HD582CFjbtUnJiaGN998k7vvvpvQ0FAGDhzIrl27HPa+RETyKjnNyqsL9/H8vL0kpmbQLKQ4K55vffsBKTXRflv/d73tASmoMvzfz9B1ggKSSDZyHZJOnz7Nhx9+SM+ePWnUqBGNGjWiV69eTJo0iTNnzuRqrsWLF/Pggw/y0EMP8eOPP+Lv78+9997LlStXbmtMTvq88MILBAQEMHv2bObNm0epUqW49957OX78eG4/EhERhzl6KYH7Zm5m/q5zmEwwsn115jx5N+UCfW9v4tNbYPY98PsX9nbTx+GZrRByz+0XLXKHMhmGYeSk48mTJ3nllVdYunQpderU4a677qJMGfu/aqKioti5cydHjhyhT58+TJw4kapVq95yzsaNG9O4cWO++ML+hzYjI4Ny5coxYsQI3nzzzTyPyUkfm82G+S8PZLRarfj4+PDZZ5/x2GOP5eQjIT4+nsDAQOLi4ggICMjRGBGR7BiGwbzfz/H2soOkZtgo5e/NtEGNaFm95O1NnJ4Ma8bB9lmAAYHBcN8MqNbOIXWLFEQ5/f7O8TVJLVq04KmnnmLy5MmEhIRk2+f06dN8+eWXtGjRgqioqFsWGB4ezquvvvr/i/HwoEOHDmzcuDHPY3I6r/lvT6yeP38+FouFFi1a3LRuERFHS0hJZ8yi/SzfFwlAm5qlmDKwISWLet/exOd+hyXD4NoJezvsIegyHnz0jzqRnMhxSDp06BAlSpS4aZ+QkBDeffddXnjhhVvOd+HCBQDKli2bZXuZMmWIiIjI85jczLt+/XqGDh1KfHw8FouFZcuWUadOnRvWnJqaSmpqamY7Pj7+hn1FRHJi3/lYhs8J52x0Eh5mEy91qcVTratiNt/Go0UyUmHdeNg6HQwb+JeDXtOhZmfHFS5SCOT4mqSbBSTDMDhx4gSJiYm37Psnm80G2I/y/JWnpydWqzXPY3Izb4sWLdi+fTsbN25k8ODBPPDAAxw6dOiGNU+YMIHAwMDMn+Dg4Fu9TRGRbBmGwZebT3H/rK2cjU6iQpAvC4a1YNi91W4vIF0Mh8/uhS1T7QGpwSB4dpsCkkge5Onutt9//53nnnsusz1kyBBq1KhB2bJl2bRpU47mKFWqFABXr17Nsv3q1auZr+VlTG7m9fb2pmLFijRq1IhPP/2U8uXL8+mnn96w5jFjxhAXF5f5c+7cuVu9TRGRf4i5nsaT3+3i3eWHSLcadA0ty4qRrWlcqVjeJ81Isx89+rwDXDkMRUrBoP9Cv3+D723MK1KI5SkkvfTSSwwZMgSAffv2sXLlSnbt2sXrr7/O2LFjczRH6dKlqVy5Mlu2bMmyffPmzTRrlv1iZjkZk5d5/+Tn50dSUtINX/f29iYgICDLj4hIbuw8FU336ZtYffgyXhYz7/YOZdbQxgT6eeZ90ksH4Iv2sGEiGFao2wee3QF1ejqsbpHCKE8haffu3TRubH+mz2+//Ua/fv1o0qQJI0eOZO/evTme57nnnuPLL78kIiICm83G9OnTOXv2LE899VRmn1deeYWOHTvmasyt+iQlJfHiiy9y6dIlwH7326effsquXbvo379/Xj4SEZGbstoMZqw5zgP/3kZkXApVSxZh8XMteahFCCZTHk+vWTNg4yT4d1u4tB98i0P/r2Hgt1Dk1pc9iMjN5WnF7YCAAE6ePEloaCg//fQTjz/+OACxsbG5OroyevRoIiMjad68ORaLhYCAAObNm5fl4uno6OjMMJPTMbfq4+vrS61atWjZsiWxsbEkJSVRo0YN5s2bR/fu3fPykYiI3NDl+BRemL+XrX9cA6BfWAXe7VOPIt638dCDK0dh8TC4uMfertUDen4M/g5YkVtEgFysk/RXL7zwAkuWLKFu3brs2LGDEydOUKxYMb744gt27tzJv//971zNl5aWRlxcHCVLlvzHv6hiYmJIS0vLXJMpJ2Ny0ycuLg4/Pz88PXN/qFvrJInIrWw4doXRC/ZyNTENX08L7/apR/8mFfM+oc0K2z6Bte+BNRW8A6H7h/YLtPN6REqkkHH4Okl/NXnyZGrUqMGZM2eYMGECxYrZLwr8448/brgI5M14eXnd8GLtP+fOzZjc9AkMDMxZkSIiuZButTHlt2PMWv8HALXL+jNzSGOqly6a90mv/QFLnoVz2+3t6h3tC0MGlHdAxSLyd3k6kiR2OpIkItk5H5PEyLnh7DkbC8DQ5pX4V4+6+Hha8jahzQa/fw6/vQUZyeDlD13eh8YP6+iRSB7k9Ps7xxduDxgwgCNHjtyy36FDhxgwYEBOpxURuaOsOniJ7tM2sedsLP4+Hnz6YGPe61M/7wEp5gx8dx+sfMUekKq0gWe3QpNHFJBEnCzHp9uaN29O8+bNCQsLo1evXjRp0oQyZcpgGAaXLl3i999/Z9myZezfv5833njDmTWLiLidlHQrE1Yc5ttt9gd9NwwOYubgMIKL++VtQsOA3d/Ar/+CtETw9INO4+wPpjXn6cZkEcmlXJ1uu3btGp999hnz5s3jwIED/DnUZDJRv359Bg8ezJNPPpmjFbfvBDrdJiIAJ68kMnxOOIci7Y8qeqpNVV7qXAsvjzyGmbgLsGwE/LHG3q7UAnp/AiWqOahikcItp9/feb4mKS4ujgsXLmAymShfvnyhvABaIUlEFoef51+LD3A9zUrxIl58NLAh7WqVzttkhgF758AvYyA1Djx8oMObcPcwMOfxdJ2I/INT724DMp9fJiJSGCWlZfDW0oP8sPs8AM2rFmfqoDDKBvrkbcKES/DTC3Bspb1doSn0mQWlajqmYBHJtTyHpISEBH799VdOnjzJyy+/DMDhw4epXbt23lePFREpAI5cimf4nHBOXE7EbIKRHWowon0NLHl5MK1hwIEf4efRkBILFi9oOwZajgTLbSw2KSK3LU+n244cOUKnTp2w2WxcvHgx89qkRx55hC5dumQ+1+1Op9NtIoWLYRjM2XmWcT8dIjXDRpkAb6YOCqNFtTxeh5l4BX4eBYeX2dvlGkKf2VCmruOKFpF/cPgSAH/14osv8tBDD3H+/Pks20eOHMnkyZPzMqWIiFuLT0ln+Jxwxi4+QGqGjba1SrFiZOu8B6RDS+HT5vaAZPaAtq/DE2sUkETcSJ6OJAUFBXH69GmCgoIwmUyZR5KuX79O8eLFSU1NdXih7khHkkQKh73nYhkxdw/nopPxMJt4pWstnmhVFXNeTq8lRcOKl+HAQnu7dCj0nWU/iiQi+cKpF24bhpEZhP56/dHJkyd1MbeI3DFsNoMvN59i4i9HyLAZVCzmy4zBYYRVyv5xSbd09Bf4aSQkRoHJDK1ehHtfBQ9vxxYuIg6Rp5DUuXNnPvzwQz766KPMkHT58mWGDx9Ot27dHFqgiIgrRF9PY/SCvaw7egWA7vXLMqFfAwJ9c/8wbFLi7Lf17/2vvV2ypv3ao4pNHFixiDhank63nTt3jrZt22I2mzlx4gStWrUiPDycsmXLsmnTJsqVK+eMWt2OTreJ3Jm2n7zG8/PCiYpPxcvDzJs96/Lg3ZXydufuiTX2hSHjLwAmaPEctP8XePo6vG4RyRmnnm4LDg5m3759zJkzh127dmGz2RgyZAgPPfQQRYvexhOuRURcyGozmLn2BNPWHMNmQLVSRZg5pDF1yuXhH0GpCfDrG7D7a3u7WBX7ukeVWzi2aBFxmjyvuC06kiRyJ4mKT+GFeXvZdvIaAP2bVGRc71D8vPLwb8lTm2DpsxB71t5u9hR0fBu8ijiuYBHJM6evuA1gs9lISkr6x3YdTRKRgmT90cuMXhDBtetp+HlZeK9PPfo1rpj7idKSYPXbsPMzezuwEvT5BKq0cWi9IpI/8hSSjh49yrBhw9i6dStpaWn/eF0Hp0SkIEi32pi86iifbTwJQJ1yAcwcEka1Unn4h97ZHbBkGETb56LJ/0Hn98Db33EFi0i+ylNIeuSRRyhbtixLly4lKCjIwSWJiDjfuegkRswNZ++5WAAeblGZ17vXwcczlw+STU+Bde/B1pmAAf7lofcMqN7R4TWLSP7KU0iKiIjgl19+UUASkQJp5f5IXvlxHwkpGQT4ePBh/wZ0rZeHu3Iv7IbFz8DVo/Z2wyHQdQL4Bjm0XhFxjTyFpJCQEC5fvqyQJCIFSkq6lfd/Psx/tp8BIKxSENMfCCO4uF/uJspIgw0TYfPHYFihSGnoNQ1qd3dC1SLiKnkKSePGjePRRx9l4sSJVKtW7R9rh5QtW9YhxYmIOMofVxIZPiecw5HxAAy7txqjO9fE05LLR1hG7oMlz0DUAXu73v3QfTL4FXdwxSLiankKSSVKlODAgQO0bt0629d14baIuJMfd5/njaUHSEqzUqKIFx8NbEjbWqVzN4k13X7kaMNEsGWAXwnoMQVC+zilZhFxvTyFpGeffZYePXrw7LPP6pSbiLit66kZvLH0AIv2XACgRdUSTH2gEWUCfHI30eXDsHgYRO61t2v3hJ5ToWgph9YrIu4lTyHp7Nmz7Ny5UwsoiojbOnQxnuFz93DyynXMJnihY02ea1cdizkXjxaxWWHrdFg3Hqxp4BNkP7VWvz/k5RElIlKg5Ckk1ahRg/Pnz1O3bl1H1yMiclsMw+D77Wd49+fDpGXYKBvgw7QHGnF31RK5m+jqcfu1R+d/t7drdLFfnB1QOJ5NKSJ5DElDhw5l6NChTJw4kerVq//jwu2QkBBH1CYikitxyem89uM+Vh64BECH2qWZNKAhxYt45XwSmw12zIY170BGCngH2G/rb/Sgjh6JFDJ5enbbrZ6EXVgu3Naz20TcR/jZGEbMDed8TDKeFhOvdq3N462q3PLvqyyiT8KS5+DsVnu7ajvoPRMC8/CIEhFxW059dtvx48fzXJiIiCPZbAafbzrJpFVHybAZVCrux4zBYTQMDsrNJLDrS/jtLUi/Dp5FoMt70ORRHT0SKcTyFJKqV6/u6DpERHLtWmIqo3+IYP3RKwD0aFCOCf3qE+DjmfNJYs/B0ufg1AZ7u3Ir+0Npi4U4vmARKVByHJIOHLAvnFavXr3M/76RevXq3V5VIiK3sO2Pazw/L5zLCal4e5h5q1cog5sF5/z0mmFA+H/gl9chLQE8fKHj29DsKTDncoFJEbkj5Tgk1a9fH7Bfb/Tnf99IYbkmSUTyn9VmMG3NcWasPY5hQPXSRZk5JIzaZXNxXWB8JPw0Eo7/am9XbAZ9ZkFJHSUXkf8vxyEpMjIy2/8WEckvl+JSGDkvnJ2nogEY2LQib98Xip9XDv8qMwzYtwBWvgwpcWDxhvZjocVwMFucWLmIFEQ5Dklly5bliSee4IsvvtCz2UQk3609EsXoBRHEJKVTxMvC+H716d2oQs4nSLwMy1+EI8vt7fJh0Gc2lK7tnIJFpMDL1RIAJpNJp9L+QksAiDhfWoaNSauO8PmmUwCElg9g5pDGVClZJOeTHFwMy0dBcjSYPeHeV6HVi2DJ070rIlLAOXUJABGR/HD2WhIj5u4h4nwcAP/XMoQx3Wvj7ZHDU2PXr8GKl+DgInu7TH3oOwvK3vy6ShERUEgSETf1875IXvtxHwmpGQT6evJh/wZ0Cc3Fqf4jP8NPL8D1y2CyQOvR0OZl8MjF6tsiUqjlOiR5eNx6SEZGRp6KERFJSbcybvkh5uw4C0CTysWYPjiMCkG+OZsgOQZWvgb75tnbpWrb71yr0NhJFYvInSrXIWnmzJnOqENEhBOXExg+J5wjlxIwmeCZe6vxYqeaeFpyuG7R8dWwbDgkRILJDC1HQNvXwdPHuYWLyB0p1yFp2LBhzqhDRAoxwzBYuPs8by49SHK6lZJFvfh4UCNa1yiVswlS4uHXsbDnO3u7eDXoOxuCmzmvaBG54+maJBFxqcTUDN5YcoDF4RcAuKd6CT4e1IjS/jk8+nNyg/2xInHn7O27n4EOb4KXn5MqFpHCQiFJRFzm4MU4hs8J59TV61jMJkZ1qsmwe6thMefg0SKpibD6bfj9c3s7qDL0+RRCWjm1ZhEpPHIVkpKTk51Vh4gUIoZh8N22M7z/82HSrDbKBfowfXAYd4UUz9kEZ7bCkmcg5rS93fRx6DQOvIs6rWYRKXxyFZJ8fHTxo4jcnrikdF75MYJVB6MA6FinDJP6N6BYkRzcmp+eDGvehe2fAgYEVITeM6FaO+cWLSKFkk63iUi+2X0mhpFzw7kQm4ynxcSYbnV49J4QTKYcnF47vwsWD4Nrx+3tsKHQZTz4BDq3aBEptBSSRMTpbDaD2Rv/4KNfj2G1GVQu4cfMwY2pXzEHAScjFdZPgC3TwLBB0bJw33So2cX5hYtIoaaQJCJOdSUhlVEL9rLp+FUAejUsz/i+9fD38bz14IvhsPgZuHLY3m4wCLp+AH45vHZJROQ2KCSJiNNsOXGVF+bv5UpCKj6eZt7uFcqgu4JvfXotIw02TYaNk8GwQpFS0PNjqNMrfwoXEUEhSUScIMNqY9qa48xcdwLDgJplijJzSGNqlvG/9eCog7D4abi0396u2wd6fARFSjq1ZhGRv1NIEhGHioxL5vm5e9l5OhqAwc2CebNnKL5elpsPtGbAlqmw/gOwpYNvMXs4qne/84sWEcmGQpKIOMzqQ1G8tDCC2KR0inp7ML5ffe5rWP7WA68cta97dGG3vV2rO/ScCv5lnFqviMjNKCSJyG1Ly7DxwcojfLXlFAD1KwQyY3AYISWL3HygzWpf82jNu2BNBe9A6DYRGj4AOVkWQETEiVwekiIjI/n++++Jioqifv36DBkyBE/Pm9/1kpMxt+pjGAa//vorW7duxcPDg1atWtGunRakE8mtM9euM2JuOPvOxwHw2D1VeLVbLbw9bnF67dofsORZOLfd3q7WAe6bAYEVnFyxiEjOmF2582PHjlG/fn3WrVuHv78/77//Pp07d8Zqtd7WmFv1sdlshIWFMXXqVCwWC9evX6dfv3489dRTTn/PIneSnyIu0mP6ZvadjyPIz5MvHm7Km73q3jwg2Wyw498wu5U9IHkVhV7TYOiPCkgi4lZMhmEYrtp53759iYmJYd26dZhMJs6fP0+1atX4/PPPefjhh/M85lZ9DMPgwIED1K9fP3Pe1atX06lTJ/bu3UvDhg1zVH98fDyBgYHExcUREBBw+x+ISAGRnGZl3PKDzN15DoC7Qoox7YEwygf53nxgzBlY+hyc3mRvh7SG3p9AscpOrlhE5P/L6fe3y44kpaens3LlSoYMGZK5ZkrFihVp27YtS5cuzfOYnPQxmUxZAhJAaGgoAJcuXXL8mxW5gxyPSqD3J5uZu/McJhOMaF+duU82v3lAMgzY9TXMamkPSJ5+0H0yPLxMAUlE3JbLrkk6e/YsqampVKlSJcv2qlWrsmXLljyPycu8AF999RV+fn40bdr0hn1SU1NJTU3NbMfHx9+wr8idxjAMFuw6x1vLDpKSbqNkUW+mDmpEqxq3WL8o7gIsGwF/rLG3K7WwHz0qUc35RYuI3AaXhaTk5GQA/P2zLi4XEBBAUlJSnsfkZd7Vq1fz9ttvM2PGDEqUKHHDmidMmMA777xzw9dF7lQJKemMXXyAZREXAWhdoyRTBjailL/3jQcZBkTMhZWvQWocePhA+zeg+TNgvsVF3SIibsBlIalo0aIAxMbGZtkeExNzw/ODORmT23k3bdpEnz59eOONNxg2bNhNax4zZgyjRo3KbMfHxxMcHHzTMSIF3f7zcYyYu4fT15KwmE2M7lyTYW2qYTbf5Bb9hCj46Xk4ttLertAU+syCUjXzp2gREQdw2TVJlSpVomjRohw+fDjL9sOHD1O3bt08j8nNvFu2bKF79+6MHj2aN99885Y1e3t7ExAQkOVH5E5lGAZfbzlFv1lbOH0tiQpBvix4ujnPtq1+44BkGLB/IXx6tz0gWbygw1vw2CoFJBEpcFwWksxmMwMGDOCbb77JPEW2d+9etm7dyqBBgzL7zZkzh/Hjx+d4TE7n3bp1K127dmXUqFE6hSbyN7FJaTz1n92889Mh0q0GneuW4eeRrWhSufiNB12/Cgsehh8fh+QYKNsAntoArUeBxeVLsomI5JpLlwC4fPkybdu2BaBRo0b88ssv9O3bly+//DKzzxNPPMH27ds5cOBAjsfcqk9iYiIVKlTAx8eHAQMGZKnpwQcfpEWLFjmqX0sAyJ1o1+loRs4N52JcCl4WM2N71OHhFpUz7xbN1qFlsPxFSLoKZg9o8zK0Hg2Wmy8MKyLiCjn9/nZpSAL7HWOrVq3KXBm7efPmWV5ft24dly5dYvDgwTkec6s+KSkpfPHFF9nW0759+xue7vs7hSS5k9hsBrM2/MGU345htRmElPBj5pDG1KsQeONBSdGw8hXY/4O9Xbqu/dqj8o3ypWYRkbwoMCGpIFNIkjvF5YQURs2PYPOJqwD0aVSe9/rWp6j3TU6THVsFy0ZC4iUwmeGeF6Dta+BxkzveRETcQE6/v3WhgEght+n4FV6cH8HVxFR8PS280zuUAU0q3vj0Wkoc/PI67P3e3i5RA/rOhoo3XmNMRKQgUkgSKaQyrDY+Xn2MT9f/gWFArTL+fPJgGNVL+9940Ik19oUh4y8AJmjxHLT/F3je4nEkIiIFkEKSSCF0ITaZ5+eGs+tMDABD7q7Emz3r4uN5g0UeUxPg1zdg99f2drEq9muPKufsJgcRkYJIIUmkkPn14CVeXriPuOR0/L09mHB/fXo2KH/jAac2wdJnIfasvd3sKej4NngVyZd6RURcRSFJpJBIzbAyYcURvtl6GoAGFQOZObgxlUr4ZT8gLQnWvAM7ZtvbgZWg90yoem/+FCwi4mIKSSKFwKmr1xkxdw8HLtgfyvxEqyq80rU2Xh43WE/27A5Y8gxE/2FvN34EOr8HPrqLU0QKD4UkkTvc0r0XeH3Rfq6nWSnm58lHAxvSvnaZ7Dunp8C692HbTDBs4F8e7psBNTrmb9EiIm5AIUnkDpWUlsHbyw6yYNd5AJpVKc60BxpRLvAGd6Jd2GM/enTliL3dcDB0/QB8g/KnYBERN6OQJHIHOnopgeFz9nD8ciImE4xoX4OR7avjYcnm9FpGGmz8EDZNAcMKRUpDr2lQu3v+Fy4i4kYUkkTuIIZhMO/3c7y97CCpGTZK+3sz9YFGtKxWMvsBl/bD4mcgar+9Xe9+6D4Z/G7yIFsRkUJCIUnkDpGQks6YRftZvi8SgDY1SzFlYENKFs3mMSHWdNj8MWyYCLYM8CsBPT6C0L75XLWIiPtSSBK5A+w7H8vwOeGcjU7Cw2zi5S61eLJ1VczmbB4tcvkwLB4GkXvt7do9oedUKFoqP0sWEXF7CkkiBZhhGHy5+RQTfzlCutWgQpAvM4aE0bhSsX92tllh6wz73WvWNPAJsp9aq98fbvScNhGRQkwhSaSAirmexks/RLDmyGUAuoaWZeL9DQj08/xn56snYMkwOP+7vV2ji/3i7IBy+VixiEjBopAkUgDtPBXNyLnhXIpPwcvDzBs96jC0eWVMfz8iZLPZV8xe8w5kpIB3AHSdAI0e1NEjEZFbUEgSKUCsNoNP153g49XHsBlQtWQRZgwJI7R84D87R5+Cpc/BmS32dtV29oUhg4Lzt2gRkQJKIUmkgLgcn8IL8/ey9Y9rAPQLq8C7fepRxPtvf4wNA3Z9Cb++CenXwbMIdH4Xmj6mo0ciIrmgkCRSAGw4doVR8/dy7Xoafl4W3u1dj/ubVPxnx9hzsGw4nFxvb1duZX8obfEq+VqviMidQCFJxI2lW2189OsxZm+wP2i2dll/Zg5pTPXSRbN2NAwI/x5WvQ6p8eDhCx3fgmZPg/kGD7EVEZGbUkgScVPnY5IYOTecPWdjARjavBL/6lEXH09L1o7xkfDTSDj+q71dsRn0mQUlq+dvwSIidxiFJBE39MuBS7yyMIL4lAz8fTz48P4GdKv/t9v1DQP2/wArXoaUWLB4Qft/QYvhYLZkO6+IiOScQpKIG0lJtzJhxWG+3XYGgEbBQcwYHEZwcb+sHRMvw/IX4chye7t8GPSZDaVr53PFIiJ3LoUkETdx8koiw+eEcygyHoCn21TlpS618LT87Zqig4vh59GQdA3MnnDvq9DqBbBks4ikiIjkmUKSiBtYHH6esYsPkJRmpXgRLz4a2JB2tUpn7ZQUbQ9HBxfZ22XqQd/ZULZ+/hcsIlIIKCSJuFBSWgZvLj3Iwt3nAWhetTjTHgijTIBP1o5HVsBPz8P1y2CyQOtR0OYV8PByQdUiIoWDQpKIixyOjGf4nD38ceU6ZhOM7FCDEe1rYDH/ZcHH5Fj45TWImGtvl6wFfWdBhSYuqVlEpDBRSBLJZ4ZhMGfnWcb9dIjUDBtlAryZ9kAYzauWyNrx+GpYNgISLgImaDkC2o0FT59s5xUREcdSSBLJR3HJ6by+aD8/748EoF2tUkwe0JASRb3/f6fUBFg1FvZ8a28Xr2Zf96jS3S6oWESk8FJIEskne8/FMnzOHs7HJONhNvFq19o83qoK5r+eXju5AZYOh7iz9vbdz0CHN8HLL/tJRUTEaRSSRJzMZjP4cvMpJv5yhAybQcVivswYHEZYpWL/v1PadfjtLfj9c3s7qDL0+RRCWrmmaBERUUgScabo62mMXrCXdUevANCjfjnG96tPoO9f1jQ6sw2WPAMxp+ztpo9Bp3fBu2g2M4qISH5RSBJxku0nr/H8vHCi4lPx8jDzVq+6DGlWCZPpf6fX0pNh7Xuw7RPAgICK0HsGVGvv0rpFRMROIUnEwaw2gxlrjzN9zXFsBlQrVYSZQxpTp1zA/+90fhcsHgbXjtvbYUOhy3jwCXRN0SIi8g8KSSIOFBWfwvPzwtl+MhqA/k0qMq53KH5e//ujlpEK6yfAlmlg2KBoWbhvOtTs4sKqRUQkOwpJIg6y/uhlRi2IIPp6Gn5eFt7vW4++YRX/f4eLe+3XHl0+ZG/XHwjdJoJfcZfUKyIiN6eQJHKb0q02Jq86ymcbTwJQt1wAM4eEUbXU/y68tqbDxsmwaTLYMsCvJPSaCnV6ua5oERG5JYUkkdtwLjqJEXPD2XsuFoBHWlRmTPc6+Hha7B2iDtqvPbq0z96u2xt6TIEiJV1TsIiI5JhCkkgerdwfySs/7iMhJYMAHw8+7N+ArvXK2V+0ZsDWabBuAtjSwbcYdJ8M9e4Hk+nmE4uIiFtQSBLJpZR0K+/9fIjvt9tXxQ6rFMT0B8IILv6/VbGvHIMlw+DCbnu7ZjfoNQ38y7ioYhERyQuFJJFcOHE5keFz9nDkUgIAw+6txujONfG0mMFmhe2zYO27kJEC3oHQ7QNoOFhHj0RECiCFJJEcWrj7PG8uPUBSmpUSRbyYMqgR99YsZX/x2h+w9Dk4u83ertYB7psBgRVcV7CIiNwWhSSRW7iemsEbSw+waM8FAFpWK8HUQY0oHeADNhv8/gWsfgvSk8CrKHR5Hxo/oqNHIiIFnEKSyE0cuhjP8Ll7OHnlOmYTvNixJs+2q47FbIKYM7BsOJzaaO8c0hp6fwLFKru2aBERcQiFJJFsGIbB99vP8O7Ph0nLsFE2wIfpg8NoVqU4GAbs/gZWjYW0RPD0g47vwF1PgNns6tJFRMRBFJJE/iYuOZ3XftzHygOXAOhQuzSTBjSkeBEviLsAP42EE6vtnSu1sB89KlHNhRWLiIgzKCSJ/MWeszGMmBPOhdhkPC0mXu1am8dbVcEEsHcurHwVUuPA4g0d3oTmz4DZ4uqyRUTECRSSRACbzeDzTSeZtOooGTaDSsX9mDkkjAYVgyAhCpa/AEdX2DtXaAJ9ZkOpmq4sWUREnEwhSQq9a4mpjFoQwYZjVwDo2aAc4/vVJ8DbA/YvhBUvQXIMmD2h3Rho+TxY9EdHROROp7/ppVDb+sdVXpi3l8sJqXh7mHn7vlAeuCsYU9I1+GEUHFpq71i2AfSdDWVCXVuwiIjkG4UkKZQyrDamrz3BjLXHMQyoXrooM4eEUbtsABz+CX56AZKugtkDWr8EbV4Ci6eryxYRkXykkCSFzqW4FEbOC2fnqWgABjatyNv3heKXEQ8/Pgn7F9g7lq4LfWZB+UauK1ZERFzGLULS4cOHiYqKok6dOpQpk7OHgOZkTE76nDx5kmPHjtGsWTOKFy+e5/cgBcPaI1GMXhBBTFI6RbwsjO9Xn96NKsCxVbBsJCReApMZ7nkB2r4GHt6uLllERFzEpSvfXb9+nS5dutCyZUtefvllQkJC+OCDD257TE76bN26la5du9K6dWu6devGvn37HP7+xH2kZdh4b/khHvtmFzFJ6dSrEMDyka3pXbsoLHkO5gy0B6QSNeDx36DjWwpIIiKFnEuPJL355pscO3aM48ePU7JkSVatWkXXrl1p1aoVrVq1yvOYnPQ5c+YMzz//PKGhoVSurMdI3MnOXktixNw9RJyPA+D/WoYwpnttvM9sgO9GQPx5wAQtnoP2/wJPX9cWLCIibsGlR5K+++47Hn/8cUqWLAlAly5dCAsL49tvv72tMTnpM3jwYLp164ZZj5G4oy3fd5Ee0zcRcT6OQF9P/v1QE97uUhnvX16C//S1B6RiVeDRFfYH0yogiYjI/7jsSNL58+e5evUqYWFhWbaHhYURERGR5zF5mTenUlNTSU1NzWzHx8ff1nziPCnpVsYtP8ScHWcBaFK5GNMHh1EhdjfMehZiz9g73vUkdHoHvIq4sFoREXFHLgtJsbGxAP+4WLpEiRLExMTkeUxe5s2pCRMm8M4779zWHOJ8Jy4nMHxOOEcuJWAywbNtq/HCvRXxXPcO7Jhl7xQYDL1nQtW2Lq1VRETcl8tCkpeXFwDJyclZticlJWW+lpcxeZk3p8aMGcOoUaMy2/Hx8QQHB9/WnOI4hmHww+7zvLX0IMnpVkoW9eLjQY1o7XMK/t0Gov+wd2z8MHR+H3wCXFuwiIi4NZeFpODgYCwWC+fOncuy/fz584SEhOR5TF7mzSlvb2+8vXXHkztKTM3gX4v3s2TvRQBaVS/JlPtrUXrXFNg6Awwb+JeD+2ZAjU4urlZERAoCl1217OvrS5s2bViyZEnmtri4OFavXk3Xrl0ztx08eJAtW7bkeExO55U7x4ELcfSasZkley9iMZt4uUstvuvqSek5XWDLNHtAajgYnt2mgCQiIjlmMgzDcNXOt2/fTtu2bXnyySdp0aIFs2bN4urVq+zevRs/Pz8AnnjiCbZv386BAwdyPCYnfS5cuMD+/fu5evUqDz30EBMnTqRBgwZUr16d6tWr56j++Ph4AgMDiYuLIyBAp27ym2EYfLv1NONXHCHNaqN8oA/TB4bS9MwXsGkKGFYoUhp6TYXaPVxdroiIuImcfn+79P735s2bs23bNlJTU5k/fz733nsvW7ZsyQwyAPXq1cuyZlJOxuSkz6FDh5g6dSrff/89Xbp0Ye3atUydOpXt27fnz5uX2xKXlM7T/9nN2z8dIs1qo2OdMvwyuBhNf+0PGyfZA1K9++G5HQpIIiKSJy49klTQ6UiSa+w+E83IuXu5EJuMp8XE611q8H/GYkwbPgRbOviVgB4fQWhfV5cqIiJuKKff327x7DaRnLDZDGZv/IOPfj2G1WYQUsKPf3ctSs1tT8LFcHun2j2h58dQtLRrixURkQJPIUkKhCsJqYxasJdNx68C0LtBGSZW2IjPkg/Amgo+gdB9MtQfACaTi6sVEZE7gUKSuL0tJ67ywvy9XElIxcfTzEfti9D9jzGY1u20d6jRGXpNh4Byri1URETuKApJ4rYyrDamrj7OJ+tPYBhQq7Qf/6m/l9JbJkJGMnj5Q9cJEDZUR49ERMThFJLELUXGJTNybji/n7Y/SubZhhZGJ0/C8r81s6jaFu6bCUFa8VxERJxDIUnczupDUby0MILYpHSKelv4b9ghGh6cDOnXwbMIdB4HTR/X0SMREXEqhSRxG2kZNj5YeYSvtpwCoF3ZND71/wrfvRvtHSrfA70/geJVXFiliIgUFgpJ4hbOXLvO8Dnh7L8QBxhMr3WQXpdmYIpNAA8f6Pg2NHsazC5d/1RERAoRhSRxuWURF3l90X4SUzOo4ZvAnLJzKXVmvf3FindBn9lQMmePihEREXEUhSRxmeQ0K+OWH2TuznOAwYtl9jIi5XPMkbFg8YJ2Y6HlCDBbXF2qiIgUQgpJ4hLHohIYPmcPx6ISKWmKY265+dSIXm9/sVwj6DsbStdxZYkiIlLIKSRJvjIMgwW7zvHWsoOkpNsYVGQP73l8hWd0NJg94N5XodWLYPF0dakiIlLIKSRJvklISWfs4gMsi7hIEAl8XXwuLZLWgxUoUw/6zIJyDVxdpoiICKCQJPlk//k4hs/dw5lrSXSy7GFqkW8oknQVTBZoPQravAIeXq4uU0REJJNCkjiVYRh8veU0E1YexteayKd+c+huWwdpQMla0HcWVGji6jJFRET+QSFJnCY2KY2XftjH6sNRtDFHMK3IlxSzXgVM9rvW2o0FTx9XlykiIpIthSRxit9PR/P83HDi4mKY6PVfBpnX2q89Kl7Nfu1RpbtdXaKIiMhNKSSJQ9lsBrM2/MGU347RjAN87Ps5ZY3L9hfvHgYd3gIvP9cWKSIikgMKSeIwlxNSGDU/gt0nzvOGxzz+z+NXMICgytDnUwhp5eoSRUREckwhSRxi0/ErvDh/LyHX9/GL97+pbLpkf6HpY9DpXfAu6toCRUREckkhSW5LhtXGlN+O8dWGw4y2LOBx75WYMSCgAvSeCdXau7pEERGRPFFIkjy7EJvMyLnhWM/+znLP2VQ3X7S/0GgodB0PPoGuLVBEROQ2KCRJnqw+FMVrC3bxaMY8hnn9hMVkQNEy0Gs61Orq6vJERERum0KS5IrNZjB19TFWr1vNfzxnUcfjnP2F+gOg24fgV9y1BYqIiDiIQpLkWFxSOi/MD6fkiR9Y7PU13qZ0DL+SmHp+DHXvc3V5IiIiDqWQJDly5FI8I77bxmPxsxjsuc6+sUYXTH0+hSIlXVuciIiIEygkyS0ti7jItIWr+dg0hQYepzAwYWo/FlqNBrPZ1eWJiIg4hUKS3FCG1cbEX45wbMsSFnp+QjFTIjbf4pj7f6lb+0VE5I6nkCTZupaYyoj/7uaus1/wtecizCYDo3xjzAO/g6BgV5cnIiLidApJ8g/7zsfy8nfreS15Cu08I+wbmz6GqesH4OHt2uJERETyiUKSZLFg1znmLPmJL8xTCLZcwWbxxtxrGjQa7OrSRERE8pVCkgCQlmFj3PKDpP3+LfM9vsHblI4tKATzA99D2fquLk9ERCTfKSQJUfEpPP/9dvpc/JgHPNcDYNTogrnfZ+BbzLXFiYiIuIhCUiG363Q0477/hffTJlLf4zSGyYyp3VhMrUbp9n4RESnUFJIKKcMw+H77GdYtn8N3HjMJMl/H6lMcy4CvoFo7V5cnIiLicgpJhVBKupU3Fu+jwr7pfOGxGLPJwFouDMug/+j2fhERkf9RSCpkzsck8fJ3G3j66gTaethv7zeaPIalm27vFxER+SuFpEJk64mrzJzzIx9mTCLYcgWrxRtLr2mYdHu/iIjIPygkFQKGYfD5ppOcXDWLrz2+wducTkZgCB6DdXu/iIjIjSgk3eGS0jIYu+B3mh/5gA/+d3u/tUZXPPp9Br5BLq1NRETEnSkk3cFOX73Om9/+zMtx71Pf4zQ2zJjaj8Wi2/tFRERuSSHpDrXuyGV+mPcV043pBJmvk+5dHM+Bur1fREQkpxSS7jA2m8HMtcewrf+AmRb77f3pZcPwHPw9BFZ0dXkiIiIFhkLSHSQ+JZ035myk76l3Mm/vtzZ5DE/d3i8iIpJrCkl3iONRCUz+Zj5vJE2gouUqGWYfPHpPw9LwAVeXJiIiUiApJN0BVu6PZNsPU5hu+hpvUzqpAZXxHjIHytZzdWkiIiIFlkJSAWa1GUz9JYKKW99inMd6ANKqdcW7v27vFxERuV0KSQVUzPU03v1+BY9deIt6/7u932g3Fq/Wur1fRETEERSSCqADF+L45tt/82bqxwSZr5PqVQzvQV/r9n4REREHUkgqYBbvOcOFJe/woWkRZpNBcukwfB/U7f0iIiKOppBUQKRbbUxZup3m4a/S17IPgNSwx/Dtodv7RUREnEEhqQC4kpDKR9/MY/jVcVS0XCXd7I3lvml4Nxrs6tJERETuWC6/wvfTTz+lVq1aBAUF0bp1a3bu3OmQMY7q42onLifw+dS3eOfqKCqarnK9aGU8n1qLWQFJRETEqVwakr777jtGjRrF+++/z8GDB2ncuDGdOnXiwoULtzXGUX1c7ciFq0TMepTXrbPwNmVwvUoXijy3UesfiYiI5AOTYRiGq3YeGhpK27Zt+eSTTwCw2WxUrFiRRx99lPfffz/PYxzV51bi4+MJDAwkLi6OgICAvH8Q2Th64hjJ3w+lEUexYSK19Rh8272s2/tFRERuU06/v132jRsTE8OhQ4do1+7/37ZuNptp164dW7ZsyfMYR/VxpflLlhD4n8404iiJpiIk95+Lb4dXFZBERETykcu+dSMjIwEoXbp0lu2lS5fm0qVLeR7jqD7ZSU1NJT4+PsuPoxnXr9Fn7xOUNcVwzhIMT66lSL1uDt+PiIiI3JzLD02Y/3Z0xGw2c6szgDkZ46g+fzVhwgQCAwMzf4KDg29aZ14kewayr2RP9gfcS9DIjRQtX9vh+xAREZFbc9kSAGXKlAHgypUrWbZfvnw587W8jHFUn+yMGTOGUaNGZbbj4+MdHpT8vDy469kvwWxx6LwiIiKSOy47klSiRAlq1KjBhg0bMrcZhsGGDRto0aJFnsc4qk92vL29CQgIyPLjFApIIiIiLufS020vvvgiX375JWvWrOH69eu8/fbbXL16laeffjqzzzPPPEOTJk1yNcZRfURERKTwcumK28888wwxMTEMHjyYa9euUadOHZYvX07VqlUz+6Snp5OampqrMY7qIyIiIoWXS9dJ+iubzfaPC6kBMjIysNlseHl55XiMM/pkx5nrJImIiIhz5PT7222e3XajkOLhceMScxJsHNVHREREChelAxEREZFsKCSJiIiIZEMhSURERCQbCkkiIiIi2VBIEhEREcmGQpKIiIhINhSSRERERLKhkCQiIiKSDbdZTLIg+nOx8vj4eBdXIiIiIjn15/f2rR46opB0GxISEgAIDg52cSUiIiKSWwkJCQQGBt7wdbd5dltBZLPZuHjxIv7+/phMJofNGx8fT3BwMOfOndMz4bKhz+fm9PncmD6bm9Pnc3P6fG6uIH0+hmGQkJBA+fLlb/poMh1Jug1ms5mKFSs6bf6AgAC3/0VzJX0+N6fP58b02dycPp+b0+dzcwXl87nZEaQ/6cJtERERkWwoJImIiIhkQyHJDXl7e/PWW2/h7e3t6lLckj6fm9Pnc2P6bG5On8/N6fO5uTvx89GF2yIiIiLZ0JEkERERkWwoJImIiIhkQyFJREREJBsKSW7o8OHDhIeHk56e7upS8iwqKorNmzcTGxt7wz7nz59n165dBaqPI6SmprJv3z7Onj170yXxjx49yp49e0hLSyswfRwhOTmZvXv3cvr06Rt+Punp6ezdu5fDhw8XmD6OtmPHDn7//fdsX4uPj2fXrl2cPXv2huPdrc/tOnv2LJs3b87ys2PHjmz7Xrp0id9//51r167dcD536+Moqamp7N27l4sXL96wz4kTJ9i9ezfJyckFpo/TGOI2Tp8+bTRo0MAoWbKkERISYpQpU8ZYt26dq8vKlfDwcGPgwIFG6dKlDcBYuXLlP/qkpqYagwYNMnx9fY06deoYPj4+xqRJk9y6jyPExMQYzz77rBEUFGQ0aNDAKFWqlNGoUSNj//79WfqdP3/eCAsLM4oXL25UqVLFKFmypLFq1Sq37uMICQkJxvDhw43ixYsbjRs3NkqVKmXUqVPH2L17d5Z+GzZsMMqWLWtUrlzZKFmypFGvXj3j5MmTbt3H0b788kvDbDYbFSpU+Mdrn3zyieHr62vUrl3b8PPzM3r37m0kJSW5dR9HeOutt4yAgADjnnvuyfzp0aNHlj4ZGRnG448/bvj4+Bh169Y1vL29jTfffNOt+zjSjBkzjICAAKNOnTpGjRo1jCFDhhgpKSmZr1+5csVo2bKlERgYaFSvXt0IDAw0Fi1alGUOd+vjbApJbqRVq1ZGhw4djLS0NMMwDGP06NFGiRIljLi4OBdXlnPff/+9MXfuXOPChQs3DElvv/22UbZsWePs2bOGYRjGihUrDJPJZGzYsMFt+zjCkSNHjE8++STzL6WUlBSjX79+Ro0aNbL069ixo9G6devMfmPHjjUCAwONa9euuW0fRzh9+rTx9ddfG+np6YZhGEZaWprRr18/IzQ0NLNPQkKCUapUKWPUqFGGYRhGenq60bFjR6NFixZu28fRDh8+bFSoUMF46qmn/hGSfv/9d8NkMmV+kURGRhoVK1Y0Xn75Zbft4yhvvfWWcc8999y0z9SpU42goCDj6NGjhmEYxqZNmwwPDw9j6dKlbtvHUb755hvDy8vL+PXXXzO3zZs3z7hy5Upmu3///kbjxo2NxMREwzAMY9KkSYavr69x/vx5t+3jbApJbuLYsWMGYKxevTpz29WrVw0PDw/jP//5jwsry5srV67cMCRVqlTJeO2117Jsa9q0qfHII4+4bR9nWb58uQEYUVFRhmEYxtmzZw3AWL58eWafuLg4w9vb2/j888/dso8zTZkyxQgKCspsz5kzx7BYLMbVq1czt61evdoAjMOHD7tlH0dKTk42GjRoYMybN8949913/xGSnn32WaNevXpZtr399ttGyZIlDZvN5pZ9HOWtt94ymjVrZoSHhxtHjx7NDNt/1aBBA2PYsGFZtnXs2NHo3bu32/ZxBJvNZlSqVMl49tlnb9gnOjrasFgsxvfff5+5LTU11QgMDMw8su5uffKDrklyE+Hh4QA0adIkc1uJEiWoWrVq5mt3gujoaM6ePZvlfQI0a9Ys8326Wx9n+v333wkMDKRkyZJA9r8HAQEB1KpVK/M1d+vjaAcPHmTjxo18+eWXTJkyhXfffTfztfDwcEJCQihRokTmtmbNmmWp1d36ONLo0aNp2LAhgwYNyvb18PDwbH+Xr169yvnz592yjyPt2rWLBx98kHbt2lGuXDnmzJmT+Vp6ejoHDx686Z91d+vjKCdOnODs2bP06tWLa9eusXv37n9c/7R//36sVmuWery8vGjYsGFmPe7WJz8oJLmJ6OhoLBbLPx64V6JECaKjo11UleP9+V7++qXyZ/vP19ytj7Ps2bOHDz/8kLFjx2Y+hdrd3rsrPp+vv/6aV155hVdeeYUaNWrQrVu3zNeio6P/UYu/vz+enp5ZananPo6yePFiVq5cycyZM2/YJ7t6/mzfrGZX9nGUu+++m1OnTnHw4EHOnz/Pq6++ysMPP5x5cXtcXBxWq/Wmv8vu1sdR/rxIe8WKFYSGhvLEE08QHBzM0KFDM2/EcLe/V1z5d/NfKSS5CU9PT6xW6z/uaEtOTsbLy8tFVTmep6cnACkpKVm2//V9ulsfZzh69Cjdu3dn0KBBvPTSS5nb3e29u+LzmTx5Mtu3b+fixYsEBwfToUMHUlNTM+v5ey0ZGRlkZGRkqdmd+jhCYmIijz/+OMOGDWPfvn1s3ryZs2fPkpaWxubNm7l69eoN6/nzjqCb1ezKPo7SrVs3KlWqBIDJZOKll16iSpUqLFy4MLMWcJ8/N/n5Z+vPfe3evZs//viD8PBwDhw4wIoVK5g0aZJDay6In8/NKCS5icqVKwP847bMixcvZv7BvxOUL18eT09PLly4kGX7hQsXMt+nu/VxtGPHjtG+fXu6dOnCl19+iclkynztz9+Dm9Xjbn2cxdvbm5EjR3LmzBkOHz6cWc/Fixez3Gb/Z/uvNbtTH0dIS0ujbt26LFu2jNdee43XXnuNVatWERcXx2uvvUZERERmPdn9vzKZTAQHB7tlH2cqXbp05v4DAwMJCgq66e+yu/VxlJCQEACGDh1KkSJFAKhatSqdOnVi06ZNgPv9veLKv3uyyLern+SmEhMTjSJFihjTpk3L3LZ161YDMHbs2OHCyvLmZhdud+zY0ejVq1dmOzk52ShevLjx/vvvu20fRzl27JhRvnx546GHHjKsVus/Xk9JSTECAwONiRMnZm7bs2ePAWTebedufRzlzztY/mrevHkGkHnn4a5duwzA2LJlS2af6dOnG35+fkZCQoJb9nGW7C7cnjp1quHv75/lsxw4cGCWu+3crY+j/P3359KlS0bRokWNCRMmZG7r37+/0aZNm8x2enq6UalSpSx327lbH0epV6+eMXbs2CzbWrZsaQwdOtQwDMOwWq1G+fLljTFjxmS+/scffxhA5t127tYnPygkuZGJEycaRYoUMWbNmmXMmzfPqFatmtG3b19Xl5UrV65cMTZt2pR519bkyZONTZs2GadPn87ss23bNsPLy8sYPXq0sXTpUqNbt25GpUqVjJiYGLft4wjnz583KlasaISFhRkbNmwwNm3alPnz17/gp02bZvj6+hozZswwFixYYNSqVcvo3r17lrncrY8jTJs2zXjggQeM77//3li1apUxadIko0SJEsbjjz+epd+AAQOMqlWrGnPnzjVmz55tFC1a1Bg/frxb93GG7EJSYmKiUaNGDaNDhw7GkiVLjDFjxhgeHh7G2rVr3baPozRp0sQYP368sWLFCuPbb781QkNDjZo1a2b5c7xv3z7Dz8/PGDZsmLFs2TLj/vvvN0qXLm1ERka6bR9HWbFiheHv729MmTLFWLVqlTFixAjDy8vL2LVrV2afb7/91vD09DQmT55s/Pjjj0ajRo2MVq1aZfkHnbv1cTaTYeTT8rCSI//973+ZP38+qamptG/fnhdeeAFvb29Xl5Vja9as4a233vrH9qFDhzJs2LDM9o4dO5gxYwaRkZGEhoby6quvUqFChSxj3K3P7dqxYwejR4/O9rVvvvmG6tWrZ7bnz5/P3LlzSUpK4t5772XUqFH4+vpmGeNufRzh559/ZsGCBURGRlKxYkX69etHz549s/RJS0tj2rRprF69Gm9vbwYMGMBDDz3k1n2c4bvvvmPJkiUsWrQoy/bLly/zwQcfEBERQenSpXn22Wdp3bq1W/dxhOjoaGbOnMmOHTsoUqQId999N88+++w/fk8jIiL4+OOPOXv2LLVq1eKVV16hSpUqbt3HUTZu3Mjs2bO5cuUK1atXZ8SIEdStWzdLn2XLlvHtt98SHx9PixYtePnll/H393frPs6kkCQiIiKSDV24LSIiIpINhSQRERGRbCgkiYiIiGRDIUlEREQkGwpJIiIiItlQSBIRERHJhkKSiIiISDYUkkTkjrZ27Vr279/vlLnj4+NZtWoV8+bNIzY21in7ANi0aRPh4eFOm19EsqeQJCK35eTJkyxYsMDVZQCwYcMG9u7dm2XbuHHjmD9/vsP3denSJWrWrMn48eNZsmQJcXFxuRqfXa03MnHiRL799ts8VCkit8PD1QWISMG2du1ahg0bxsCBA11dChMmTKBevXo0atTI6ftaunQpAQEBbNiwIU/jc1NrmzZtKFu2bJ72IyJ5p5AkIk5nGAa7du3i4sWLVK1alfr162d5fe3atZQqVYpKlSoRHh6OzWajefPm+Pn5ZekXHx/Ppk2bCAgIICwsjP379+Pp6UnTpk3Zvn07ly5dwtPTk3nz5gFkee5bXFzcTef+u7S0NLZu3UpsbCz169enWrVqma9t3ryZtWvXYhgG8+bNIyAggO7du2c7z9GjRzl27BgVKlSgUaNGmM3mG9a6c+dOSpUqRfny5dmxYwd+fn60bduWFi1aULRoUYd+XiJyawpJIuJUkZGR3HfffcTFxVGnTh327t1L7dq1Wbx4ceaX+rhx47BarURGRlK7dm2OHTuG1Wpl+/btlCpVCoDw8HA6d+5M6dKlKV++PCdPnqRo0aK0aNGCpk2bsnv3bqKiokhJSWHJkiUAtGvXDrCf2po3b94N5/67o0eP0rVrVzw9PalSpQpbtmzhySef5OOPPwbsDys+fPgwMTExLFmyhAoVKmQbkp5++mkWLlzIPffcQ1RUFJ6enixduvSGtY4bN46MjAwuXLhAaGgoLVq0oG3btkycOJHq1asTFhbmsM9LRHLAEBG5DZ9//rlhsVhu+Hrnzp2NJ5980rBarYZhGEZKSopx9913G2PHjs3sc++99xply5Y1Ll26ZBiGYaSmpho1a9Y0xo0bl9mnZcuWxoABAzLn+e233wzAePrppzP7dOnSxRg9enSW/edk7r9r27at0bNnTyM9Pd0wDMPYsWOHYbFYjF9++SWzz7vvvmvcfffdN5zj9OnTBmAcO3Ysc9vOnTuNc+fO3bTWoKCgzD5/6tGjh/H888/n6j3l5PMSkZvTkSQRcZqLFy/y66+/8uGHH7Jo0SIMw8AwDKpWrcq6deuy9O3bty9lypQBwMvLi5YtW3L06FHAfjRq69atbN++HbPZfr9Jx44dc3zt0c3m/ruoqCjWr1/Pxo0b8fCw/xXZrFkzOnXqxPz58+nSpUuO9unl5YXZbGbfvn3UqFEDgLvuuitHtVasWPG23tPtfl4iYqeQJCJOc/r0aQC2bNnC7t27s7z298BQvHjxLG1vb28SEhIAOHfuHAAhISFZ+vy9fSM3m/vvzpw5A0DVqlWzbK9WrRqHDx/O0f4AypUrx+zZsxkxYgTPP/887dq145FHHqFjx463HJcTzvy8RMROIUlEnCYgIACA119/nWbNmuV5nj8DQWxsbObRE4CYmJgsbUcoWbIkANHR0VSoUCFze3R0dOZrOfXkk0/yxBNPcODAAZYtW0aPHj2YO3cu/fr1u+EYk8mUt8L/Ij8/L5E7mdZJEhGnqVu3LsHBwcyePfsfr124cCHH84SEhFC+fHmWLl2auS0qKoodO3Zk6Ve0aFFSUlLyXjBQuXJlgoODWbRoUea2hIQEVq1aRatWrXI8T0xMDElJSZhMJurXr8/YsWNp3rw527dvd1itN5LTz0tEbk5HkkTkthn/uxX+rzw9Pbn//vv56quv6N27NzExMXTr1o2YmBiWL19O7969eemll3I0v4eHB++99x7Dhg0jNjaWihUrMnv2bPz8/LIceWnatCmffvopYWFhFClSJMsSADllsViYMmUKQ4YMISEhgerVq/PFF19QoUIFnn766RzPc+7cOfr370///v2pWbMmhw8fZufOnYwfP95htd5ITj8vEbk5hSQRuS3VqlVjwIABmbey/8nHx4f777+fjh07cvDgQb777ju2bNlChQoV+PDDD2nRokVm3/bt21O7du0s4++6664s1w09+uijlClThkWLFpGSksLUqVOZMGEC/v7+mX1efPFF/Pz82LJlC0lJSbRr1y5Hc/9d//79qVixInPnzmXbtm0MGTKEJ598Ei8vr8w+oaGhpKam3nCOBg0asH79er799ls2btxI2bJl+f3336lXr16uaoV/LibpqM9LRG7OZBiG4eoiRERuJSYmhqCgoMwjIdeuXaNatWp89tlnDBo0yMXVuR99XiK3TyFJRAqEjRs38vbbb9OvXz8yMjL47LPPKFq0KJs3b8bb29vV5bkdfV4it08hSUQKjE2bNrFkyRKSkpJo1KgRjz32GJ6enq4uy23p8xK5PQpJIiIiItnQEgAiIiIi2VBIEhEREcmGQpKIiIhINhSSRERERLKhkCQiIiKSDYUkERERkWwoJImIiIhkQyFJREREJBsKSSIiIiLZ+H+AkrF6QzcbQgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Length of string\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 6: Semantic Segmentations As QuPath Json\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely.affinity import translate\n", + "from shapely.geometry.base import BaseGeometry\n", + "\n", + "\n", + "def make_valid_poly(\n", + " poly: BaseGeometry,\n", + " origin: tuple[float, float] | None = None,\n", + ") -> BaseGeometry:\n", + " \"\"\"Helper function to make a valid polygon.\n", + "\n", + " Args:\n", + " poly (Polygon):\n", + " The polygon to make valid.\n", + " origin (Tuple[float, float]):\n", + " The x and y coordinates to use as the origin for the annotation.\n", + "\n", + " Returns:\n", + " geometry:\n", + " A valid geometry.\n", + "\n", + " \"\"\"\n", + " if origin != (0, 0) and origin is not None:\n", + " # transform coords to be relative to given pt.\n", + " poly = translate(poly, -origin[0], -origin[1])\n", + " if poly.is_valid:\n", + " return poly\n", + " logger.warning(\"Invalid geometry found, fix using buffer().\", stacklevel=3)\n", + " return poly.buffer(0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def save_qupath_json(save_path: Path, qupath_json: dict) -> Path:\n", + " \"\"\"Saves QuPath JSON to disk.\"\"\"\n", + " save_path = save_path.with_suffix(\".json\")\n", + " with Path.open(save_path, \"w\") as f:\n", + " json.dump(qupath_json, f, indent=2)\n", + " return save_path" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def poly_geo_func(coords: list) -> list:\n", + " \"\"\"Used solely for function semantic_segmentation_as_qupath_json.\"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": coords,\n", + " }\n", + " ),\n", + " (0, 0),\n", + " )\n", + " return mapping(geom)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import dask.array as da\n", + "\n", + "\n", + "def py_semantic_segmentations_as_qupath_json(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> dict | Path:\n", + " \"\"\"Helper function to save semantic segmentation as QuPath json.\"\"\"\n", + " features: list = []\n", + "\n", + " # color map for classes\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " tqdm_loop = tqdm(\n", + " layer_list,\n", + " leave=False,\n", + " desc=\"Converting outputs to QuPath JSON.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for type_class in tqdm_loop:\n", + " class_id = int(type_class)\n", + " class_label = class_dict[class_id]\n", + "\n", + " # binary mask for this class\n", + " layer = da.where(preds == type_class, 1, 0).astype(\"uint8\").compute()\n", + "\n", + " contours, _ = cv2.findContours(layer, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n", + "\n", + " contours = cast(\"list[np.ndarray]\", contours)\n", + "\n", + " # Convert contours to polygons\n", + " for cnt in contours:\n", + " if cnt.shape[0] < 3: # noqa: PLR2004\n", + " continue\n", + "\n", + " # scale coordinates\n", + " cnt_scaled: np.ndarray = cnt.squeeze(1).astype(float)\n", + "\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": scale_factor * np.array([cnt_scaled]),\n", + " }\n", + " ),\n", + " (0, 0),\n", + " )\n", + " poly_geo = mapping(geom)\n", + "\n", + " feature = {\n", + " \"type\": \"Feature\",\n", + " \"geometry\": poly_geo,\n", + " \"id\": f\"class_{class_id}_{len(features)}\",\n", + " \"properties\": {\n", + " \"classification\": {\n", + " \"name\": class_label,\n", + " \"color\": class_colours[class_id],\n", + " }\n", + " },\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_label,\n", + " \"class_value\": class_id,\n", + " }\n", + "\n", + " features.append(feature)\n", + "\n", + " qupath_json = {\"type\": \"FeatureCollection\", \"features\": features}\n", + "\n", + " # if a save directory is provided, then dump JSON into a file\n", + " if save_path:\n", + " return save_qupath_json(save_path=save_path, qupath_json=qupath_json)\n", + "\n", + " return qupath_json" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rust_semantic_segmentations_as_qupath_json(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + ") -> dict | Path:\n", + " \"\"\"Helper function to save semantic segmentation as QuPath json.\"\"\"\n", + " num_classes = len(class_dict)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " features = rmisc.semantic_segmentations_as_qupath_json(\n", + " layer_list, preds, scale_factor, class_dict, class_colours, cv2, poly_geo_func\n", + " )\n", + "\n", + " qupath_json = {\"type\": \"FeatureCollection\", \"features\": features}\n", + "\n", + " # if a save directory is provided, then dump JSON into a file\n", + " if save_path:\n", + " return save_qupath_json(save_path=save_path, qupath_json=qupath_json)\n", + "\n", + " return qupath_json" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d365f01361e34553a29c8c1d741d0fc1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Converting outputs to QuPath JSON.: 0%| | 0/9 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "print(timings)\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "interpreter": { + "hash": "a3ed8fb525a8bde66cc7655a5df08d8d0f8699a69b9eb5ccab28dc0a7837eec6" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/benchmarks/implementing_misc_in_rust.ipynb b/benchmarks/implementing_misc_in_rust.ipynb deleted file mode 100644 index e677e41ed..000000000 --- a/benchmarks/implementing_misc_in_rust.ipynb +++ /dev/null @@ -1,744 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "aqPkpRk-pT5q" - }, - "source": [ - "# Benchmarking Misc in Rust\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b6S8vzFipT5w" - }, - "source": [ - "# Part 1: Contrast Enhancer\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from skimage import exposure\n", - "\n", - "from tiatoolbox import rust_misc\n", - "\n", - "\n", - "def rust_contrast_enhancer(\n", - " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", - ") -> np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " # check if image is not uint8\n", - " dimension_for_rust = 3\n", - "\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " if img.ndim == dimension_for_rust:\n", - " return rust_misc.contrast_enhancer(img, low_p, high_p)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def py_contrast_enhancer(\n", - " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", - ") -> np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "DZBiw_EepT5x" - }, - "outputs": [], - "source": [ - "import time\n", - "\n", - "sizeofarray = []\n", - "timings = []\n", - "i = 1\n", - "maxarraysize = 10000\n", - "while i <= maxarraysize:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for _j in range(10):\n", - " rng = np.random.default_rng()\n", - " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", - " start_time = time.time()\n", - " py_contrast_enhancer(temp, 2, 96)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_contrast_enhancer(temp, 2, 96)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " sizeofarray.append(i)\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGzCAYAAADDgXghAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAc4BJREFUeJzt3Xd0VNXexvFveiMJLUCAhB4g9A6CgmJBpSO9qRS9YsV20XtR8Cp2bHktIL2LVLEhIiI19CaEGhJCgADpPXPePwaikUwKJDOT5PmslWXmzD5nfmEI87jPLg6GYRiIiIiIlEGOti5ARERExFYUhERERKTMUhASERGRMktBSERERMosBSEREREpsxSEREREpMxSEBIREZEyy9nWBdg7k8lEVFQU3t7eODg42LocERERKQDDMEhISKB69eo4Olru91EQykdUVBQBAQG2LkNERERuQkREBDVr1rT4vIJQPry9vQHzH6SPj4+NqxEREZGCiI+PJyAgIPtz3BIFIQtCQkIICQkhKysLAB8fHwUhERGREia/YS0O2mssb/Hx8fj6+hIXF6cgJCIiUkIU9PNbs8ZERESkzFIQsiAkJITg4GDatWtn61JERESkmOjWWD4K0rVmMplIT0+3cmUC4OLigpOTk63LEBERO1PQW2MaLH2L0tPTOX36NCaTydallFnly5enWrVqWudJREQKTUHoFhiGwfnz53FyciIgICDPBZuk6BmGQXJyMhcvXgTA39/fxhWJiEhJoyB0CzIzM0lOTqZ69ep4enraupwyycPDA4CLFy9SpUoV3SYTEZFCUReGBQUZLH19jSFXV1drlSW5uB5CMzIybFyJiIiUNApCFkyYMIEjR44QGhqab1uNTbEt/fmLiMjNUhCSIpGamqqZcyIiUuIoCJVBaWlpJCYmkpiYSGpqaqHPzy309OzZk8mTJxdViSIiIlahIFQGPfbYY/j6+lKtWjXKly9PlSpVmDBhAgkJCQU6/6GHHuKll14q5ipFRESKn4JQGXX77bdn9wh99913LF26lBdeeIH09HRSUlJuaJ+RkUFycjJpaWlkZWWRkZGR3av0zzU5DcO44Vhu18vN33ubCnIdEREpuTKzTKSkZ9m0BgUhC8rSFhvt27dn5MiRfP/99yxdupSaNWuSlpaWo83gwYN5+OGHeeaZZ1i/fj0zZsygWrVqVKtWjePHjwNw/vx5+vXrR4UKFShXrhyPPvpojsCTkpLCv/71L7y9vXF3d6dx48Z89913OV6nZ8+ejBs3Ls/riIhIyZdlMpi4bD+PzNlJUlqmzepQELKgMLPGrjMMg+T0TJt83WrPSUZGBs7Ozjz00EOYTCZWrVqV/dylS5f47rvvGDNmDF988QU9evTgiSeeyO4RCgoKAmDRokUMHz6cmJgYQkNDWbVqFbNmzcq+zr///W9+/vlntm3bRnJyMmPGjKF///7ZQeq6/K4jIiIlW5bJ4MVv9rNmfxS7zlzlQGSczWrRgopFKCUji+DJP9nktY9MvQ9P14K/nVlZWSQmJpKZmcmWLVuYN28eY8eOxcPDg2HDhjFr1iwGDx4MwPz586lWrRr33HNPntfs168fDz30EADBwcE8+OCDbNu2jccee4yUlBQ+//xz5s6dS9OmTQF44YUXWLp0KZ988gmffvppga4jIiIlm8lk8MqKg6zYew4nRwc+HdqKTvUq2aweBaEyauvWrVSrVg0XFxdq1qzJc889x6RJkwAYN24cbdq0ISIigoCAAGbPns3o0aPz3UKkTp06OR77+voSGRkJwKlTp8jIyKBt27Y52rRr146jR48W+DoiIlJyGYbBf1cfYumuCBwd4KPBLbm/mW23R1IQKkIeLk4cmXqfzV67MG6//XZ+++23XJ9r2bIlrVq1Ys6cOdx3330cPnyY1atX53vNvBY2vB6irq/GfV1WVtYN22JogUQRkdLHMAymrD3Cwh1ncXCADwa1oFeL6rYuS0GoKDk4OBTq9pQ9Gzt2LO+99x6RkZF07dqVunXrZj/n6up6Q6DJT926dfHw8GDbtm00atQo+/i2bdu49957i6xuERGxP4Zh8Oa6P5mz9QwA7w5oTr9WNW1b1DUaLC25GjZsGBcuXODrr79mzJgxOZ6rU6cOu3btIjo6Otfp87lxc3PjhRde4D//+Q+//vorkZGRvPzyy5w8eZJnn322mH4KERGxNcMweOfHY8z84zQAb/VrxsC2ATau6i+lo/uiGISEhBASElLono+SwN3dPXvXdkt8fHwYMGAAq1evZsCAATmee/bZZzl8+DAtWrQgKSmJPXv24OHhgZubW452bm5uOV7ntddew9HRkfHjx3P16lWaN2/OL7/8Qs2af/1fQUGuIyIiJcf09WF8sekkAFP7NGFYh0AbV5STg6EV6/IUHx+Pr68vcXFx+Pj45HguNTWV06dPU6dOHdzd3W1UYfG58847adSoEZ9//rmtS8lTaX8fRERKqk82HOfD9WEA/LdnMGO61MnnjKKT1+f336lHSG6QlJTEhg0b2Lx5s92HIBERsU+f/3YyOwRNur+RVUNQYSgIyQ1at25NYmIiH3/8cY6BzSIiIgUxc/Mp3vnRvDTKi/c15LGu9XJvaBjmr3yWZylOCkJyg2PHjtm6BBERKaHmbj3D/9b9CcAz3Rsw4c76lhv/+j+Ii4Q+IeBkm0iiWWMiIiJSJBbuCOe1NYcBmHBnPZ69u4Hlxpvehc3vw4ElcGqjlSq8kYKQiIiI3LJloRG8uvIQAOPvqMsL9za0vEDuHx/BxjfN39/7P2iQ9xZOxUlBSERERG7Jij2RvLziAACPdK7NpPsbWQ5B2/4PfnnN/P1d/4XbnrJSlblTEBIREZGbtnrfOV74Zj+GASM6BjK5Z7DlELRzBvxk3teSrv+GO16wXqEWKAiJiIjITfn+4HkmLtuPyYAh7QKY2rup5RC0ey58fy34dHkOuv3beoXmQUHIgpCQEIKDg2nXrp2tSxEREbE7Px+O5unFe8kyGTzUpiZv9WuGo6OFELRvMax9xvx9xwnQ/TWwkw22FYQsmDBhAkeOHCE0NNTWpYiIiNiVX49eYMKiPWSaDPq2rM47A5pbDkGHvoXVTwAGtBsH971pNyEIFITKpLfeeosuXbrQpUsX7rzzTkaOHMmKFSuK9DV+++037r///iK9poiI2N6msEs8Pn8PGVkGDzb35/2BLXCyFIKOrIFvx4Fhgtaj4P537SoEgRZULJPCwsJISkri008/JTMzk+3btzNkyBDefvttJk6cWCSvERMTw7Zt24rkWiIiYh+2nIhh/LxdpGeZuK9JVT4a3BJnJwt9Ksd+hOWPgpEFLYZCz49tuoK0JfZXkViFr68vXbp0oVu3bvz73/9m+PDhzJgxI/v5b775hlGjRuU4Z8eOHXTr1i37cUZGBp988gl9+/alb9++2cFq7969/Pe//yUxMTG75+mLL76w1o8mIiLFYPupy4yZG0papom7G1fh06GtcbEUgk78AstGgikDmg4wrxxthyEI1CNUtAwDMpJt89ounrfU3Vi1alUuXryY/fjcuXPs2bMnR5urV6/yxx9/ZD+ePHkyK1asYOrUqZQrV44NGzbw+uuv8+KLLzJ8+HDeeecd3n77bQACAgJuujYREbGtXWeu8OicUFIzTHQN8iNkeGtcnS0Em1ObYMlwyEqHxr2g35fg6GTdggtBQagoZSTDW9Vt89qvRIGr102dGhcXx5o1a+jcuXOhztu8eTNjx45l8ODBADz44IMkJyfj6elJo0aNcHJyokuXLjdVk4iI2Ie9Z6/y8OxQktOz6FK/Ml+ObIObs4VgE74VFg+BzFQIuh8GzAInF+sWXEgKQmXU3r176dKlC5mZmRw9epTWrVvnuDVWEF27duWjjz7C1dWVe++9l8aNG+Pp6VlMFYuIiLUdiIxl1KydJKZl0rFuRWaMaou7i4UQFLETFg40dwrUvxsGzQVnV+sWfBMUhIqSi6e5Z8ZWr10IdevW5e233yYtLY0VK1awaNEizp8/T9WqVQt8jf/97380b96clStXMm3aNLy8vPjiiy+45x7b7RkjIiJF43BUHCO/3klCaibtalfg69Ht8HC1EILO7YEFAyA9Eep0hcELwNnNugXfJAWhouTgcNO3p6zt+mBpgO7du3Pp0iVGjRrF3r17cXJywtPTk5SUlBznXLhwIcdjBwcHBg8ezODBgzGZTDz//POMHTuW8PBwHO10UJyIiOTvWHQCI2buIC4lg9aB5Zn9SHu83CxEhvMHYH4/SIuHwNtg6GJw8bBuwbegzHxaGYZh6xLs2nvvvUdYWBhz584FoFmzZpw5c4b9+/cDEBsby6effprjnPfff5+YmBgAHB0dqVChAk5O5v9bqFKlCgkJCSQkJFjxpxARkVt14mICw2du52pyBs1r+jLn0faUsxSCLhyB+X0hNRZqtofhy0pMh8B1ZSIIvfzyy1SoUIHq1auzdOlSW5djl2rVqsUTTzzB5MmTSUlJoVOnTowZM4ZOnTrRunVrmjRpQpMmTXKc4+PjQ/PmzWnSpAmNGjXiiy++yJ4m37FjR9q0aUOjRo00fV5EpIQ4dSmRoTN2EJOYTpPqPsx/tAM+7hYGO8cch3l9IPkyVG8FI5aDm7d1Cy4CDkYp7yr5+eefmThxIhs3biQqKop77rmHo0ePUrFixQKdHx8fj6+vL3Fxcfj4+OR4LjU1ldOnT1OnTh3c3d2Lo/xicfz4cVJTU2nWrFmO4wkJCezfv59mzZrh6+sLQGRkJFeuXKFhw4akpKRw+PDhHLPLsrKyOHr0KI6OjtSvXx8Xl79+YUwmE8ePHycmJoaaNWtSq1atYvl5Sur7ICJiT8IvJzH4y+1Ex6fSqJo3i8d1pIKXhcHOl0/CnAch4TxUawaj1oBnwT5XrSWvz++/KxFjhMLCwggLC6NTp05UqlTphudNJhO7d+8mISGBVq1aUaFCheznfvnlF0aNGoWfnx9+fn507tyZrVu30rNnT2v+CHalQYMGuR739va+Ybp7zZo1qVmzJgBubm43TLF3cnK6oafoOkdHRxo2bEjDhg2LoGoRESkuEVeSGfqVOQQ1qFKOBWM7WA5BV8Nhbm9zCPJrDCNX210IKgy7vjW2efNm7r77brp3706vXr04ePDgDW0iIyNp1qwZ/fv35+WXXyYgIICFCxdmP3/58mX8/PyyH/v5+WWPaxERESnromJTGDpjO1FxqdT182LhuA5ULmdhxldcJMztBfGRUDkIRq8Brxs7KEoSuw5CUVFRvPzyy2zdutVim3HjxlGxYkVOnjxJaGgob7/9NmPGjCEiIgIwB5/o6Ojs9ufPn88RjERERMqq6LhUhs7YTuTVFGpX8mTxuI5U8bYwxCD+vDkExYZDxbrm22Hlqli34GJg10Fo8ODB3HPPPThY2DriwoUL/PTTTzz33HO4upq78B577DE8PDyyB0X36NGD2bNnc+LECTZt2sSOHTvyXO04LS2N+Pj4HF8iIiKlzcWEVIbN2E745WQCKnqwaFxHqvpYCEGJF2Feb7hyCsoHwui14ONv3YKLSYkYI2TJwYMHMQyDFi1aZB9zcXEhODg4e9p3t27dGD16NHfeeSflypVj1qxZ2QOBczNt2jSmTJlS7LWLiIjYSkxiGsNm7OBUTBI1ynuwaGxHqpe3sPZP0mXz7LCYMPCpaQ5BvjWtW3AxsuseofzExsYC3DADrFKlStnPAbz66qtERETw559/5jtIetKkScTFxWV/Xb/FlpdSPvHO7unPX0Sk4K4kpTNi5g5OXEykmo87i8Z1IKCihd0JUq7C/D5w8QiUq2YeE1ShtlXrLW4lukfo+u2w5OTkHDPFkpOT8+z1yYubmxtubgVbFvz64oHp6el4eJScVTRLm+TkZIAcU/dFRORGscnmEHQ0OoEq3m4sHt+RWpUsLICYGgfz+0P0QfDyM/cEVapn3YKtoEQHoTp16gDmmWM1atTIPh4REUHLli1v6dohISGEhISQlZVlsY2zszOenp5cunQJFxcXbSthZYZhkJyczMWLFylfvnx2MBURkRvFpWQw8uudHDkfT+Vyriwa15E6lS2EoLQE8waqUXvAo6J5YLRfkHULtpISHYSaNm1KzZo1WbFiBR06dADM44bCwsLo0aPHLV17woQJTJgwIXtBptw4ODjg7+/P6dOnCQ8Pv6XXk5tXvnx5qlWrZusyRETsVkJqBg/P3snBc3FU9HJl4diO1K9SLvfG6cmwaAhE7AB3Xxi1CqoGW7Vea7LrIBQZGcm+ffu4fPkyANu2bSMxMZGgoCCCgoJwcHDg/fffZ8SIEbi7uxMYGMg777zDAw88wN13322VGl1dXWnQoAHp6elWeT3JycXFRT1BIiJ5SErL5JHZoew9G0t5TxcWjOlAw2oWtsLISIUlQyH8D3DzgZErwb9F7m1LCbveYmPDhg1Mnz79huPDhg1j2LBh2Y83btzI/PnzSUhIoHPnzjzxxBPZ44du1t9vjYWFheW7RLeIiIi9SUnP4uHZO9lx+go+7s4sGteRpjUsjKHNTIMlw+HEenAtByNWQGAH6xZchAq6xYZdByF7UNA/SBEREXuSmpHFmLmhbDlxmXJuziwY24GWAeVzb5yZDt+MhmPfg4snDF8OtTvn3raEKOjnt0b3ioiIlDKpGVmMn7+bLScu4+XqxNxH21kOQVmZ8O0Ycwhydoehi0t8CCoMBSELQkJCCA4Opl27drYuRUREpMDSM01MWLiH38Mu4eHixKyH29GmloVNUU1ZsPIx+HMNOLnC4IVQt5tV67U13RrLh26NiYhISZGRZeLJRXv46fAF3Jwdmf1wO26rXzn3xiYTrHkS9i0ER2cYvAAa3m/dgouRbo2JiIiUIZlZJp5dso+fDl/A1dmRGaPaWg5BhgHrnjOHIAcneGhWqQpBhaEgJCIiUsJlmQye/2Y/6w6ex9XJkS9HtOGOIL/cGxsG/PAS7J4DDo7Q/ysI7mPVeu2JgpAFGiMkIiIlgclk8OLy/azeF4WzowMhw1tzZ6MquTc2DPj5P7DzK8AB+oRAs4esWq+90RihfGiMkIiI2CuTyeCVlQdZEhqBk6MDnw1txf3N/HNvbBiwYSr88aH5ca+Poc3DVqvV2jRGSEREpBQzDIPJaw6xJDQCRwf4aHBLyyEIYNM7f4WgB94v1SGoMBSEREREShjDMJiy9ggLtp/FwQE+GNSCXi2qWz5h84fw2zTz9/e9Be3HWafQEkBBSEREpAQxDIO3vv+TOVvPAPDOgOb0a1XT8gnbQmDDFPP33V+DThOKv8gSREHIAg2WFhERe2MYBu/+dIwZm08D8Fa/ZgxqG2D5hJ0z4KdXzN93mwS3T7RClSWLBkvnQ4OlRUTEXny4PoxPNhwHYGqfJozqVNty491zYO0z5u+7TITuk8HBodhrtBcaLC0iIlKKfLrheHYI+m/P4LxD0L5FsPZZ8/ednixzIagwFIRERETs3BebTvLB+jAAJt3fiDFd6lhufHA5rJ4AGNB+PNz7P4WgPCgIiYiI2LGZm0/x9g9HAXjh3iAe61rPcuMjq2HFeDBM5unxPd5RCMqHgpAFGiwtIiK2Nm/bGf637k8AnunegCfvamC58dHvYfmjYGRBy+Hw4HRw1Md8fjRYOh8aLC0iIrawaMdZXll5EIAnutXjxfsa4mCpd+f4L7BkKGSlQ7OB0O9LcHSyYrX2R4OlRURESqhloRHZIWj8HXXzDkGnfoMlw8whKLgP9P2izIegwlAQEhERsSMr90by8ooDADzSuTaT7m9kOQSd2QKLhkBWGjR8AAZ8DU7OVqy25FMQEhERsRNr9kfx/LL9GAaM6BjI5J7BlkNQxE5YNAgyU6D+PTBwDji5WLXe0kBBSERExA78cPA8zy3dh8mAIe0CmNq7qeUQdG43LBgA6YlQtxsMng/Oblatt7RQEBIREbGxnw9H89TivWSZDAa0rslb/Zrh6GghBJ0/APP7QVo81OoMQxaDi4d1Cy5FFIQs0PR5ERGxho1HLzJh0R4yTQZ9Wlbn3YeaWw5BF47AvD6QGgcBHWDYUnD1tG7BpYymz+dD0+dFRKS4/B52ibHzdpGeaeLB5v58PLglzk4W+iguhcGcByDpElRvDaNWgbuvVestSTR9XkRExI5tPRHDuGsh6L4mVfkorxB0+STM7WUOQdWaw8gVCkFFREFIRETEynacusyYubtIyzRxd+MqfDq0NS6WQtDVM+YQlBgNVZrAyFXgUcGa5ZZqCkIiIiJWtDv8Co/MCSUlI4uuQX6EDG+Nq7OFj+PYCHMIij8HlYNg1GrwqmTdgks5BSEREREr2RcRy+hZoSSnZ9GlfmW+HNkGN2cLq0DHnzeHoNizULEujFoD5fysW3AZoCAkIiJiBQcj4xj59Q4S0zLpWLciM0a1xd3FQghKvAjzesPV01C+FoxeCz7+1i24jFAQEhERKWZHouIZ8fUOElIzaVe7Al+PboeHq4UQlHTZPEU+Jgx8appDkG9N6xZchigIiYiIFKNj0QmM+HoHcSkZtAosz+xH2uPlZmE/sOQrML8PXDwC3v4weg1UqGXdgssYBSEREZFicuJiAsNnbudKUjrNa/oy99H2lLMUglLjYEF/iD4IXlXMY4Iq1bNuwWWQgpCIiEgxOHUpkaEzdhCTmE6T6j7Mf7QDPu4WNkVNSzDvHRa1FzwrmXuC/IKsW3AZpSBkgbbYEBGRmxV+OYlhM3ZwKSGNRtW8WTCmA76eFkJQehIsHASRoeBe3jxFvkpjq9ZblmmLjXxoiw0RESmMiCvJDPlqO+diU2hQpRyLx3ekcjkLO8NnpMCiQXD6d3DzMYegGq2tW3AppS02RERErCwqNoVhM80hqK6fFwvHdbAcgjLTYOkIcwhyLQcjVigE2YCCkIiISBGIjktl2IztRFxJoXYlTxaP60gVb/fcG2emw7LRcOIXcPGE4d9AgIZi2IKCkIiIyC26mJDKsJnbOXM5mYCKHiwa15GqPhZCUFYmfDsGwn4AZ3cYugRq3WbdgiWbgpCIiMgtiElMY/iMHZy6lESN8h4sGtuR6uU9cm9syoKV4+HPNeDkCkMWQt2u1i1YclAQEhERuUlXk9IZMXMHxy8mUs3HnUXjOhBQ0TP3xiYTrJ4Ah74FRxcYNB/q323dguUGCkIiIiI3IS45gxFf7+BodAJVvN1YPL4jtSp55d7YZILvnoH9i8HBCQbOhoY9rFuw5EpBSEREpJDiUzMYOWsHh6PiqVzOlUXjOlKnsoUQZBjww4uwZx44OMKAGdC4l3ULFosUhERERAohMS2T0bN2ciAyjoperiwc25H6Vcrl3tgw4KdXIXQm4AB9P4emA6xar+TNwoYnpUdqaipvv/02AMHBwQwaNMjGFYmISEmVlJbJI7N3svdsLL4eLiwY04GG1bxzb2wYsGEKbA8xP+79CbQYYr1ipUDKTI9QWFgYy5Yts3UZIiJSQqWkZzFmbiihZ67i7e7MgjEdCK6ex44Dv70Nf0w3f//A+9B6lHUKlUIp9UHI3d2d119/nWHDhtm6FBERKaFSM7IYN28X209doZybM/PHdKBZTV/LJ2z+ADaZ70Zw3zRoP846hUqh2fzW2K5du/jiiy84evQon376Ka1atbqhzapVq5g/fz4JCQl07tyZF154AS8v86C0s2fPMmvWrFyvPXnyZBwdS33WExGRYpSWmcVj83fzx4kYvFydmPtoO1oGlLd8wtbPYMNU8/d3vw6dnrBGmXKTbJoSJk+ezOOPP07dunXZsmULcXFxN7SZNWsWgwcPpnPnzjz22GN8++23PPjgg2ivWBERKW7pmSYmLNzDprBLeLg4MevhdrSpVdHyCTu+gp9fNX9/56vQ5TnrFCo3zaa7z1+9epUKFSoQGRlJQEAAGzdupFu3btnPZ2VlUaNGDcaPH8/UqeZ0HRYWRsOGDVm3bh0PPPBAgV/ru+++Y86cOSxfvrxQNWr3eRGRsikjy8STi/bw0+ELuDk7MvvhdtxWv7LlE3bNhu+eNX9/+wvQ/b9WqVNyVyJ2n69QoUKezx88eJALFy7Qu3fv7GNBQUE0btyY9evXF/h13n33XRYtWsSRI0d4/fXXOXHihMW2aWlpxMfH5/gSEZGyJTPLxLNL9/HT4Qu4OjsyY1TbvEPQ3oV/haDbnoK7/mOVOuXW2fUAmvDwcABq1KiR43iNGjU4e/Zsoa4VFBRUoKnz06ZNw9fXN/srICCgUK8jIiIlW5bJ4Plv9rPuwHlcnBz4ckQb7gjys3zCgW/MW2cAdHgc7nkDHBysU6zcMpsPls5LRkYGYJ759XceHh6kp6cX+DovvfRSgdtOmjSJiRMnZj+Oj49XGBIRKSNMJoOXlh9g9b4onB0d+L/hbbizURXLJxxeBSsfAwxo8wj0eFshqISx6yBUsaJ5QNrly5dz3Ea7fPky9evXL5bXdHNzw83NrViuLSIi9stkMnhl5UG+3ROJk6MDnw5txT3BVS2fcHQdfDsGjCxoOQIe/FAhqASy61tjzZs3x9HRkd27d2cfS0tL4+DBg7lOsy9KISEhBAcH065du2J9HRERsT3DMJi85hBLQiNwdICPBrfk/mb+lk84vh6WjQZTJjQbZF41Wsu1lEh2/a5VrlyZ3r178/7775OcnAzA9OnTycrKYvDgwcX62hMmTODIkSOEhoYW6+uIiIhtGYbB1O+OsGD7WRwc4INBLejVorrlE05uhCXDwZQBwX3N+4c5OlmtXilaNg1CP/zwA126dKF///4APPXUU3Tp0iXHAolffvklTk5O1KhRgwYNGvDOO++waNEi/P3zSOpFQD1CIiKln2EYTPvhKLO3nAHgnQHN6deqpuUTzvwBi4dCVho0fBAGzAQnux5lIvmw6TpCFy9eJCws7IbjgYGBBAYG5jgWFhZGQkICTZo0uWHwdHHSOkIiIqWTYRi899Mx/u+3kwC81a8ZwzoEWj7h7HaY3x8ykqDBvTB4AThrTKm9Kujnt01jbJUqVahSJY/R+H8TFBRUzNWIiEhZ8tEvx7ND0NQ+TfIOQZG7YcFD5hBU904YNF8hqJSw6zFCIiIixeGzX4/z8YbjAPy3ZzCjOtW23DhqHyzoB+kJUPt2GLIIXKx3Z0KKl4KQBRojJCJSOn256STv/2weljHp/kaM6VLHcuMLh2F+X0iNg4COMHQJuHpap1CxCpuOESoJNEZIRKT0+PqP07zx3REAXrg3iCfvamC58aVjMPsBSI6BGm1g5Cpw1+dASVEi9hoTERGxlnnbzmSHoGe6N8g7BF0+CXN7m0NQteYw4luFoFJKQUhEREq9RTvOMnn1YQCe6FaPZ+/OIwRdPQNze0FiNFRpAqNWg0fem4RLyaUgZIHGCImIlA7LdkXwysqDAIy/oy4v3tcQB0tbYcRGwJxeEH8OKjc0hyDPilasVqxNY4TyoTFCIiIl18q9kUxcth/DgIdvq81rvYIth6D4KPOYoKunoWI9eOR78K5m3YKlyGiMkIiIlGlr90fx/LUQNKJjYN4hKOGC+XbY1dNQoTaMXqsQVEYoCImISKnz46HzPLt0HyYDhrQLYGrvppZDUFIMzOsNl0+Ab4A5BPnWsG7BYjMKQhZojJCISMm0/sgFnly0lyyTwYDWNXmrXzMcHS2EoOQrMK8vXDoK3tVh9Boon8cK01LqaIxQPjRGSESk5Nh49CLj5+8iI8ugT8vqfDioJU6WQlBKLMzrA+f3gVcV85igynnMJpMSRWOERESkTNl8/BKPLdhNRpbBg839+WBgC8shKC0BFj5kDkGelcw9QQpBZZKCkIiIlHhbT8Ywdu4u0jNN3NekKh8Nbomzk4WPuPQkWDgQIkPBvbx5inyVxlatV+yHgpCIiJRoO09fYcycXaRlmujeqAqfDm2Ni6UQlJECi4fA2W3g5gujVkG1ZlatV+yLgpCIiJRYu8Ov8MjsnaRkZNE1yI//G9EaV2dLISgVlgyD07+DqzeMXAHVW1m3YLE7CkIWaNaYiIh92xcRy8OzQklKz6JL/cp8ObINbs5OuTfOTIdlo+Dkr+DiBcO/gZptrVuw2CXNGsuHZo2JiNifA5GxDJ+5g4TUTDrWrcjsh9vj4WohBGVlwDcPw9HvwNndHILq3GHVesX6NGtMRERKpYORcYy4FoLa167I16Pb5RGCMmHFeHMIcnKFIYsUgiQHBSERESkxDp2LY8TXO4hPzaRd7QrMfqQdXm7OuTc2ZcHqCXB4BTi6wOAFUL+7dQsWu6cgJCIiJcKhc3EMn7mDuJQM2tSqwOxH2ucRgkyw9hk4sAQcnGDgbAi6z7oFS4mgICQiInbvcJS5JyguJYPWgeWZ80g7ylkKQYYB378Ae+eDgyMMmAmNe1m3YCkxFIRERMSuHYmKZ/jMHcQmZ9AqsDxzH22Pt7tL7o0NA356BXZ9DThA3y+gaX+r1isli4KQBZo+LyJie3+ej2f4zO3EJmfQIqAAIeiX12D7/5kf9/4UWgy2XrFSImn6fD40fV5ExDaORScwdMZ2riSl06KmL/PGdMDXw0IIAvj1Tfj9XfP3D34I7cZYp1CxS5o+LyIiJVbYhQSGXQtBzQsSgn5/768Q1OMdhSApMAUhERGxK8evhaDLSek0q+HL/EfzCUFbPoFf/2f+/p6p0PFx6xQqpYKCkIiI2I0TFxMYOmMHMYnpNK3hw4IxHfD1zCMEbf8C1v/X/P2d/4HOz1inUCk1FIRERMQunLiYyJCvdhCTmEawfwFCUOjX8OPL5u/veBG6vmidQqVUURASERGbO3kpkaEzthOTmEZjfx8Wju1AeU9Xyyfsmg3rJpq/v+1puPNV6xQqpY6CkIiI2NSpS4kM/Wo7lxLSaFTNm4VjO1DBK48QtHsufPes+fuOE8zjghwcrFKrlD4KQiIiYjOnY5IYOmM7F6+FoEXjOlIxrxC0Zx6sfdr8fccn4L43FYLkligIiYiITZyJSWLoV9u5EJ9Gw6rmnqC8Q9B8WHMtBHX4F9z3lkKQ3DIFIQu0srSISPEJv2zuCYqOT6VBlXIsHNeBSuXcLJ+wdyGseQowoP1j0GOaQpAUCa0snQ+tLC0iUrTOXk5myFfbiIpLpX6Vciwe1xE/7zxC0L5FsOoJwIB24+CB9xSCJF9aWVpEROxOxJVkhs7YTlRcKvX8vFg0rkPeIWj/kr+FoLEKQVLkFIRERMQqIq4kM+Sr7ZyLTaGenxeLx3ekire75RP2L4WVjwMGtB0DD7yvECRFTkFIRESKXeRVc0/QudgU6lb2YvG4fELQgWWw6loIavOIQpAUGwUhEREpVudiUxg6YzuRV1OoU/laT5BPHiHo4HJY+RgYJmg92ryTvKM+rqR46G+WiIgUm6jYFIZ8tY2IKynUruTJ4nEdqZpfCFox7loIGgU9P1IIkmKlv10iIlIszselMOSr7URcSaFWJU8Wj+9INd88QtChb/8KQa1GQs+PFYKk2OlvmIiIFLnouFSGfLWds1eSCaxo7gny9/WwfMLhlfDttRDUcgT0+kQhSKxCf8tERKRIRcelMnTGdsIvJxNQ0YPF4ztSvXxeIWgVLB8DRha0HA69P1UIEqvR3zQRESkyF+JTGTZjO6djkqhZwYPF4zpSI68QdGQ1LH/UHIJaDFUIEqtzvpmTDMPg2LFjREZGAhAQEEDDhg2LtLCitG7dOhYuXIi3tzdPPvkkzZo1s3VJIiKlzsV4c0/QqZgkapQ3h6CaFTwtn/Dn2r9CUPMh0CcEHJ2sV7AIhewROn78OE8//TRVq1alcePG3HPPPdxzzz00atSIqlWr8uyzz3LixIniqvWmrFy5ki+//JJevXpRrVo1unXrRnJysq3LEhEpVS4mXAtBl8whaMn4jgRUzCsEfQffPAymTGg+GPr+n0KQ2ESBg9Bzzz1H69atiY6O5v333+fIkSNcvnyZy5cvc+TIEd59913OnTtHq1atmDhxYnHWXCjdu3dnzZo1DB06lClTpuDu7k5CQoKtyxIRKTUuJaQxbMYOTl5KorqvO4vH5ROCjq6Db0abQ1CzgdD3c4UgsZkC3xozmUycPHmSKlWq3PBcxYoVady4MaNHj+bixYu8+eabBbpmXFwc8+fP54svvuDo0aNs2LCBrl275miTmZnJf//7X+bNm0dCQgKdO3fm008/pX79+gAcPnyY559/Ptfrf//99zk2Wps9ezb33nsvVatWLeiPLSIieTCHoO2cuJiIv687S8Z3IrBSHiHo2A+w7FoIavoQ9P1CIUhsyqa7z//nP//h6tWr9OrVi/vvv5+NGzfSrVu3HG1efvll5s6dy4oVK6hVqxbPPPMMu3fv5siRI3h4eBAbG8v27dtzvf59992Hw7Ul2T///HO2bNnCnDlzcHYu+NAo7T4vIpK7mERzCAq7kEg1H3eWPtaRWpW8LJ9w7EdYOgJMGdB0APT7CpxuaqiqSL4K+vl9U0EoIyOD0NBQbrvtNgD27NnDV199Rb169Zg4cSJOToVL95GRkQQEBNwQhFJSUqhcuTLvvPMOTz75JACXL1+mWrVqfP3114waNSrfaxuGwSuvvEJsbCwhISE4FnI2goKQiMiNLieab4cdu5BAVR83lo7vRO3KeYSgsJ/MISgrHZr0g/4zFYKkWBX08/um5ii+/fbbrF+/HoCkpCTuv/9+jh07xmeffcbkyZNvruJc7Nu3j+TkZO68887sY5UqVaJFixZs3bq1QNeYO3cuH374IadPn+aBBx6gR48eHD9+3GL7tLQ04uPjc3yJiMhfriSlM3ymOQRV8XZjSb4h6Oe/QlBwX4UgsSs39Tdx9uzZbNq0CYD169dn9+YcPHiQXr16FXiMUH7Onz8PcMO4JD8/P6Kjowt0jbvuuovVq1fnOJbXGKFp06YxZcqUQlYqIlI2XE1KZ9iM7RyNNoegxeM7UievEHT8F1g63ByCGveGAQpBYl9u6m/jhQsXqFixIgAbN27kwQcfBKB+/fpcvHix6KqzwNHRkYLe0QsMDCQwMLDA1540aVKOWW/x8fEEBAQUukYRkdLm6rWeoKPRCfh5u7FoXEfq+ZWzfMKJX2DJsGshqBc8NAucXKxXsEgB3NStseDgYEJCQjhy5AhLlizhvvvuA+DPP/8kODi4yIq73nNz6dKlHMcvXrxYbDO/3Nzc8PHxYf78+XTs2JHu3bsXy+uIiJQkscnpjPh6B0fOx1O5nBuLx3WgfpW8QtAGWDwMstKgUU94aLZCkNilmx4j9Oabb9KkSRPuvPPO7EHTn3zyCU8//XSRFdeqVSs8PDyyb8MBXL16lf3792e/ZnGZMGECR44cITQ0tFhfR0TE3sUlZzDi6x0cjoqncjnXayHI2/IJJ3+91hOkECT276ZujXXv3p2YmBiuXr2aY/zO888/T5MmTYqsOE9PTx5//HHefPNNOnbsSGBgIE899RRVq1Zl4MCBRfY6IiKSu7gUcwg6dC6eSl6uLBrXkQZV8wpBG2HxUMhMhYYPmEOQs6v1ChYppAL3CP1z6wwXF5cbBjE3a9YMR0fHAm+zMW/ePJydnalduzZgDljOzs5MnTo1u80777zDQw89RPfu3fH39ycqKoqff/4ZL688BucVgZCQEIKDg2nXrl2xvo6IiL2KS8lg5Nc7OHgujorXQlBQXiHo1G+weIg5BAXdDwPnKgSJ3SvwOkL+/v707NmTxx9/nDZt2uTaZvv27cyYMYN169YVaFaXYRhkZWXdcNzR0bHQ6/0UF60jJCJlUXxqBiNn7mB/ZBwVPF1YPL4jjarl8W/gqU2waDBkpkBQDxg0D5zdrFewyD8U9PO7wLfGDh8+zJQpU+jatSs+Pj60adOGqlWrYhgG0dHRhIaGkpyczJgxYzhy5EiBrung4FCoVZ5FRKT4xadmMOrrndkhaNG4fELQ6c1/haAG9yoESYlS6JWlY2NjWbNmDVu2bCEiIgIHBwdq1qxJly5d6N27N76+vsVVq1WFhIQQEhJCVlYWYWFh6hESkTIhITWDUbN2svdsLOU9XVg0tiPB1fP4t+/MH7BwIGQkQ/17YPACcHG3XsEiFhTrFhtliW6NiUhZkZiWyaivd7DnbCy+Hi4sGteBJtXz+J/bM1tg4UPXQtDdMHihQpDYjWLdYkNEREqXxLRMHp61MzsELRybTwgK3/pXT1C97gpBUmLdVBAyDIOZM2fSqVOnHAsb/uc//yEqKqrIihMRkeKXlJbJI7N3siv8Kj7uziwY04GmNfIKQdtgwUOQkQT17oIhixSCpMS6qSD02Wef8frrrzNw4MAcW2rUrl2b//3vf0VWnC1p+ryIlAXmEBRK6JmreLs7s2BsB5rVzCMEnd1+7XZYEtTtphAkJd5NjRFq2LAhc+bMoVOnTjg4OGTv+xUREUHbtm25cOFCkRdqKxojJCKlVXK6OQTtOH0FbzdzCGoRUN7yCWd3wIL+kJ4IdbrC0CXg6mm1ekUKo1jHCJ05c4aWLVsC5inw13l7exMbG3szlxQREStKTs/k0Tl/haB5Y9rnHYIidsKCAddC0B0KQVJq3FQQCgwMZN++fUDOILRq1SoaNmxYJIWJiEjxSEnPYsycXWw/dYVybs7MHdOeVoEVLJ8QEQrz+0N6AtS+HYYuVQiSUuOmVjN8+umnGT16NO+++y4AO3bs4Mcff+Tdd9/lk08+KdICRUSk6KSkZzFmbijbTl3Gy9WJuY+2p3VeIShy97XbYddC0DCFICldbioIPfXUU6SmpvLoo49iMpno2LEjvr6+TJkyhTFjxhR1jTbx9wUVRURKg9SMLMbN28XWk3+FoDa18ghB53bD/H6QFg+1Ol8LQcW7z6OItd3SgopZWVmcOnUKk8lE3bp1cXFxKcra7IIGS4tIaXA9BG0+HoPntRDUrnZFyyec2wPz+kJaHATeBsO/AbdyVqtX5FYV+V5juXFycqJBgwa3cgkRESlmqRlZjJ+/OzsEzXkknxAUtRfm970WgjopBEmpdtNBaNeuXWzZsoWrV6/e8Nzrr79+KzWJiEgRSc3I4rH5u/k97BIeLk7Mfrgd7evkFYL2wbw+kBoHAR0VgqTUu6kg9O677/Lvf/+b4OBgypcvf8PzCkIiIraXlpnFvxbsZtP1EPRIOzrUrWT5hPP7/xaCOsCI5eDmbb2CRWzgpoLQhx9+yHfffccDDzxQ1PWIiEgRMIegPWw8dgl3F0e+frgtHfMMQQeuhaBYqNkehisESdlwU+sIJSUlcccddxR1LXZFW2yISEmVlpnFhIV7+PXoRdycHZk1uh231ats+YTogzCvN6RchZrtYMS34K7JIVI23FQQ6tGjB6tWrSriUuzLhAkTOHLkCKGhobYuRUSkwNIzTUxYuJdf/jSHoK9Ht+O2+nmFoEMw91oIqtFWIUjKnJu6Nfbxxx/TokULli9fTr169XKsLg3w/vvvF0lxIiJScOmZJiYs2sMvf17A1dmRmaPb0qVBHiHowuFrPUFXoEYbGLkC3PPYcFWkFLqpIPTGG29w9epVoqOjSU1NLeqaRESkkDKyTDy1eA/rj5hD0IxRbbm9gZ/lEy4cgbm9IPkyVG8NIxSCpGy6qSC0cOFCfv75Z+66666irkdERAopI8vE04v38tPhC7g6OfLVyDZ0DSpoCGoFI1eCR3mr1StiT25qjJC7uzvt27cv6lpERKSQMrJMPLNkLz8cisbVyZEvR7ahW8Mqlk+4+Oe1EBQD/i0UgqTMu6kgdMcdd7BkyZKirkVERAohM8vEs0v38f1Bcwj6YmRr7myUVwg6+lcIqtYcRq4Cjzz2GhMpA27q1piTkxPjx4/nm2++oX79+jcMlv7ss8+KpDhb0qarImLPMrNMPLdsP+sOnMfFyYHPR7TmrkZVLZ9w6Zg5BCVdgmrNYNRq8MxjhWmRMuKmNl3t27dvns+Xpqn12nRVROxNZpaJicv2s2Z/lDkEDW/D3cF5haAwmPMgJF28FoLWKARJqVesm66WpqAjIlKSZJkMnv/GHIKcHR0IGdY67xAUcxzm9jSHoKoKQSL/dFNjhERExPqyTAYvfLOf1fvMIeizYa25t0k1yyfEnIA5PSHxAlRpotthIrkocI/Qww8/DMCcOXOyv7dkzpw5t1CSiIj8U5bJ4MVv9rNy7zmcHB34bFgrejTNIwRdPmnuCUqMNoeg0WvAK4+9xkTKqAIHoczMzFy/FxGR4pVlMnhp+QFWXAtBnw5tRY+m/pZPuHzS3BOUcB6qBF8LQXmsMC1ShhVqsHRsbCzly5cvxnLsjwZLi4gtmUwGL397gG92R+Lk6MAnQ1rxYPOChKAo8GsEo7+DcnksrihSShX087tQY4QqVNB6EyIi1mIyGUxacZBvdkfi6AAfDW6Zdwi6cso8RT47BK1VCBLJhwZLi4jYIZPJ4JWVB1m6KwJHB5g+uCW9WlS3fMKV0zCnF8Sfg8oNr4WgPBZXFBFAQUhExO6YTAavrjrEktC/QlCfljUsn3D1jLknKD4SKgcpBIkUQqHXEfroo4/ybfPss8/eRCn2RStLi4gtmEwG/119iMU7z+LoAB8MapFPCAo39wTFRUClBuYQ5J3HukIikkOhBks7ODjg5eWVb7vExMRbKsqeaLC0iFiLYZhD0ILtZ3FwgA8GtqB/65qWT4g9a14xOvYsVKoPD68D7zym1IuUIcW2snRpCjkiIvbCMAxeW3M4OwS991B+ISjirxBUsZ55dphCkEihaYyQiIiNGYbBlLVHmLctHAcHeHdAcx5qU9AQVBce/g588phNJiIWKQjZSHRcKhfiU21dhojYmGEYTP3uCHO2ngHgnf7NGdg2wPIJcZHmFaNjw6FCHXNPkE8es8lEJE+FCkITJkworjrKlCyTwbNL99Ljo9/56XC0rcsRERsxDIM3vvuT2VvOAPB2/2YMapdXCDpnXizx6hmoUNvcE+Sbx0BqEclXoYLQZ599Vlx1lClXk9OJT8nkanIGj83fzaQVB0lO17YlImWJYRi8ue5PZm05DcBb/ZoxpH2g5RPio8w9QVdPXwtB68A3j9tnIlIgujVmA5XLubFywm08dkddABbvPEvPT/7gYGScjSsTEWswDINpPxxl5h/mEPRmv6YM65BPCJrT07xydPla5tthCkEiRUJByEbcnJ2Y9EBjFo7tQFUfN07FJNHv/7bw+W8nyTIVeEUDESlhDMPg7R+P8tXvpwB4o29ThneoZfmE+PPXQtBJKB9ovh1WPo/bZyJSKApCNta5fmV+fOYOejSpRqbJ4J0fjzJ85naiYlNsXZqIFDHDMHj3p2N8uckcgqb2acLIjnmEoIRo8+2wKyfBN9DcE1Q+j54jESm0MhOEMjMzKcTakVZVwcuVz0e05t0BzfF0dWL7qSvc//Fm1h04b+vSRKSIGIbBez8d4/PfTgLweq9gRnWqbfmEhAvmnqDLJ8A3wNwTVCGP0CQiN6XUB6GMjAxeeukl/Pz88Pb25tVXX7V1SblycHBgULsA1j19Oy1q+hKXksGERXt48Zv9JKZpILVISWYYBh/8HMb/XQtBr/UK5uHOdSyfkHDB3BN0+Tj41FQIEilGpT4InT59msDAQKKiojhx4gRz587lzz//tHVZFtWp7MXyf93GhDvr4eAA3+yO5MFPNrP37FVblyYiN2n6L8f5bOMJAP7bM5hH8gpBiRfNG6jGhIFPjWshqLZ1ChUpgwq9xUZxOHjwIMeOHaNr1674+fnd8HxGRgbbt28nISGBtm3bUqXKX7sqZ2VlkZCQkOt1y5cvT1BQEPXr1yc+Pp6oqCjc3NyoXLlysf0sRcHFyZEX72vEHQ38mLhsP+GXk3noi208270BT9xZHydHB1uXKCIF9NEvYXyy4TgA/3mwMWO65BWCLl0LQcf+CkEV82gvIrfMpj1CGzdupEuXLvTt25eBAwdy+PDhG9qcOXOGJk2a8PDDDzNt2jTq1KnDrFmzsp8PDQ2ldu3auX5d3zk+PDyc2rVr065dO4YNG5Zr2LJHHepW4vtnbqdXi+pkmQw+WB/GkK+2EXEl2daliUgBfPzLcT76xRyCXn2gMWNvr2u58fUQdOkoeFc37yJfMY/2IlIkbBqErl69yrRp09i0aZPFNuPHj6dGjRocO3aMzZs3M336dP71r39x5swZADp27EhsbGyuX05OTgDUqVOH2NhYLl++zIYNG/jxxx+t8eMVCV8PFz4Z0pLpg1tQzs2Z0DNXeeDjzazed87WpYlIHj7dcJzpv4QBMOn+Roy7I49QkxQD83rDpT/B29/cE1SpnpUqFSnbbBqE+vfvz+23327x+ejoaH755ReeeeYZnJ3Nd/EeffRRypUrx7Jlywr0GkuWLGHWrFlERUVx5swZ4uLisgNSbtLS0oiPj8/xZWsODg70a1WTH565nTa1KpCQlskzS/bx7JK9xKdm2Lo8EfmHkI0n+GC9OQS93KMRj3XNI9QkxcDc3nDxCJSrZl4xWiFIxGrserD0wYMHMQyD5s2bZx9zdnamcePGHDhwoEDX6NOnD/v376dDhw6MGDGCRx99lHvuucdi+2nTpuHr65v9FRBgPwuXBVT0ZOn4jjx3dxBOjg6s2hfF/R9tJvTMFVuXJiLX/N9vJ3jvp2MAvHhfQ/7VLa8QdBnm9YGLh6+FIPUEiVibXQehuDjzlhMVKlTIcbxSpUrExsYW6BoeHh58/PHHREREcOjQIZ5//vk820+aNIm4uLjsr4iIiJuqvbg4OznyzN0NWPZYJwIqenAuNoXBX27jg5+PkZFlsnV5ImXaF5tO8u6P5hD0wr1BTLizvuXGyVfMIejCIShX1RyCKjewUqUicp1dByE3NzcAkpNzDg5OTEzE3d292F7Tx8cnx5c9alOrAt8/fTsDWtfEZMCnv57goS+2cSYmydaliZRJX246yds/HAVg4j1BPHlXHqEm+Yp5TNCFg+BVxbxitEKQiE3YdRCqW9c8uPDs2bM5jp89ezb7ueISEhJCcHAw7dq1K9bXuRXe7i58MKgFnw5thbe7M/sjYnngk80s2xVht6toi5RGM34/xbRrIejZuxvwdPf8QlAfiD4IXn7mniC/ICtVKiL/ZNdBKDg4mFq1arF8+fLsY3v37uXEiRPcf//9xfraEyZM4MiRI4SGhhbr6xSFXi2q8+Ozd9C+TkWS07N4afkBnly0l9jkdFuXJlLqzdx8ije/Ny/S+nT3Bjx7dx6hJuUqzO8L0QfMIWj0d+DX0DqFikiubLqgYnh4OKGhoVy5Yh7su2nTJmJiYggODiY4OBgHBwc+/PBDBg8ejLOzM4GBgXzwwQf07duXO++805al250a5T1YPK4jX/5+kg9/DmPdwfPsOXuVDwa14LZ69r2ApEhJNeuP0/xvnTkEPXVXfZ67O4+eoJSrMK8vnN8PnpXN6wRVaWSdQkXEIgfDhvdQfvvtNz777LMbjg8aNIhBgwZlP966dSsLFiwgISGBzp07M3bs2Ozp9MUlJCSEkJAQsrKyCAsLIy4uzm7HC/3TgchYnlmyj9MxSTg4wGN31GPiPUG4Ott1B6BIiTJny2leX3sEgAl31uOFexvi4GBh1feUWHNPUNTev0JQ1WCr1SpSFsXHx+Pr65vv57dNg1BJUNA/SHuTnJ7JG98dYfFO86y3pjV8+HhIK+r5lbNxZSIl37xtZ5i82rwS/hPd6vHiffmFoH4QtQc8K10LQU2sV6xIGVXQz291EZRSnq7OTOvfnC9GtKG8pwuHzsXz4CebWbTjrAZSi9yC+X8LQY93zScEpcbBgv7mEORREUatUQgSsTMKQhaUhFljBdGjaTV+evYOutSvTGqGiVdWHmT8/N1cSdJAapHCWrA9nP9eC0GP3VGXl3vkFYLiYX5/OLfbHIJGr4FqTa1YrYgUhG6N5aOk3hr7J5PJYNaW07z74zHSs0z4ebvxwcAW3BFUMjagFbG1RTvO8srKgwCMu70OrzzQOO8QtKA/RIaCRwVzT5B/89zbikix0K0xycHR0YGxt9dl5YTbqF+lHJcS0hg1aydvfHeE1IwsW5cnYtcW7/wrBI3pkk8ISkuABQPMIci9PIxarRAkYscUhMqYJtV9WftkF0Z1qgXA13+cpm/IFsIuJNi4MhH7tDT0LJNWmEPQI51r858H8wtBD0Hkzr+FoBbWK1ZECk1ByILSMkYoNx6uTkzt05SvR7elkpcrR6MT6PXpH8zdekYDqUX+ZlloBP++FoIevq02k3sG5x2CFg6EiO3g7gujVkH1llarVURujsYI5aO0jBGy5FJCGi8u389vxy4BcGdDP959qAV+3m42rkzEtr7ZFcFL3x7AMGBUp1pM6d0kjxCUaA5BZ7eaQ9DIVVCjtVXrFZGcNEZICsTP243ZD7djSu8muDo7svHYJXp89Du/Hr1g69JEbObb3ZHZIWhEx8D8Q9CiQeYQ5OYLI1cqBImUIApCgoODA6Nvq83aJ7vQqJo3l5PSeXTOLiavPqSB1FLmrNwbyQvL92MYMLxDIFN7N7UcgtKTYNFgCN8Cbj7XQlAb6xYsIrdEQUiyNazmzaoJnRnTpQ4A87aF0/PTPzgcFWfjykSsY9Xeczy/zByChrYP5I0+TXF0tBSCkq+FoD/+CkE1FYJEShoFIQtK82DpvLi7OPHfnsHMe7Q9ft5unLiYSL+QrczcfAqTScPJpPRave8cE5ftw2TA0PYBvNk3vxA0CM5sBldvGLECara1bsEiUiQ0WDofpX2wdF6uJKXz8rcHWH/EPF6oS/3KfDCoBVV93G1cmUjRWrM/imeX7MVkwOC2AUzr3yzvELR4MJz+3RyCRq6AgPbWLVhE8qXB0nLLKnq58tXINrzVrxnuLo78cSKG+z76nR8PRdu6NJEis/ZvIWhgm5p5h6CMFFgy9FoIKgcjvlUIEinhFIQkTw4ODgzrEMh3T91O0xo+xCZn8PiC3UxacYDk9ExblydyS9YdOM+zS823wx5qU5N3BjTPOwQtHgqnfgMXL3MICuxg1XpFpOgpCEmB1K9SjhX/6szjXevh4ACLd0bQ85M/OBAZa+vSRArFMAz2R8Ty4jf7eXrJXrJMBv1b18gnBKXCkmFwauPfQlBH6xYuIsVCY4QsCAkJISQkhKysLMLCwsrkGCFLtp6MYeLS/UTHp+Ls6MDEe4N47I56OFn6EBGxA8npmazZF8WCHeEcOheffXxA65q8+1Bzy39/r4egkxuuhaDlUOs2K1UtIjeroGOEFITyUZYHS+clNjmdV1Ye5PuD5vFCHepUZPrgllQv72HjykRyOn4hgQXbw1mx5xwJaebbua7OjjzYzJ8RHQNpHVjB8jpBGamwdDic+AVcPGH4N1C7ixWrF5GbpSBURBSELDMMg+W7I3ltzWGS07PwcXfmrf7N6Nm8uq1LkzIuLTOLnw5fYMH2cHaevpJ9vFYlT4Z3COShNgFU9HLN+yKZabB0BBz/2RyChi2DOrcXc+UiUlQUhIqIglD+zsQk8czSfeyPiAXMtxqm9GlCOTdn2xYmZU7ElWQW7TzLstAILielA+Dk6MDdjaswomMtOterbHkc0N9lpsHSkXD8J3D2gOHLoM4dxVy9iBQlBaEioiBUMBlZJj7dcJzPNp7AZEBgRU8+GtKS1oEVbF2alHJZJoONRy+yYEc4m8Iucf1ftKo+bgxtH8iQdoFU8y3E2leZabBsFIT9aA5Bw5ZC3a7FU7yIFBsFoSKiIFQ4oWeu8OySfZyLTcHJ0YGn72rAhDvr4eykCYpStC4mpLJ0ZwSLd54lKi41+/jtDSozvEMt7m5cpfB/7zLT4ZvRcOx7cHa/FoK6FW3hImIVCkJFREGo8OJTM5i86hCr9kUB0KZWBT4a3JKAip42rkxKOsMw2HbqMgu3n+Wnw9FkXtv2pbynC4PaBjCsfSC1K3vd3MUz0+Gbh+HYOnMIGroE6t1ZdMWLiFUpCN0iTZ+/dav2nuO/qw6RkJZJOTdn3ujbhL4ta1ieoSNiQVxyBsv3RLJwRzinLiVlH29TqwLDOwTyQDN/3F2cbv4FsjLMIejod+DkBkMXQ/3ut164iNiMglARUY/QrYm4ksxzS/exK/wqAL1bVOeNvk3x9XCxcWVi7wzDYH9kHAu2h7N2fxRpmSYAvFyd6NuqBsM71CK4ehH8Tt4QghZB/btv/boiYlMKQkVEQejWZWaZ+Py3k3y04ThZJoMa5T2YPrgl7etUtHVpYocsLXzYqJo3IzrWom+rGkU3IzErA5Y/Cn+uASdXGLIYGigEiZQGCkJFREGo6Ow9e5Vnl+4j/HIyjg7wRLf6PHN3A1w0kFqAsAsJLMxl4cOezfwZnt/ChzcjKwO+HQNHVl8LQYugwT1Fd30RsSkFoSKiIFS0EtMymbLmMN/sjgSgRU1fPhrSijo3O8BVSrS0zCx+PBTNwh1nb37hw5uREmu+HXZqozkEDV4IQfcW/euIiM0oCBURBaHise7AeSatOEB8aiaerk683qsJA9vW1EDqMqLIFj68GVdOw6LBEHPMvGL0wLkKQSKlkIJQEVEQKj5RsSlMXLaP7afMPQH3N63GtP7NKO9ZDD0AYnNFvvDhzTi73byBavJl8K4Ow5aAf4vifU0RsQkFoSKiIFS8skwGMzaf4v2fjpFpMqjm486Hg1pwW/3Kti5NikixLHx4Mw4sg9UTICsd/Fua1wny8S/+1xURm1AQKiIKQtZxMDKOZ5bs5VRMEg4OMP72ujx/b0NcnTWQuiQyDINtJy+zYEc4Px++kL3wYQVPFwbe6sKHhS8GfpsGm94xP27UE/p/Ba4alyZSmikIFREFIetJTs/kf+v+ZNGOswA0qe7Dx0NaUb9KORtXJgWV18KHIzoGcn/TW1z4sLAyUmH1E3DoW/Pjzs9C99fAUQFbpLRTECoiCkLW9/PhaF7+9gBXkzNwd3HkPw8GM7xDoAZS26m8Fj7s19q88GFjfxv87iReNI8HigwFR2fo+RG0Hmn9OkTEJhSEbpG22LCti/GpPP/NfjYfjwHg7sZVeGdAcyqVc7NxZXJdcnomq/dFsdAaCx8W1oUj5plhcWfBvTwMXgB1brdNLSJiEwpCRUQ9QrZjMhnM3nqGd344SnqWCT9vN94f2IKuQX62Lq1My3vhw1q0Dixv296747+Y1whKT4CKdWHYN1C5vu3qERGbUBAqIgpCtvfn+XieWbKXsAuJADzauQ4v9Who3bEmZVz2wofbz7LzzF8LH9au5MnwDrV4qE1NKhTHwoeFtXMG/PASGCao1QUGzwdPbeUiUhYpCBURBSH7kJqRxds/HGXO1jOA+fbLR0Na0qia3pPiFHElmYU7zvLNLhssfFgYWZnw0yuw80vz45bDzWOCnO0gnImITSgIFREFIfuy8ehFXly+n5jEdFydHZl0fyMevq22BlIXoSyTwa9HL7LwHwsfVvNxZ0j7AOssfFgYqfHmjVNPrDc/7v4adHkO9HdCpExTECoiCkL2JyYxjZeWH+DXoxcB6Brkx3sDm1PF244+nEugvBY+HNGxFt0bWWnhw8KIPWseFH3xCDh7QP8vIbiPrasSETugIFREFITsk2EYLNgezv/W/UlapomKXq68O6A5dwdXtXVpJUpeCx8OahvAUGsufFhYkbtg8VBIugjlqsLQxVCjja2rEhE7oSBURBSE7NvxCwk8vWQff543T98e0TGQVx8IxsNVA6nzYncLHxbWoRWw6l+QmQpVm5n3DPOtaeuqRMSOKAgVEQUh+5eWmcX7Px1jxubTANTz8+LjIa1oWsPXxpXZF7td+LAwDAN+fx82/s/8OKgHDJgJbt62rUtE7I6CUBFRECo5Nh+/xPPL9nMxIQ0XJwdevK8hY7vUtY9ZTTZ0feHDBdvDORxlZwsfFkZmGqx5Gg4sMT/uOAHufQMc7bjnSkRsRkEoF9OnT6dWrVr079+/wOcoCJUsV5PS+feKA/x0+AIAnetX4oOBLe1rlpOVhF1IYMH2cFba68KHhZF0GZYOh7PbwMEJHngP2o2xdVUiYscUhP5hxowZLFq0iHr16jFz5swCn6cgVPIYhsHS0AimrD1CSkYW5T1deLt/M3o09bd1acWuxCx8WBiXwmDRQLh6Btx8YdAcqHeXrasSETtX0M/vEtAffuuOHDnCnj17GD16NH/88Yety5Fi5uDgwJD2gbSvU5Fnluzj4Lk4Hl+wh8FtA5jcKxivknAbqJAsLXx4T+OqDO8YaD8LHxbWyY2wbDSkxUH5WjBsGVRpZOuqRKQUsfknwh9//MEXX3zB0aNH+fLLL2nT5sbpr0uXLmXevHkkJCTQuXNnJk2alJ3uwsPD+fzzz3O99ltvvUV6ejpvvPEGX3/9NcuWLSvWn0XsS12/cnz7r9v46JcwPt90kqW7Ith55gofDW5Ji4Dyti7vlpW4hQ8La9dsWPc8GFkQ0BGGLASvyrauSkRKGZsGoVdeeYVNmzbRv39/Fi5cSEJCwg1tvvjiC5577jk++OADatWqxeTJk/n999/ZvHkzjo6OODk5Ub58+Vyv7+DgwGuvvUZ6ejpTp07l4MGDREZGsnTpUgYPHlzMP53YA1dnR17q0Yg7gvyYuHQfp2OSGPD5Vp67J4jHu9bDqQT2klyMT2VpaAlb+LAwTFmwfjJs+8z8uNkg6P0puJTgUCcidsumY4QSEhLw9vYmMjKSgIAANm7cSLdu3bKfz8rKwt/fnyeffJLJkycDcOrUKerVq8eaNWvo1atXvq+xatUqjh49CsDu3bsJDw9n8uTJ9OzZs0A1aoxQ6RGXnMErqw6y7sB5ANrXqcj0wS2pUd7DxpXlL7+FD4d1CKRWJTtd+LAw0hJhxTg49r358Z2vwh0varsMESm0EjFGyNs777U/Dhw4wKVLl3jwwQezj9WtW5fg4GA2bNhQoCDUt2/f7O/nzJnDH3/8kWcISktLIy0tLftxfHy8xbZSsvh6uvDZ0Fbc1bAKk1cfYufpK/T46Hfe6teMXi2q27q8XMUmp7N8dySLdpzlVMxfCx+2rVWBER1r0aNpNfte+LAw4s7B4sEQfRCc3KDv/0Gzh2xdlYiUcjYfI5SXs2fPAlC9es4PqerVq2c/Vxht2rShatW8t2CYNm0aU6ZMKfS1pWRwcHBgQJuatK1dgWeX7mPv2VieWryXjUcvMqVPE7zdXWxdIoZhsC8ilgXbz/LdgRK68GFhRe2FRUMgMRq8/GDIYghoZ+uqRKQMsOsglJGRAYCbm1uO4x4eHtnPFUazZs1o1qxZnm0mTZrExIkTsx/Hx8cTEBBQ6NcS+1arkhffPNaJT389wae/HmfF3nOEhpsHUrepVdEmNVla+LCxvw8jOgbSp2UJWfiwsI6sgRXjITMF/BrDsKVQoZatqxKRMsKu/1WtVKkSAJcvX6Zixb8+nGJiYggKCiqW13Rzc7sheEnp5OzkyHP3BHF7g8o8u3QfEVdSGPjFNp66qwFP3VXfagOOLS582Nyf4R1K2MKHhWEYsOUj+OV18+P6d8NDs8G9lPV2iYhds+sg1KJFC5ycnAgNDaVBgwYApKamcvDgQYYMGVKsrx0SEkJISAhZWVnF+jpie21rV+T7Z27n9dWHWbH3HB9vOM7m45f4aHArAit5FstrlsqFDwsjMx3WPQd7F5gftx8P900DJ7v+J0lESiG7WFna0qwxgIEDB3LixAl+//13vL29mTp1Ku+99x4nT56kSpUqxV6bZo2VLav3neM/qw6RkJpJOTdnpvRuQv/WNYqsR+bs5WQW7cx94cMRHWtxW71KJXPhw8JIvgLLRsGZzeDgCD3ehg6P2boqESllSsQWG9999x2vv/46GRkZHDhwgKCgILy9vRk/fjzjx48HzLfFBgwYwK5du6hQoQJpaWnMnTuX+++/v1hr+3uPUFhYmIJQGRJ5NZmJS/dn99T0bO7Pm32b4et5cwOpry98uGB7OL8fz7nw4dD2gQxuF1CyFz4sjMsnYeFAuHISXL3hoVkQdK+tqxKRUqhEBKHLly9z+vTpG45Xr179hpliZ8+eJSEhgaCgIFxcrDezRz1CZVOWyeCLTSeZvj6MTJNBdV93Phzcko51KxX4GhfjU1kSGsGSfyx8eEeQH8M7BJb8hQ8L68wfsHQEpFwF3wDzoOiqTWxdlYiUUiUiCJUECkJl276IWJ5dspczl5NxcIAnutXj2buDcLEQYAzDYOvJyyws7QsfFtbehbD2GTBlQI22MGQReOe9lIWIyK1QECoiCkKSlJbJ1LVHWLorAoDmNX35eEgr6lT+K9CUqYUPC8Nkgl+nwh/TzY+b9IO+n4OL/a/mLSIlm4LQLdIYIfmnHw6e598rDhKXkoGHixOv9QqmYTVvFu44y9r9ZWThw8JIT4aVj8Gfa8yP73gRur0CjmXodqCI2IyCUBFRj5D83fm4FJ5ftp+tJy/f8FypX/iwMBKiYfEQ84rRTq7mTVNbFO+SFyIif1ci9hoTKWn8fT1YMKYDM/84xXs/HcPBwYGezf0Z0bEWrQJK6cKHhRV9EBYNhvhz4FHRPB6oVidbVyUikisFIZFCcnR0YPwd9ejbqgZuzk74eth+fzK7cewHWD4GMpKgcpB5ZljFurauSkTEIt2styAkJITg4GDatdPGj5K7Kt7uCkHXGQZsC4HFQ80hqE5XGLNeIUhE7J7GCOVDY4RE8pGVAd+/CLtnmx+3eRgeeB+cFBJFxHY0RkhEil9KLHzzMJzaCDjAvf+DThNAY6VEpIRQEBKRm3PltHlQdMwxcPGCATOh0QO2rkpEpFAUhCzQ7vMieTi7HZYMg+TL4F0dhi0B/xa2rkpEpNA0RigfGiMk8g8HlsHqCZCVDv4tYegS8PG3dVUiIjlojJCIFC3DgI1vwe/vmh836gn9vwLXMrh3moiUGgpCIpK/jBRY9QQcXmF+3PlZ6P6atssQkRJPQUhE8pZ40TweKDIUHJ2h50fQeqStqxIRKRIKQiJi2YUj5plhcWfBvTwMXgB1brd1VSIiRUb92hZoZWkp847/Al/faw5BFevC2A0KQSJS6mjWWD40a0zKpB1fwY8vg2GCWl1g8HzwrGjrqkRECkyzxkSk8LIy4adJsPMr8+OWw81jgpxdbVqWiEhxURASEbPUeFj+KJxYb37c/TXo8py2yxCRUk1BSEQg9qx5UPTFI+DsAf2/hOA+tq5KRKTYKQiJlHURobBkKCRdgnJVzStF12ht66pERKxCQUikLDv0Laz8F2SlQdVm5j3DfGvauioREavR9HkLNH1eSjXDgE3vmscEZaVBUA949EeFIBEpczR9Ph+aPi+lTmYarHkKDiw1P+44Ae59AxydbFuXiEgR0vR5EblRUgwsGQ4R28HBCR58H9o+auuqRERsRkFIpKy4dAwWDYKrZ8DNFwbNgXp32boqERGbUhASKQtOboRloyEtDsrXguHfgF9DW1clImJzCkIipd2uWbDuBTCyIKAjDFkIXpVtXZWIiF1QEBIprUxZ8PN/YXuI+XHzwdD7U3B2s21dIiJ2REFIpDRKS4Rvx0LYD+bHd74Kd7yo7TJERP5BQUiktImLhEVD4MJBcHKDfp9D0wG2rkpExC4pCImUJuf2wOKhkBgNXn4wZDEEaFFQERFLtLK0BVpZWkqcI2tg9gPmEFQlGMZuUAgSEcmHVpbOh1aWFrtnGPDHdNgwxfy4/t3w0Gxw199XESm7tLK0SFmQmQ7fPQf7Fpgftx8P900DJ/1qi4gUhP61FCmpkq/AslFwZjM4OEKPd6DDeFtXJSJSoigIiZREl0/CwoFw5SS4esPA2dDgHltXJSJS4igIiZQ0pzfD0hGQGgu+ATBsKVRtYuuqRERKJAUhkZJk7wJY+yyYMqBGWxiyCLyr2roqEZESS0HIVlKugnt5rfQrBWMymWeFbfnI/LhJP+j7Obh42LQsEZGSTkHIVub3h6tnoHor81eN1ub/+lS3dWVib9KTYeV4+HOt+fEdL0K3V8BRy4CJiNwqBSFbyMqEmOOQngAnN5i/ritX7a9QVP3af70q2a5Wsa3487B4CJzfB06u5k1TWwyxdVUiIqWGFlTMR7EtqJiZBhcOQ9ReiNoD5/bCpT/BMN3YtnygORRdD0j+LbVYXllw/oA5BMWfA4+K5vFAtTrZuioRkRKhoJ/fpT4IXb16lWbNmmU/btGiBevWrSvw+VZdWTo9GaIPmMPRuT3mgHT5RC4NHaByg5y9Rv7NNV6kNDn2AywfAxlJUDnIPDOsYl1bVyUiUmJoZelrsrKyKFeuHL/88gsArq6uNq4oD66eENjR/HVdahxE7TOHoqi95p6juLMQE2b+OrDU3M7Byby/VPWWf/UcVWkCznb888qNDAO2hcDP/wEMqNMVBs0Dj/K2rkxEpFSyix6hpKQkzp8/T40aNfDwyL1XIy4ujqSkJPz9/XEoxEyrmJgYateuTY0aNfD392fy5MncddddBT7fLvcaS7xkHjNyvdfo3B5IunhjOyc3qNb0r56jGq3NvQuOTlYvWQogKwO+fwF2zzE/bvMwPPA+OLnYsioRkRKpRNwaCwsL45NPPmHp0qXExMSwceNGunXrlqNNQkICo0aNYt26dXh4eFCpUiXmzp3L7bffDkBoaCj9+vXL9frh4eE4ODgQFRVFZmYmW7Zs4ZlnnuHQoUNUq1atQDXaZRD6J8OA+Ki/jTe61nuUGntjWxcv8G/xtwHZrcy3XDSN37ZSYuGb0XDqN8AB7v0fdJqg90VE5CaViFtjP/74Iw0bNuS3336jadOmubZ58sknOXbsGJGRkVSuXJmXXnqJPn36cOLECSpWrEiLFi3Yvn17ruc6OZl7PmrWrAlA7dq1WbRoEfv37y9wECoRHBzAt4b5q3FP8zHDgKun/wpFUXvNt9gykuDsVvPXde6+Occb1WgNPjX0IWwtV07BosHmW50uXjBgJjR6wNZViYiUCXZxaywyMpKAgIAbeoTi4uLw8/NjxowZjB49GjDfRvPz8+P999/niSeeKNTrHD9+nNtvv53ff/+doKCgAp1TInqECsqUZZ62nz3eaA9EH4SstBvbelX52/pG1wJSOT/r11zahW+DJcMg5Qp4VzcPivZvbuuqRERKvBLRI5Sfffv2kZGRQadOf00Z9vLyokWLFuzatatA11i8eDEvvvgiWVlZJCcnM2XKlDxDUFpaGmlpfwWD+Pj4m/8B7I2jE1RpZP5qOcx8LDPdPG3/+nijqL1w4Yh5zNHxn8xf1/kGmAdjXx9v5N9Sg3hvxf6lsOZJyEo3/1kOXQI+/rauSkSkTLHrIBQTEwNApUo5FxSsXLly9nP56dOnD7fffjvOzs5UrVo134HW06ZNY8qUKTdXcEnk7GoeM+TfAnjEfCwjxdxT9Pdp/DHHIS7C/HV9hWOAivVyLgDp3xxcvWzyo5QYJhP89hb8/p75ceNe0O9L/bmJiNiAXQchx2tbCGRkZOQ4np6ejqenZ4Gu4enpWeC2AJMmTWLixInZj+Pj4wkICCjw+aWCiwcEtDd/XZcaD+f357ytFhsOV06avw5+Y27n4Ah+ja71Gl0bjF21KTi72eZnsTcZKbDqX3B4pflx52eh+2vaLkNExEbsOghdDyDR0dE5BjdHR0dzxx13FMtrurm54ebmRkhICCEhIWRlZRXL65Q47j5Q53bz13VJl+H8tbWNrs9YSzgPF4+Yv/YtMLdzdIGqTXKON/JrBE52/dev6CVehMVD4dwucHSGXh9DqxG2rkpEpEyz60+iFi1aUKFCBX766SdatmwJmAdWHzx4kMmTJxfra0+YMIEJEyZkD7aSXHhVgvp3m7+uiz9/4zT+lCvmdY/O7wNmmds5e5hvo/1965CK9Upvz8iFw+aZYXER4F4eBi/IGSpFRMQmbBqEEhISuHDhAtHR0QCcO3cue1p8xYoVcXFx4dVXX+X1118nMDCQwMBA/v3vf9OiRQv69Oljy9LFEh9/89f16d+GYb6F9s9p/OkJELHD/HWdmy9Ub5FzAUjfgJI/jf/4evjmEfPPXLEeDFsGlevbuioREcHG0+dXrFjBSy+9dMPxp59+mqeffjr78RdffMG8efNISEigc+fOvPHGG/j5Fe9U7r/fGgsLCysd0+fthclk3kMtxzT+A5CZemNbz8p/Lfx4/daad1Xr13yzdnwJP/7bvJlurS4weD54VrR1VSIipV6JWFm6JChV6wjZs6wMuHT0H9P4D4Mp88a23tVzroxdvZX9hYusTHMACp1hftxyBPScrr3fRESsREGoiCgI2VBGKlw49Ldp/HvNYYlc/spWqPO3XqNW5uUA3LytXjJgnmG3/BE4Yd7ol7tfN88OK+m3+EREShAFoVukW2N2Ki3x2jT+vw3Ivno6l4YO4Ncw53ijqk3Bxb1467sabh4UfelP84Dw/l9BcO/ifU0REbmBglARUY9QCZB8bVba3wdkx5+7sZ2jM1QJzrkAZJXGRbe7e0QoLBkKSZegXDUYutj8WiIiYnUKQkVEQaiESrjwj2n8eyD58o3tnN2hWrOcG85WalD4afwHl8OqJ8z7tlVrBkOXmjfBFRERm1AQKiIKQqWEYZjX8MnuNdpjnsaflstecq7lzHt/XV8Zu3prqFA79zE+hgGb3jVvmQEQdL9593i3csX4w4iISH4UhG6RxgiVASYTXDmVcxr/+f2QmXJjW48KOccbVW8FHhVhzVNwcJm5Tacn4Z6p5s1tRUTEphSEioh6hMqYrEyIOZZzGn/0ITBl3NjWxRMyksHBCR78ANo+Yv16RUQkVwX9/LbrLTZErM7J2bwvWtUm0Hqk+VhmmnlNo6g9f+2rdulPcwhy84VBc6HenbatW0REboqCkEh+nN3Mt8NqtIZ2146lJ8HFo1Cprvm2mYiIlEgKQiI3w9ULaraxdRUiInKLSulW37cuJCSE4OBg2rVrl39jERERKZE0WDofGiwtIiJS8hT081s9QiIiIlJmKQiJiIhImaUgJCIiImWWgpAFGiwtIiJS+mmwdD40WFpERKTk0WBpERERkXwoCImIiEiZpSAkIiIiZZaCkIiIiJRZCkIiIiJSZikIiYiISJml3ectCAkJISQkhMzMTMA8DU9ERERKhuuf2/mtEqR1hPIRGRlJQECArcsQERGRmxAREUHNmjUtPq8glA+TyURUVBTe3t44ODhkH2/Xrh2hoaE3tC/o8fj4eAICAoiIiLD5Qo2Warb29QpzXkHa5tXmZp7Te1i051n7PcztWGl9D0vC+5fX8/od1HtYFAzDICEhgerVq+PoaHkkkG6N5cPR0THXJOnk5JTrm1bY4z4+Pjb/BbZUm7WvV5jzCtI2rzY385zew6I9z9rvYV7tS9t7WBLev7ye1++g3sOi4uvrm28bDZa+SRMmTCiS4/agqGu72esV5ryCtM2rzc08p/ewaM+z9ntoz+8fFG19JeH9y+t5/Q7qPbQm3RqzEe1hVvLpPSz59B6WbHr/Sj57eA/VI2Qjbm5uvPbaa7i5udm6FLlJeg9LPr2HJZvev5LPHt5D9QiJiIhImaUeIRERESmzFIRERESkzFIQEikG58+f58SJE5w4ccLWpYiIlGgZGRmcOHGCjIyMYrm+gpAdSkhIYODAgZQrV46WLVty6NAhW5ckhfTqq6/So0cPgoKCsrdpkZIjNTWVF198kYoVK1KlShWmTZtm65KkkBISEhg3bhze3t7UqVOHZcuW2bokuUkvvfQSrVq1Ijw8vFiuryBkhz744AOcnZ2Jjo7m6aefZsyYMbYuSQpp1qxZnDhxAk9PT1uXIjdhy5Yt+Pv7c/LkSX777Tfef/99/vzzT1uXJYWwadMmunXrxsWLF1m4cCFjx47FZDLZuiwppFWrVlGjRg1q1KhRbK+hlaWLye7du7l06RL33Xdfjq05rktNTWX37t04OzvTunVrXFxcsp9bv3497733HuXKleORRx7h5ZdfJjY2lvLly1vxJyjbYmJiWLt2LZUqVaJ37965ttmzZw8HDhygSpUqdO/eXVN47czly5fZtWsXQUFB1KlTJ9c2x48fJzIykoYNG1K9evXs4927d6d79+6AeWXaSpUqFWiFWilaYWFhnDp1ittuuy3XNWaysrLYu3cvKSkptG7dGi8vr+znevbsiWEYZGRkkJWVRZUqVfLcZkGKXlJSEmvWrCE9PZ3Ro0fn2ubUqVP88ccfeHl5cffdd+f4PYuIiGD16tXMmjWLmTNnFl+hhhSpefPmGc2bNzeqVatmAEZGRsYNbTZt2mT4+fkZjRo1MurUqWMEBgYa+/bty34+KCjICAsLy37cuHFj4/jx41apv6xLSUkxhg8fblSvXt2oXbu20bVr11zbTZgwwfD19TUeeugho2HDhkZwcLARHR19QzsvL69c/w5I8Tl9+rQxatQow9/f33BzczOmTZt2Q5u0tDSjX79+hre3t9G+fXvD3d3dmDRp0g3tTCaT8dRTTxnvvfeeNUqXa3799VfjrrvuMvz9/Q3ACA0NvaHNiRMnjKCgIKNmzZpG06ZNDV9fX2Pt2rU52nz77beGo6Oj4ebmZixZssRa5YthGC+99JLh7+9vNG7c2KhUqVKubT7//HPDw8PD6NWrl9GhQwejcuXKxp49ewzDMIzMzEyjT58+xs6dO43jx48bdevWNTZs2GCkpaUVea0KQkXs/fffN/bu3WssXrw41yCUnJxsVKtWzXjmmWcMwzD/Qztw4ECjcePGhslkMgzDMDp37mxs3rw5+/lKlSoZsbGxVv05yqrExERj/vz5RmpqqjFmzJhcg9APP/xgODg4GLt27TIMw/yeNm3a1Hj44YdvaKsgZH1//PGHMWfOHCM5OdmoUaNGrkFo6tSpRtWqVY2IiAjDMAxjy5YthpOTk/Hdd99lt0lPTzdGjRplTJ8+3VqlyzVz5swx1q9fbxw5csRiELrtttuM++67z8jMzDQMwzBef/11w8fHx7h8+XKOdiaTyTh8+LBRs2ZNIyoqyir1i/k9vHr1qjF9+vRcg1B4eLjh6upqzJo1K/vYgAEDjJYtW2Y/X69evewvFxcXIzAwMEcnQVFREComloLQypUrDQcHB+PcuXPZx3bv3m0Axvbt2w3DMIwpU6YYAwYMMC5dumSEhIQYHTt2tGrtYmYpCI0ePdro1KlTjmPTp083vLy8sv9RvnTpknH8+HHD09PTOHr0qHHhwgVrlCz/YCkI1atXz3j++edzHLvzzjuNhx56yDAMw4iLizPuvfdeY8aMGUZGRoaRkZGR/T8qYj1//vlnrkHo+PHjBmCsX78++1hcXJzh5uZmzJw50zAMw/jwww+N3377zUhMTDR27txpVK5c2YiMjLRq/WJYDELTp083fH19jfT09OxjGzduNADj6NGjN7Rv2LBhsd0Z0Q1TK9u3bx9Vq1bNMR6hZcuWODo6sn//fgAmTpyIq6srDRs2ZO7cucyaNctW5UouDh8+THBwcI5jwcHBJCUlZc9qCAkJoUePHvj7+/Pggw/ywQcf2KJUyUViYiInT56kVatWOY63atUq+3fwxx9/ZMOGDTz++OO4u7vj7u7O+vXrbVGu5GLfvn0AOd5DHx8f6tWrl/0eDhgwgHfeeQd/f38efvhhPvzww2IdcCuFc/jwYerXr59jfOz1f1cPHz58Q/tatWrh6upaLLVosLSVxcbGUrFixRzHHB0d8fX15erVqwCUK1eORYsW2aI8KYD4+PgbBq5XqFAh+zmA1157jddee83apUkBxMbGAtzwe1ipUqXs38FBgwYxaNAga5cmBXT9Pbz+e3fd39/DwMBAvv/+e2uXJgVUkH9H/+6nn34qtlrUI2Rlrq6upKSk3HA8JSWl2NKuFC0PDw8SEhJyHLv+i6vp8vbv+u/ZP38Pk5OT9TtYQlx/n1JTU3Mc13tYctjTv6MKQlZWu3ZtLly4kGOFzJiYGFJTU6ldu7btCpMCa9CgAadPn85x7PTp0zg7O1OrVi0bVSUF5efnh5eXFxERETmOR0ZG6newhLj+Pv3zPTx37pzewxKiQYMGhIeHY/xt3/fr/67Wr1/fqrUoCFnZvffeS0pKCj///HP2sW+//RY3Nze6detmu8KkwHr37s2mTZuIiooCwDAMFi1axH333ae1hEoABwcH7r33XlatWpV9LDU1le+//54ePXrYrjApsA4dOlC+fPkc7+GWLVuIjo7We1hC9OrViwsXLrBhw4bsYwsWLCAgIICWLVtatRaNESpihw8fJiIiInvA3s8//4yjoyPt2rWjUqVK1K9fn3/961+MGTOGKVOmkJqayn/+8x9effXVG+53i20sXLiQhIQEjh49ysWLF/niiy8AePzxxwEYNmwYs2bN4q677mLkyJHs3LmTPXv2sGXLFluWLdckJSWxefNmANLS0ggLC+PHH3/Ez8+PNm3aADBlyhQ6derEmDFjuPvuu5k9ezaenp48+eSTtixdrjl79ixHjhwhMjISgG3bthETE0OjRo2oXbs2bm5uvPXWWzz33HM4ODhQuXJlpk6dyqBBg2jXrp2NqxeAH374gfDwcLZu3Upqamr2v6ODBw+mQoUKNG/enCeffJKhQ4fyxBNPcOHCBb7++muWL19u9YUvHYy/90vJLfvoo4/48ccfbzj+9ttvZ6dck8nErFmz+PHHH3F2dqZv374MGTLEypWKJa+++iqXL1++4fj1X2QwbwI4f/589u/fT5UqVRg1ahQBAQHWLFMsiIyMZOzYsTccb9u2Lf/73/+yHx85coTPPvuMc+fO0ahRIyZOnEjVqlWtWapYsHbtWkJCQm44Pm7cOAYMGJCj3ZIlS0hJSeHOO+/k8ccfzzELSWzn//7v/zhw4MANxydPnpxj1vTq1avZtGkTnp6eDBo0iObNm1uzTEBBSERERMowjRESERGRMktBSERERMosBSEREREpsxSEREREpMxSEBIREZEyS0FIREREyiwFIRERESmzFIRExOqOHTtWrLtJF1RWVhabN29m2bJlhIWF2bocEbEBbbEhIsXi4MGDnDlzhqpVq9KiRYsc+7CtXbuWBQsWcN9999msPsMwuPvuu7lw4QLNmzfH29uboKAgm9UjIrahICQiRerixYv07t2b06dP065dO65evUpUVBT//e9/efTRRwFo1KiRzTfHDAsL47fffiMqKgp/f3+b1iIitqMgJCJF6qWXXiIlJYUzZ87g4eEBQExMDL/88kt2mwYNGuTYE2rJkiU3XMfR0ZFBgwZlPz5x4gSHDh2iatWqtG7dOkcPkyW7d+8mPDycgICAHJtxhoWFZb/mL7/8gouLC3379sXd3T3H+eHh4Wzbtg0ALy8vgoODqVevXo42hw4d4sKFC3Tp0oWtW7cSExPDwIED+fXXX/Hz86N69ers2LEDT09PunXrRmhoKCdPngSgcuXKtGjRAj8/v+zrHThwgOjoaO69994cr7Nv3z4uXbrEPffck+/PLSIFpyAkIkXq0KFDdOrUKTsEgfkD/+8bC//z1tiqVatyXGPPnj2Eh4czaNAgMjMzGTt2LN9//z0dOnQgMjKSpKQkVq9eTePGjXOtITk5md69e3PgwAHatm3Lnj17aNSoEWvXrsXb25uTJ09m71C/du1aHB0duf/++28IQhEREdm1JSQksHnzZkaPHs2nn36a3Wb58uXMnz8fLy8v/Pz8qFatGgMHDmTq1KlkZmZy7tw5mjRpQqdOnejWrRt79+7l119/BSA6Oprdu3fz+eefM2LECMDco9arVy/OnTtH5cqVs1/nkUce4d5771UQEilqhohIEZowYYJRvnx5Y/bs2caFCxdybfPee+8ZLVq0yPW5gwcPGuXKlTPeffddwzAM46233jJatmxpxMfHZ7d59tlnjc6dO1us4fXXXzcCAwOzX//SpUtG7dq1jUmTJmW32bx5swEYKSkpBf7ZwsPDDV9fX+O3337LPvbaa68ZgLF27docbbt27WqUL1/eiIiIyPOaq1evNnx8fLJ/PpPJZNStW9eYPn16dpu9e/cagHH06NEC1yoiBaNZYyJSpN5++21GjhzJxIkTqVq1KnXr1uXJJ58kOjo633OvXLlCnz596NOnDy+++CIAs2fPpkWLFvz000988803LFu2jEqVKrFt2zZSU1Nzvc6SJUsYO3YsVapUAcw9Uo8//niut+Dyk5qaypYtW1i+fDlbt26levXq7Ny5M0ebOnXq0LNnzxvO7devHzVr1rzheExMDL/++ivLli0jMTGRxMREjh49CoCDgwOPPvoos2fPzm7/9ddf07lzZxo2bFjo+kUkb7o1JiJFqly5cnzyySdMnz6dgwcP8vvvv/P++++zbt06Dh48SLly5XI9LzMzk0GDBlGxYkVmzpyZffzMmTNUrlyZ5cuX52g/cOBAkpOTb7idBeaxPXXr1s1xrF69epw9exbDMHBwcCjQz7Jlyxb69+9P5cqVqVevHp6enly9epWLFy/maGdpsHVuxz/99FMmTZpE8+bN8ff3zx4r9fdrPvLII7z22mvs2rWLZs2asWjRIt57770C1SwihaMgJCLFwsnJiZYtW9KyZUs6dOhAx44d2bp16w2DgK97/vnnOXz4MLt27coRbnx8fOjbty8vvfRSgV+7cuXKXLlyJcexK1euUKlSpQKHIIAXX3yRESNG8MEHH2Qfa9u2LYZh5Ghn6Zr/PJ6cnMxzzz3HypUr6dWrFwCJiYksXbo0xzWrV6/OAw88wKxZs+jatSvp6ek5Bo6LSNHRrTERKVKnT5++4dj1W1jly5fP9ZzZs2fz5ZdfsnLlSmrUqJHjuR49ejBr1izS09NzHD937pzFGrp06cKKFStyHFu+fDldunQpyI+QLTo6OsftqOPHj3PgwIFCXePvYmJiyMrKynHNf/Z0XTd27FgWL17M559/zqBBgyz2pInIrVGPkIgUqZdffpmLFy/SvXt3AgMDCQ8P5/PPP6dHjx60adPmhvbnz5/nX//6Fw888ABnzpzhzJkzwF/T59955x1uv/12OnTowOjRo3F2duaPP/4gJSWF1atX51rDG2+8Qbt27RgwYAA9evRg/fr17Nixgx07dhTqZ+nbty9TpkwhLS2NjIwMpk+fjqenZ6H/TK4LCAigdevWjB49mrFjx3LixAm+/vprHB1v/H/SBx98EE9PTzZt2sSbb755068pInlTEBKRIrVs2TK2bNnCzz//zMaNG6lcuTL/93//R+/evXFycgJyLqhoGAZ9+/YFck6jd3JyYtCgQdSoUYP9+/czb948du/ejbe3NwMGDGDAgAEWa6hXrx779u1jxowZbN68mQYNGvDOO+9Qp06d7DZ+fn4MHjw4u6bcvPvuuzRs2JAdO3bg5eXF/Pnz2b59OwEBAdltmjZtmuu5d911F40aNcpxzMHBgfXr1/PZZ5+xadMmatSowdatW5k6deoNPWFOTk707NmTTZs20blzZ4s1isitcTD+ebNbRERszmQyUa9ePSZMmMALL7xg63JESi31CImI2JlVq1axbt06kpOTGT9+vK3LESnVNFhaRMTO/Pjjjzg5OfHzzz/j4+Nj63JESjXdGhMREZEySz1CIiIiUmYpCImIiEiZpSAkIiIiZZaCkIiIiJRZCkIiIiJSZikIiYiISJmlICQiIiJlloKQiIiIlFkKQiIiIlJm/T+gFlSE2tCPJgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()\n", - "plt.loglog(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b6S8vzFipT5w" - }, - "source": [ - "# Part 2: Patch Predictions As Annotations\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from shapely.geometry import Polygon\n", - "from tqdm.auto import tqdm\n", - "\n", - "from tiatoolbox.annotation.storage import Annotation\n", - "\n", - "\n", - "def py_patch_predictions_as_annotations(\n", - " preds: list | np.ndarray,\n", - " keys: list,\n", - " class_dict: dict,\n", - " class_probs: list | np.ndarray,\n", - " patch_coords: list | np.ndarray,\n", - " classes_predicted: list,\n", - " labels: list,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> list:\n", - " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", - " annotations = []\n", - " tqdm_loop = tqdm(\n", - " patch_coords,\n", - " leave=False,\n", - " desc=\"Converting outputs to AnnotationStore.\",\n", - " disable=not verbose,\n", - " )\n", - "\n", - " for i, _ in enumerate(tqdm_loop):\n", - " if \"probabilities\" in keys:\n", - " props = {\n", - " f\"prob_{class_dict[j]}\": class_probs[i][j] for j in classes_predicted\n", - " }\n", - " else:\n", - " props = {}\n", - " if \"labels\" in keys:\n", - " props[\"label\"] = class_dict[labels[i]]\n", - " if len(preds) > 0:\n", - " props[\"type\"] = class_dict[preds[i]]\n", - " annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props))\n", - "\n", - " return annotations" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def rust_patch_predictions_as_annotations(\n", - " preds: list | np.ndarray,\n", - " keys: list,\n", - " class_dict: dict,\n", - " class_probs: list | np.ndarray,\n", - " patch_coords: list | np.ndarray,\n", - " classes_predicted: list,\n", - " labels: list,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> list:\n", - " \"\"\"Helper function to generate annotation per patch predictions.\"\"\"\n", - " tqdm(\n", - " patch_coords,\n", - " leave=False,\n", - " desc=\"Converting outputs to AnnotationStore.\",\n", - " disable=not verbose,\n", - " )\n", - " if len(class_probs) == 0:\n", - " class_probs = np.empty((0, 2))\n", - " if len(patch_coords) == 0:\n", - " patch_coords = np.empty((0, 2))\n", - " return rust_misc.patch_predictions_as_annotations(\n", - " Annotation,\n", - " Polygon,\n", - " preds,\n", - " \"labels\" in keys,\n", - " \"probabilities\" in keys,\n", - " class_dict,\n", - " np.array(class_probs).astype(\"float\"),\n", - " np.array(patch_coords).astype(\"float\"),\n", - " classes_predicted,\n", - " labels,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "sizeofarray = []\n", - "timings = []\n", - "timings = []\n", - "num_patches = 1\n", - "num_classes = 1\n", - "max_patches = 1000\n", - "while num_patches <= max_patches:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for _j in range(10):\n", - " rng = np.random.default_rng(42)\n", - " class_probs = rng.random(\n", - " (num_patches, num_classes),\n", - " dtype=np.float64,\n", - " )\n", - " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", - " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", - " labels = (\n", - " rng.integers(0, num_classes, size=num_patches).astype(np.int32).tolist()\n", - " )\n", - " x = np.arange(num_patches, dtype=np.float64) * 10\n", - " y = np.zeros(num_patches, dtype=np.float64)\n", - " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", - " keys = [\"predictions\", \"probabilities\", \"labels\"]\n", - " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", - " classes_predicted = list(range(num_classes))\n", - " verbose: bool = False\n", - " start_time = time.time()\n", - " py_patch_predictions_as_annotations(\n", - " preds,\n", - " keys,\n", - " class_dict,\n", - " class_probs,\n", - " patch_coords,\n", - " classes_predicted,\n", - " labels,\n", - " verbose=False,\n", - " )\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_patch_predictions_as_annotations(\n", - " preds,\n", - " keys,\n", - " class_dict,\n", - " class_probs,\n", - " patch_coords,\n", - " classes_predicted,\n", - " labels,\n", - " verbose=False,\n", - " )\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " sizeofarray.append(num_patches)\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " num_patches *= 10\n", - " num_classes *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGzCAYAAADDgXghAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAa9dJREFUeJzt3Xd4k2X7xvFv96ALWiijZZS9y54KiiIqAjJElshwwutAnD+3vi70dVFxskH2coMbAdm77LLKaGnp3k2e3x+BYm1SCrRJx/k5Dg+TPHeSqxKbk+e+n/tyMgzDQERERKQCcnZ0ASIiIiKOoiAkIiIiFZaCkIiIiFRYCkIiIiJSYSkIiYiISIWlICQiIiIVloKQiIiIVFiuji6gtDObzZw+fRpfX1+cnJwcXY6IiIgUgWEYpKSkULNmTZydbZ/3URC6jNOnTxMaGuroMkREROQqnDx5kpCQEJvHFYQuw9fXF7D8h/Tz83NwNSIiIlIUycnJhIaG5n2P26IgdBkXp8P8/PwUhERERMqYyy1r0WJpERERqbAUhERERKTCUhASERGRCktrhIqB2WwmOzvb0WVUSG5ubri4uDi6DBERKaMUhGyIiIggIiICk8lU6Ljs7GyOHj2K2Wy2U2XybwEBAVSvXl37PImIyBVzMgzDcHQRpVlycjL+/v4kJSUVuGrMMAxOnDhBTk7OZTdskuJnGAbp6enExsYSEBBAjRo1HF2SiIiUEoV9f/+Tzghdg9zcXNLT06lZsybe3t6OLqdC8vLyAiA2NpZq1appmkxERK6ITmFcg4vTZu7u7g6upGK7GEJzcnIcXImIiJQ1CkLFQGtTHEv//UVE5GopCEmxyMzM1JVzIiJS5igIVUBZWVmkpqaSmppKZmbmFT/fWujp27cvL774YnGVKCIiYhcKQhXQAw88gL+/P9WrVycgIIBq1aoxYcIEUlJSivT8wYMH89RTT5VwlSIiIiVPQaiCuu666/LOCH377bcsXLiQyZMnk52dTUZGRoHxOTk5pKenk5WVhclkIicnJ++s0r93YDAMo8Bj1l7Pmn+ebSrK64iISNmVnWsmM6fw/fpKmoKQ0LFjR0aNGsX333/PwoULCQkJISsrK9+YoUOHcu+99/Loo4+yZs0avvjiC6pXr0716tU5dOgQAGfOnOHOO++kcuXK+Pj4MHbs2HyBJyMjg4ceeghfX188PT1p2rQp3377bb736du3L/fdd1+hryMiImWf2WwwadEOxszYTEqm437HKwgVI8MwSM/Odcg/13rmJCcnB1dXVwYPHozZbGbFihV5x86dO8e3337LuHHj+PTTT+nTpw8PP/xw3hmhRo0aATB//nxGjBhBXFwcmzdvZsWKFUyfPj3vdZ555hlWr17Nhg0bSE9PZ9y4cQwcODAvSF10udcREZGyzTAMXvlmL9/uOsOW4+fZd6ZoSzNKgjZULEYZOSaavfiTQ9478tVb8HYv+h+nyWQiNTWV3Nxc1q1bx+zZsxk/fjxeXl4MHz6c6dOnM3ToUADmzJlD9erVufnmmwt9zTvvvJPBgwcD0KxZM26//XY2bNjAAw88QEZGBtOmTWPWrFm0aNECgMmTJ7Nw4UI++ugjPv744yK9joiIlH0f/3qYWRuO4+QE790VTsd6VRxWi4JQBbV+/XqqV6+Om5sbISEhPP744zz77LMA3HfffbRr146TJ08SGhrKjBkzGD169GVbiNSrVy/ffX9/f6KjowGIiooiJyeH9u3b5xvToUMH9u/fX+TXERGRsm3exuP8b81BAF7q24x+rWs6tB4FoWLk5eZC5Ku3OOy9r8R1113H77//bvVYeHg4bdq0YebMmdxyyy3s3buXlStXXvY1C9vY8GKI+ncTW5PJVKAthjZIFBEpn77ffYbnV+wB4JEbG3Bvt3qXeUbJUxAqRk5OTlc0PVWajR8/nilTphAdHU2PHj0ICwvLO+bu7l4g0FxOWFgYXl5ebNiwgSZNmuQ9vmHDBnr37l1sdYuISOm0/nAcjy3YgWHA8E61efzmRo4uCdBiabFh+PDhxMTE8NVXXzFu3Lh8x+rVq8eWLVs4e/as1cvnrfHw8GDy5Mk8//zz/Prrr0RHR/P0009z5MgRHnvssRL6KUREpDTYHZ3EfbO3kG0yc2uL6rzWv0WpOftfPk5flICIiAgiIiKu+MxHWeDp6ZnXtd0WPz8/Bg0axMqVKxk0aFC+Y4899hh79+6ldevWpKWlsW3bNry8vPDw8Mg3zsPDI9/7vPTSSzg7O3P//feTkJBAq1at+PnnnwkJCckbU5TXERGRsuNoXBr3zthEWraJrvUD+eDucFycS0cIAnAytGNdoZKTk/H39ycpKQk/P798xzIzMzl69Cj16tXD09PTQRWWnBtuuIEmTZowbdo0R5dSqPL+5yAiUlbFJGcyaNp6ohMyaFHLj6/v64yvp5td3ruw7+9/0hkhKSAtLY1ffvmFtWvXlvoQJCIipVNSeg73fLWJ6IQM6gZ6M3NMR7uFoCuhICQFtG3bltTUVD788MN8C5tFRESKIiPbxLhZmzkQk0I1Xw/mjOtEkI/H5Z/oAApCUsCBAwccXYKIiJRROSYzE+dvY8vxBPw8XZk9riOhVbwdXZZNumpMREREioVhGDyzdDe/7I/Fw9WZr+7tQJPqttfnkBQN8UfsV6AVCkIiIiJSLN76YT9Lt0Xj4uxExPC2dKhbSOuMtDiYPQCm3wJn99itxn9TEBIREZFr9tkfR/jszygA3h7UipuaBdsenJkMcwdB/CFw8QCvAPsUaYWCkIiIiFyTxVtO8uYPlr6Rz93WhMHtQmwPzsmEBcPhzA7wDoJ7VoB/IeNLmIKQiIiIXLWfI2N4ZtluAB64Poz7r69ve7ApF5aMhWNrwd0XRi6FoIZ2qtQ6BSERERG5KpuPnWfC/G2YzAaD24XwzK2FbLliNsM3j8CB7yzTYcMXQM1wu9Vqi4KQiIiIXLF9Z5IZO3MzWblmejWpxlsDW9ruH2YYsOYF2DEPnFxgyEyo292u9dqiIFQBvfHGG3Tv3p3u3btzww03MGrUKJYtW1as7/H7779z6623FutriohI6XDyfDqjp28iJTOXDnUrM3V4W1xdCokUa9+DDVMtt/tHQJPb7FNoEWhDxQro4MGDpKWl8fHHH5Obm8vff//N3XffzVtvvcWkSZOK5T3i4uLYsGFDsbyWiIiUHnGpWYz6aiOxKVk0qe7Ll/d0wMvdxfYTNn8Fv75muX3LmxA+zD6FFpHOCFVQ/v7+dO/enZ49e/LMM88wYsQIvvjii7zjixcv5p577sn3nI0bN9KzZ8+8+zk5OXz00UcMGDCAAQMG5AWr7du388ILL5Campp35unTTz+1148mIiIlJCUzh3tnbOJYfDohlb2YNbYj/t6F9A/bsxS+e8Jy+/onocvD9in0CuiMUHEyDMhJd8x7u3mDrbnZIggODiY2Njbv/qlTp9i2bVu+MQkJCfz1119591988UWWLVvGq6++io+PD7/88gsvv/wyTz75JCNGjODtt9/mrbfeAiA0NPSqaxMREcfLzDFx/+yt7DmVTGAld+aM60Swn6ftJxz+GZY9ABjQYTzc8H92q/VKKAgVp5x0eKOmY977udPgXumqnpqUlMSqVavo1q3bFT1v7dq1jB8/nqFDhwJw++23k56ejre3N02aNMHFxYXu3UvHYjgREbl6JrPB4wt3sCEqHh8PV2aN7Ui9oEK+c05shIWjwJwDLQbBrVOu6S/rJUlBqILavn073bt3Jzc3l/3799O2bdt8U2NF0aNHDz744APc3d3p3bs3TZs2xdu79DbWExGRK2cYBi+s3MMPe87i7uLM56Pa0aKWv+0nnN0D84dYTg40uAkGfArOpXcljoJQcXLztpyZcdR7X4GwsDDeeustsrKyWLZsGfPnz+fMmTMEBxeyJfq/vP7667Rq1Yrly5fz5ptvUqlSJT799FNuvvnmK61eRERKqffXHGT+xhM4OcGHd4fTtUGQ7cHno2DuQMhMgtBOcNcccHW3X7FXQUGoODk5XfX0lL1dXCwN0KtXL86dO8c999zD9u3bcXFxwdvbm4yMjHzPiYmJyXffycmJoUOHMnToUMxmM0888QTjx4/n+PHjOJfi9C8iIkUzc91RPvr1MACvD2jBrS1r2B6cchbm3AmpMVCtOQxfCO6lf5ag3H9bZWZm8vLLL/Pyyy+zaNEiR5dTak2ZMoWDBw8ya9YsAFq2bMmxY8fYuXMnAImJiXz88cf5nvPuu+8SFxcHgLOzM5UrV8bFxXIJZbVq1UhJSSElJcWOP4WIiBSXlTtO8fI3kQA8cXMjRnSqY3twRoIlBCUcg8p1YdQy8KpslzqvVbkPQhcdPHhQQagQderU4eGHH+bFF18kIyODLl26MG7cOLp06ULbtm1p3rw5zZs3z/ccPz8/WrVqRfPmzWnSpAmffvpp3mXynTt3pl27djRp0kSXz4uIlDF/HDzHE4ssfxG+t2tdJt7YwPbg7DSYdxfERoJPdRi1Anyr26fQYuBkGIbh6CLs4dtvv2XmzJksWbLkip6XnJyMv78/SUlJ+Pn55TuWmZnJ0aNHqVevHp6ehVxCWMocOnSIzMxMWrZsme/xlJQUdu7cScuWLfH3tyyEi46O5vz58zRu3JiMjAz27t2b7+oyk8nE/v37cXZ2pkGDBri5XdpPwmw2c+jQIeLi4ggJCaFOnUL+NnENyuqfg4hIabT9RAIjvtxIeraJO1rX5MOh4Tg727jiKzcbvr4bjvwCnv4w5gcIbm59rJ0V9v39Tw5fI7RlyxY+/fRT9u/fz8cff0ybNm0KjFmxYgVz5swhJSWFbt26MXnyZCpVsqzFOXHiBNOnT7f62i+++KLWqljRsKH1Tr++vr4FLncPCQkhJCQEAA8PjwKX2Lu4uBQ4U3SRs7MzjRs3pnHjxsVQtYiIlLTDsSmMnbmZ9GwT1zUM4r0hrW2HILMJlj9gCUFu3jBiSakJQVfCoSnhxRdf5MEHHyQsLIx169aRlJRUYMz06dMZOnQo3bp144EHHmDp0qXcfvvtVJATWSIiInZxOjGDe77aREJ6Dq1DA/h0ZDvcXW3EBMOA7yfD3mXg7AZD50BoR/sWXEwcekbo8ccf59VXXyU6Opr/+7+CO06aTCaee+45nn766bweWC1btqRx48b88MMP3HbbbdSuXZuXX37ZzpWLiIiUHwlp2dwzfROnkzIJq1qJGfd2oJJHIRHh19dhy3TACQZ+btkvqIxy6BmhypULX1G+e/duYmJi6NevX95jjRo1omnTpqxZs6bI7/POO+8wf/58IiMjefnllzl8+LDNsVlZWSQnJ+f7R0REpLxKz85l7KzNHI5NpbqfJ3PGdaJKpUL2/tkQAWvftdzu+z60GGifQktIqV5Ac/z4cQBq1aqV7/FatWpx4sSJK3qtRo0acdddd1123Jtvvom/v3/eP+qRJSIi5VWOycxDc7ex/UQi/l5uzBnXkVoBXrafsGM+/PSc5XavF6H9GPsUWoIcvli6MDk5OQAFrgTy8vIiOzu7yK/z1FNPFXnss88+mzcNB5ZV55cLQ1qv5Fj67y8icuXMZoMnF+/kj4Pn8HJzYfq9HWgY7Gv7Cfu/g5UTLbe7TITuk2yPLUNKdRCqUqUKAPHx8fmm0eLj42nQoJA9Da6Bh4cHHh4eRRp7cfPA7OxsvLwKSdBSotLT0wHyXbovIiK2GYbBa99FsmLHaVydnfhkZFva1SlkucrRtbB4DBgmCB8JvV8vtU1Ur1SpDkKtWrXC2dmZrVu35gWfrKwsdu/ezZAhQxxcHbi6uuLt7c25c+dwc3PTpfp2ZhgG6enpxMbGEhAQkBdMRUSkcJ/8foQZ644B8O6Q1tzQuJrtwae3w9fDwJQFTfrCHR+WmxAEpTwIBQUF0a9fP959913uuOMOvL29ef/99zGZTAwdOrRE3zsiIoKIiAhMJpPNMU5OTtSoUYOjR4/mrWcS+wsICKB69bKzi6mIiCMt2HSCKT8dAODFvs0Y0KaW7cHnDsLcQZCdAvWuh0FfgUupjg5XzKE7S//www/897//JTs7m82bN9OiRQv8/f0ZO3YsY8eOBSA2NpZ+/fpx4MABgoKCiIuLY+bMmfTv398uNRZlZ0qz2XxFa5ak+Li5uelMkIhIEf245ywPz9uK2YAJN9TnyVua2B6ceBKm94HkaKjZBkZ/Ax6FrCEqZYq6s7RDg1BsbCwHDx4s8Hjt2rWpXbt2vscOHjxISkoKzZs3t2sbhaL+hxQRESnNNhyJZ/SMTWTnmrm7QyhvDmyJk60prrQ4SwiKPwRBjWDMj1Ap0L4FX6My0WKjWrVqVKtWyLzkPzRq1KiEqxERESmf9pxK4r7ZW8jONXNL82BeH9DCdgjKTLZMh8UfAr8QGLW8zIWgK6HVvSIiIuXYsbg07p2xidSsXDrVq8KHd7fB1cXG139OJiwYDmd2gHcQ3LMC/EPsWa7dKQjZEBERQbNmzejQoYOjSxEREbkqscmZ3DN9E3Gp2TSr4ccXo9vj6WZjXaUpF5aMhWNrwd0XRi6FIOtNussTh64RKgu0RkhERMqipIwc7v78b/adSaZOoDdLHuxKVV8b++SZzbByAuycDy4eMGoZ1O1u34KLWVG/v3VGSEREpJzJzDFx3+wt7DuTTFVfD+aM7WQ7BBkGrH7eEoKcXGDIzDIfgq6EgpCIiEg5kmsy85+vt7Pp6Hl8PVyZNaYjtQO9bT9h7bvwd4Tldv8IaHKbfQotJRSEREREygnDMHhu+W7WRMbg7urMl6Pb06xmIcs6Nn8Jv75uuX3LmxA+zD6FliIKQjZosbSIiJQ17/x0gEVbonF2gqnD2tAprJDL3ncvge8mW25f/yR0edg+RZYyWix9GVosLSIiZcGXa6N4/bt9ALwzqBV3dQi1PfjQz/D1UDDnQofxcNu75ap/GGixtIiISIWxbFt0Xgh6uk+TwkPQiY2wcKQlBLUYBLdOKXch6EooCImIiJRhv+6P4ckluwAY370eD/YIsz347B6YPwRyM6DBTTDgU3Cu2FGgYv/0IiIiZdjW4+d5eN42TGaDgW1q8dxtTW23zjgfBXMHQmYShHaCu+aAq7t9Cy6FFIRERETKoANnUxgzYzOZOWZuaFyVtwe3wtnZRghKOQtz7oTUGKjWHIYvBPdCLqmvQBSEbNBVYyIiUlpFJ6Rzz/SNJGfm0q5OZT4Z0Q43W/3DMhIsISjhGFSua9k12quyPcst1XTV2GXoqjERESlN4lOzGPLpBqLi0mgU7MOiB7oQ4G1jiis7DWYPgOhN4FMdxv4IVerZtV5H0VVjIiIi5UxqVi5jZm4mKi6NWgFezB7byXYIys2GhaMsIcgzAEYtrzAh6EooCImIiJQBWbkmHpizhV3RSVSp5M7scR2p7u9pfbDZBMsfgCO/gJs3jFgMwc3sW3AZoSAkIiJSypnMBpMW7mTd4Xi83V2YcW8H6lf1sT7YMOD7ybB3GTi7wdC5ENrRvgWXIQpCIiIipZhhGLy8ai/f7T6Dm4sTn41qR+vQANtP+PV12DIdcIKBn0ODXvYqtUxSEBIRESnFPvzlEHP+Po6TE7w/NJzrGla1PXhDhKWbPEDf96HFQPsUWYYpCNmgy+dFRMTR5mw4xgc/HwLg1X7N6duqpu3BO+bDT89Zbvd6EdqPsUOFZZ8un78MXT4vIiKO8O2u0/zn6+0YBjzaqyGP39zI9uD931muEDNM0GUi9H69QvcPA10+LyIiUmb9dSiOxxfuwDBgZOfaPHZTQ9uDj/4Ji8dYQlD4SIWgK6QgJCIiUorsik7kgTlbyDEZ3N6yBq/0a2G7f9ipbfD1MDBlQZO+cMeHCkFXSEFIRESklIg6l8q9MzaTlm2iW4NA/je0NS62+oedOwjzBkN2KtS7HgZ9BS6u9i24HFAQEhERKQXOJmUy6qtNnE/LpmUtfz4b1R4PVxfrgxNPwpwBkB4PNdvA3fPBzcbmilIoBSEREREHS0zP5p7pGzmVmEFYUCVmjumAj4eNsztpcZYmqsmnIKgRjFgKHr72LbgcURASERFxoIxsE+NmbeFgTCrBfh7MGtuRQB8P64Mzk2HuQIg/BH4hlv5hlQLtW3A5oyAkIiLiIDkmMxPmb2Pr8QT8PF2ZPbYToVW8bQzOhAXD4cxO8A6Ce1aAf4hd6y2PFIRs0IaKIiJSksxmg6eX7OLX/bF4ujkz/d4ONK5uY4rLlAtLxsCxteDuCyOXQlAhl9RLkWlDxcvQhooiIlLcDMPgv9/t48u/juLi7MQX97TjxibB1gebzbByAuycDy4eMGoZ1O1u34LLIG2oKCIiUkp99mcUX/51FIB3BrWyHYIMA1Y/bwlBTi4wZKZCUDFTEBIREbGjRZtP8tYP+wF4/vamDGpXyDqfte/C3xGW2/0joMltdqiwYlEQEhERsZM1kTE8s2wXAA/2qM/468JsD978Jfz6uuX2LW9C+DA7VFjxKAiJiIjYwcaoeCbO34bZgLvah/B0n8a2B+9eAt9Ntty+/kno8rB9iqyAFIRERERKWOTpZMbP3kJWrpmbmgbzxp0tbfcPO/QzLH8AMKDDeLjh/+xaa0WjICQiIlKCTsSnM3rGJlIyc+lYtwpTh7fB1cXG1++JjbBwJJhzocUguHWKmqiWMAUhERGREnIuJYtR0zdyLiWLJtV9+WJ0ezzdbPQPO7sH5g+B3AxocBMM+BSc9TVd0vRfWEREpAQkZ+YwevomjsenE1rFi9ljO+Lv5WZ98PkoS+uMzCQI7QR3zQFXd/sWXEEpCImIiBSzzBwT98/eQuSZZIJ83JkzthPV/Gx0h085a2mimhoDwS1g+EJwt9FmQ4qdgpANarEhIiJXw2Q2eHTBdv6OOo+Physzx3SkblAl64MzEiwhKOEYVK4HI5eBV2W71lvRqcXGZajFhoiIFJVhGDy3fDdfbzqJu4szs8Z2pEt9G93hs9Ng9gCI3gQ+1WHcT1C5rj3LLdfUYkNERMTO3lt9kK83ncTZCT4aFm47BOVmw8JRlhDkGQCjlisEOYiCkIiISDGY/tdRpv52GID/3tmSPi1qWB9oNsHy++HIL+DmDSMWQ3AzO1Yq/6QgJCIico1WbD/Fq99GAjC5dyOGdaxtfaBhwHdPwN7l4OwGQ+dCaEc7Vir/piAkIiJyDX4/EMvkxTsBuLdrXSbc0MD24F9fg60zACcY+Dk06GWfIsUmBSEREZGrtO1EAg/N3Uau2aBf65q82LeZ7dYZ66fC2vcst/u+Dy0G2q9QsUlBSERE5Cociklh7MzNZOSYuL5RVd4d0hpnZxshaPtcWH2hZ1ivF6H9GPsVKoVSEBIREblCpxIzuGf6JhLTcwgPDeDTkW1xd7XxlbrvW1j1H8vtLhOh+yT7FSqXpSAkIiJyBc6nZXPPVxs5k5RJg2o+zLi3A97urtYHH/0TlowBwwzhI6H362qiWsooCImIiBRRWlYuY2Zu5si5NGr4ezJ7bEcqV7LRE+zUNvh6GJiyoUlfuONDhaBSSEFIRESkCLJzzTw4dys7TyYS4O3GnHEdqRngZX3wuYMwbzBkp0K962HQV+Bi46yROJSCkIiIyGWYzQaTF+9k7aE4vNxcmHFvBxpU87U+OPEkzBkA6fFQsw3cPR/cbDRcFYdTEBIRESmEYRi8+m0kq3aextXZiU9HtaNNbRuNUdPiLE1Uk09BUCMYsRQ8bAQmKRUUhERERAoR8dthZq4/BsB7d7WmR6Oq1gdmJsPcgRB/CPxCLP3DKtnoNSalhoKQiIiIDfM3nuDd1QcBeOmOZvQPr2V9YE4mLBgOZ3aCdxDcswL8Q+xXqFw1BSEbIiIiaNasGR06dHB0KSIi4gA/7D7D8yt2A/CfGxswpls96wNNuZZL5I+tBXdfGLkUghrasVK5Fk6GYRiOLqI0S05Oxt/fn6SkJPz8/BxdjoiI2MH6I3HcO30z2SYzwzrW5o07W1hvnWE2w8oJsHM+uHjAqGVQt7v9C5YCivr9rTNCIiIi/7DnVBL3z95KtslMn+bVeX2AjRBkGLD6eUsIcnKBITMVgsogBSEREZELjsalMXr6JlKzcukSFsgHd4fjYqt/2Np34e8Iy+3+EdDkNvsVKsVGQUhERASISc5k1FcbiU/LpnlNPz6/px2ebi7WB2/+En593XL7ljchfJj9CpVipSAkIiIVXlJGDqOnbyI6IYO6gd7MHNMRX08364N3L4HvJltuX/8kdHnYfoVKsVMQEhGRCi0zx8T4WZvZfzaFqr4ezBnXiaq+HtYHH/oZlj8AGNBhPNzwf3atVYqfgpCIiFRYuSYzE+dvY/OxBHw9XZk9tiOhVbytDz7xNywcCeZcaDEIbp2iJqrlgIKQiIhUSIZh8Myy3fy8LxYPV2e+Gt2BpjVsXGZ9dg/MvwtyM6DBzTDgU3DWV2h5oD9FERGpkN76cT9Ltkbj4uxExPC2dKxXxfrA81GW/mGZSRDaGe6aDa7u9i1WSoyCkIiIVDif/3mEz/6IAuCtgS25qVmw9YHJZ2D2AEiLheAWMHwhuNuYOpMySUFIREQqlCVbo3nj+/0APHtrE4a0D7U+MP28pYlq4nGoXA9GLgOvAPsVKnahICQiIhXGL/tieHrpLgDuvz6MB3rUtz4wOw3mD4XYSPCpbmmi6mvjrJGUaQpCIiJSIWw+dp6H523DZDYY1DaEZ/o0sT4wN9tydVj0JvAMgFHLoXJde5YqdqQgJCIi5d7+s8mMm7mZrFwzvZpU461BLXG21jrDbILl98ORX8HNG0YshuBm9i9Y7EZBSEREyrWT59O556tNJGfm0r5OZaYOb4ubi5WvP8OA756AvcvB2Q2GzoXQjvYvWOxKQUhERMqtuNQs7pm+idiULBoH+/LV6A54udvoH/bra7B1BuAEAz+HBr3sWqs4hoKQiIiUSymZOdw7YxNH49KoFeDFrLEd8fe20T9s/VRY+57ldt/3ocVA+xUqDqUgJCIi5U5WrokH5mxlz6lkqlRyZ864jlT397Q+ePtcWH2hZ1ivF6H9GPsVKg6nICQiIuWKyWzw+MIdrD8STyV3F2aO6UBYVR/rg/d9C6v+Y7ndZSJ0n2S/QqVUUBASEZFywzAMXli5h+93n8XdxZnP72lPq5AA64OP/glLxoBhhvCR0Pt1NVGtgFwdXYA97Nixg0WLFuHr68vo0aOpWbOmo0sSEZES8P7Ph5i/8QROTvD+0HC6NQiyPvDUNvh6GJiyoUlfuONDhaAKqtyfEVqzZg33338/vr6+7N+/n86dO5Odne3oskREpJjNWn+Mj345BMCr/Vtwe6sa1geeOwjzBkN2KtS7HgZ9BS4V4ryAWFHu/+SbN2/O+vXrcXW1/KghISGcO3eOWrVqObgyEREpLqt2nublb/YC8PhNjRjVuY71gYknYc4ASI+Hmm3g7vngZmMRtVQIDg1CZrOZ77//nk8//ZT9+/czb948OnXqVGDcZ599xuzZs0lJSaFbt2689tprBAVZTnceOXKEKVOmWH39Tz75JN802E8//USrVq0UgkREypE/D57jiUU7MAy4p0sdHunVwPrAtDiYcyckn4KgRjBiKXj42rdYKXUcGoSefvppIiMjGTBgAN999x0ZGRkFxrz33nu8/PLLfPbZZ9SpU4dnnnmG3r17s3nzZlxcXKhUqRLh4eFWX9/pH/O933zzDZ988gmLFi0qqR9HRETsbMfJRB6cu5Uck0HfVjV4+Y7m+X7358lMtnSSjz8EfiGW/mGVAu1fsJQ6ToZhGI568+zsbNzd3YmOjiY0NJTffvuNnj175h3PyckhODiYp59+mqeffhqA6OhoateuzeLFixk0aFCR3uezzz7jhx9+4Ouvv8bLy+uKakxOTsbf35+kpCT8/Pyu6LkiIlJyDsemMuTT9SSk53BdwyC+Gt0Bd1crS19zMmDuYDj+F3gHwdgfIaih/QsWuyrq97dDF0u7u7sXenznzp0kJCRwyy235D0WEhJCy5Yt+f3334v0HkuWLOGRRx4hKCiIxx9/nAcffJATJ07YHJ+VlUVycnK+f0REpHQ5k5TB6OmbSEjPoXWIP9NGtrMegky5sGSsJQS5+8LIpQpBkk+pXix98uRJAKpXr57v8erVqxMdHV2k12jatCkffvhhvscKOyv05ptv8sorr1xhpSIiYi+J6dnc89UmTiVmEFa1EtPv7YCPh5WvM7MZVk2EA9+DiwcMXwA1w+1er5RupToImc1mANzc8veGcXd3x2QyFek1mjdvTvPmzYv8ns8++yyTJl3aWTQ5OZnQ0NAiP19EREpOenYuY2du5lBsKtX9PJk9tiOBPh4FBxqGpW3Gzq/ByQWGzIS63e1er5R+pToIXbwyLD4+nsDAS4va4uLiaNq0aYm8p4eHBx4eVv6nEhERh8oxmXl43ja2nUjE38uN2eM6ElLZ2/rgP9+Fvz+x3O4fAU1us1+hUqaU6g0Vw8PDcXNzY8OGDXmPpaWlsXPnTtq3b+/AykRExJ7MZoOnluzi9wPn8HRzZvq9HWgUbOPS981fwm+vW27f8iaED7NfoVLmlOog5O/vz913383bb7/NuXPnMJvNvPTSS3h6enL33XeX6HtHRETQrFkzOnToUKLvIyIihTMMg9e/28fy7adwdXZi2sh2tKtT2frg3Uvgu8mW29c/BV0etl+hUiY5NAgtW7aMBg0acN111wEwYsQIGjRowEcffZQ3ZurUqTRq1IhatWpRuXJlli1bxsqVK6lSpUqJ1jZhwgQiIyPZvHlzib6PiIgUbtofR5i+7igAU4a04obG1awPPLQGlj8AGNDhPrjhOfsVKWWWQ/cRSklJISYmpsDjVapUKRB0EhMTSUtLo2bNmtY3yyoh2kdIRMRxFmw6wTPLdgPwQt9mjOtez/rAE3/D7AGQmwEtBsPAL8C5VE96SAkr6ve3QxdL+/r64utbtO3NAwICCAgIKNmCRESk1Php71meW24JQQ/3rG87BJ3dA/PvsoSgBjfDnZ8qBEmR6ZNig9YIiYg4zt9R8fzn6+2YDRjaPpQnb2lsfeD5KEv/sMwkCO0Md80GFzfrY0WscOjUWFmgqTEREfvaezqJuz/7m5SsXHo3C+aTEW1xdbHy9/bkMzD9Fkg8DsEt4N7vwCvA7vVK6VQmWmyIiIj80/H4NEZP30xKVi6d6lXho2FtrIeg9POWJqqJx6FyPRi5TCFIroqCkIiIlAqxKZmM+moTcalZNK3hxxej2+Pp5lJwYHYazB8KsZHgUx3uWQG+wXavV8oHBSEREXG45MwcRk/fzInz6dSu4s2ssR3w87Sy1ic3GxaOhOhN4BkAo5ZD5br2LlfKEQUhERFxqMwcE+NnbWHfmWSCfDyYM64j1Xw9Cw40m2D5/XDkV3DzhhGLIbiZ/QuWckVByAZdNSYiUvJyTWYe+Xo7m46ex9fDlVljO1AnsFLBgYYB3z0Be5eDsxsMnQuhHe1fsJQ7umrsMnTVmIhIyTAMg2eW7mbhlpO4uzoza0xHutQPtD74l1dh7XuAEwyeDi0G2rVWKXt01ZiIiJRqU346wMItJ3F2go/ubmM7BK2feiEEAX3fVwiSYqUgJCIidvfl2ig++f0IAG/c2ZI+LapbH7h9Lqz+P8vtXi9C+zF2qlAqiqtqsWEYBgcOHCA6OhqA0NBQGje2seuniIjIPyzfHs3r3+0D4MlbGnN3x9rWB+77Blb9x3K7y0ToPslOFUpFckVB6NChQ3z88ccsWLCAc+fO5TtWrVo1hg0bxsSJE2nQoEGxFikiIuXDb/tjeXLxLgDGdqvHwz3rWx8Y9QcsGQuGGcJHQu/XwY4Nt6XiKPLU2OOPP07btm05e/Ys7777LpGRkcTHxxMfH09kZCTvvPMOp06dok2bNkyaVPZTu64aExEpXluPJ/DQvK3kmg0GhNfk+dub4mQt3JzaCguGgykbmvSFOz5UCJISU+QzQmazmSNHjlCtWrUCx6pUqULTpk0ZPXo0sbGx/Pe//y3WIh1hwoQJTJgwIW/VuYiIXL2DMSmMnbmZzBwzPRtXZcqQ1jg7Wwk35w7A3MGQnQr1rodBX4HLVa3iECkSXT5/Gbp8XkTk2kQnpDN42gbOJmfSpnYA88Z3wtvdSrhJPGlpopp8Cmq2gdHfgIev/QuWcqFEL5/Pyclh/fr1efe3bdvGgw8+yJQpUzCZTFfzkiIiUg7Fp2Zxz1ebOJucScNqPsy4t4P1EJR6DuYMsISgoEYwYqlCkNjFVZ1vfOuttzCbzXTt2pW0tDRuvfVWmjVrxg8//EBiYmK5mBoTEZFrk5qVy5iZm4mKS6Omvyezx3UkwNu94MDMZJg3COIPg1+IpX9YJRt7CokUs6s6IzRjxgzGjh0LwJo1awgNDeW3337j22+/Zd68ecVaoIiIlD1ZuSYenLOVXdFJVPZ2Y/a4TtTw9yo4MCcDvh4GZ3aCd5Clk7x/iN3rlYrrqoJQTEwMVapUAeC3337j9ttvB6BBgwbExsYWX3UiIlLmmMwGTyzayV+H4/B2d2HGmI40qOZjZWCu5RL543+Buy+MXApBDe1fsFRoVxWEmjVrRkREBJGRkSxYsIBbbrkFgH379tGsWfnoBKzL50VErpxhGLzyzV6+3XUGNxcnPhvVjvDQgIIDzWZYNREOfA8uHjB8AdQMt3e5Ild31dgvv/zCwIEDSU5OZujQoSxYsACAe++9lxtvvJF77rmn2At1FF01JiJSdB/+fIj3fz6I04X+YXe0rllwkGHAT8/B35+Ak4ulk3yT2+xfrJRrRf3+vqrF0r169SIuLo6EhIR8+wo98cQTNG/e/GpeUkREyri5fx/n/Z8PAvDyHc2thyCAP9+1hCCA/hEKQeJQRZ4aO3z4cL77bm5uBTZXbNmyJc7OzgXGiohI+fb97jO8sHIPAI/0asjornWtD9z8Jfz2uuV2n7cgfJh9ChSxochB6LrrruO+++5j69atNsf8/fffjBs3ju7duxdLcSIiUvqtOxzHYwt2YBgwolNtHr/JxoLn3Uvgu8mW29c/BZ0fsl+RIjYUeWps7969vPLKK/To0QM/Pz/atWtHcHAwhmFw9uxZNm/eTHp6OuPGjSMyMrIkaxYRkVJid3QS98/eQrbJzG0tq/Nq/xbW+4cdWgPLHwAM6HAf3PCc3WsVseaKF0snJiayatUq1q1bx8mTJ3FyciIkJITu3bvTr1+/cteXS4ulRUSsizqXypBPNxCflk3X+oHMGNMBD1eXggNP/A2zB0BuBrQYDAO/AOerumhZpMiK+v2tXmOXoSAkIlJQTHImAz9Zz6nEDFrW8ufr+zvj42FlkuHsHph5G2QmQYObYdjX4OJm/4KlwinRXmMiIlJxJaXncM9XmziVmEG9oErMGNPBegg6HwVz7rSEoNDOcNdshSApda4qCBmGwZdffkmXLl0IDg7Oe/z555/n9OnTxVacI2lDRRGRgjKyTYybtZkDMSlU8/Vg9tiOBPl4FByYfMYyHZYWC8EtYPhCcPe2e70il3NVQWjq1Km8/PLLDBkyJF9Ljbp16/L6668XW3GONGHCBCIjI9m8ebOjSxERKRVyTGYmzN/GluMJ+Hm6MntcR0KrWAk36edh7kBIPA6V68HIZeAVYPd6RYriqtYINW7cmJkzZ9KlSxecnJy4+BInT56kffv2xMTEFHuhjqI1QiIiYDYbTF6yk2XbTuHh6sy88Z1oX7dKwYHZaTC7P0RvBp/qMO4nqFzX7vWKlOgaoWPHjhEeHg6Q7zJJX19fEhMTr+YlRUSklDIMg7d+3M+ybadwcXbikxFtrYeg3CxYONISgjwDYNRyhSAp9a4qCNWuXZsdO3YA+YPQihUraNy4cbEUJiIijpeencukRTv5/M8oAN4Z1IpeTYMLDjSbYNn9cORXcPOGEYshuHw04Zby7ap6jT3yyCOMHj2ad955B4CNGzfy448/8s477/DRRx8Va4EiIuIYR86l8tDcrRyMScXF2YmX7mjGoHYhBQcaBnw3CSJXgLObpYlqaEe71ytyNa4qCP3nP/8hMzOTsWPHYjab6dy5M/7+/rzyyiuMGzeuuGsUERE7+373GZ5asovUrFyq+nowdVgbOoUFWh/8y6uwdSbgBAM/hwa97FmqyDW5pg0VTSYTUVFRmM1mwsLCcHMrf/tDaLG0iFQkOSYzb/2wn6/+OgpAx3pVmDq8DdV8Pa0/Yf3HsPp5y+2+H0D7MfYpVOQyivr9fVVnhC5ycXGhYUMbzfVERKRMOZuUycQLl8cDPNAjjCd7N8bVxcZy0u1zL4WgXi8qBEmZdNVBaMuWLaxbt46EhIQCx15++eVrqUlEROxs/eE4HlmwnbjUbHw9XHn3rtbc0ry67Sfs+wZW/cdyu8tE6D7JPoWKFLOrCkLvvPMOzzzzDM2aNSMgIKDAcQUhEZGywWw2mPbHEd5bfQCzAU1r+DFtRFvqBlWy/aSoP2DJWDDMED4Ser8O1jrOi5QBVxWE/ve///Htt99y2223FXc9pUZERAQRERGYTCZHlyIiUiKS0nOYtGgHv+y3dAgY0i6E1wa0wNPNSgf5i05thQXDwZQNTfrCHR8qBEmZdlWLpX19fTlz5gw+Pj4lUVOposXSIlIe7TmVxEPztnLyfAburs681r85QzvULvxJ5w7A9D6QcR7qXQ/DF4ObjUXUIg5WojtL9+nThxUrVlxtbSIi4iCGYbBg0wkGTlvPyfMZhFbxYtlDXS8fghJPWjrJZ5yHmm3g7vkKQVIuXNXU2Icffkjr1q1ZsmQJ9evXz7e7NMC7775bLMWJiEjxycg28cLKPSzZGg3ATU2r8d6QcPy9L7P1yfmjMG8wJJ+CoEYwYil4+NqhYpGSd1VB6LXXXiMhIYGzZ8+SmZlZ3DWJiEgxOxaXxkPztrHvTDLOTjD5lsY8eH19nJ0vs75n7wrL1WFZyeAXYukfVsnGxooiZdBVBaF58+axevVqbrzxxuKuR0REitlPe88yedFOUrJyCfJx56NhbehaP6jwJ+Vkwur/g81fWu6HdoLB08HfSosNkTLsqoKQp6cnHTuqj4yISGmWazIz5acDfHahYWr7OpWZOrwt1f0vs7Yn/ggsHg1nd1vud3sMbnweXMpf9wCRq1osff3117NgwYLirkVERIpJbHImw7/cmBeCxnevx9f3d758CNq9BD673hKCvANhxBK4+RWFICm3ruqMkIuLC/fffz+LFy+mQYMGBRZLT506tViKExGRK7cxKp6JX2/nXEoWPh6uvDO4Fbe1rFH4k3Iy4MdnLjRPBWp3hcFfgV/NEq9XxJGuKghlZWXRr18/AE6dOlWsBYmIyNUxDIPP/4zinZ8OYDIbNA72ZdrItoRVvcyeb3GHYPG9ELMHcILrJ0OPZ8DlmtpRipQJV/Up1x5CIiKlS3JmDpMX7WR1ZAwAA9vU4vU7W+Dtfplf8zsXwrePQ04aVKoKAz+H+roQRioOxX0RkTIu8nQyD8/byrH4dNxdnHmpXzOGd6xdYNlCPtnp8MOTlg7yAHWvg0Ffgm8hjVZFyqEiB6F7770XgJkzZ+bdtmXmzJnXUJKIiBTV4i0neX7FHrJyzdQK8GLayLa0Cgko/Emx+y1TYef2AU7Q42no8RQ4F9JjTKScKnIQys3NtXpbRETsLzPHxMur9rJg80kAejauyvt3hVO5knvhT9w+D76fDDnp4BMMA7+AsB52qFikdLqipquJiYkEBASUYDmlj5quikhpcyI+nYfmbWXv6WScnGDSTY2YcEODwneJzkq1BKCdX1vuh/W0hCCfanapWcTeivr9fUVrhCpXrsxVNKsXEZFi8su+GB5fuIPkzFyqVHLnw7vDua5h1cKfFLPXMhUWdxCcnKHnc3DdJE2FiaDF0jZFREQQERGByWRydCkiIpjMBv9bc4CI344A0KZ2ABHD21IzwMv2kwwDts2GH56C3EzwrWFZEF23u52qFin9rmhqzMnJqcKdEdLUmIg42rmULB5dsJ31R+IBuLdrXZ67rSnuroU0B8hKsVwWv3ux5X6Dm+DOz6DSZXqMiZQTJTI1BvDBBx9cdsxjjz12pS8rIiJWbDl2ngnztxGTnIW3uwtvDWpFv9aX2e357G7LVFj8YXBygV4vQNdHwfmquiqJlGtXfEaoUqVKlx2Xmpp6TUWVJjojJCKOYBgGX/11lLd+2E+u2aBBNR8+HdmWBtV8C3sSbJkOPz4Lpizwq2XpGF+7s/0KFyklSuyMUHkKOSIipVFKZg5PL93F97vPAtCvdU3eHNiSSh6F/MrOTIZvHoG9yy33G94Cd34K3lXsULFI2aXF0iIipciBsyk8NHcrUXFpuLk48fztzbinS53Cd4k+vcMyFZZwFJxdoddL0GWipsJEikBBSESklFi+PZrnlu0hI8dETX9Ppo5oS9valW0/wTBg0xew+v/AlA3+oTB4BoR2sF/RImXcFQWhCRMmlFQdIiIVVlauide+jWTu3ycAuK5hEB/e3YYqhe0SnZEIqybCvm8s9xvfDv2naipM5ApdURCaOnVqSdUhIlIhRSekM2HeNnZGJ+HkBP+5sSGP9mqIS2G7RJ/aCovHQOJxcHaD3q9BpwehsOkzEbFKU2MiIg7y24FYHl+4g8T0HAK83fhgaDg9GxfS8sIw4O9psOZFMOdAQB0YMgNqtbNf0SLljIKQiIidmcwGH/58kI9/O4xhQOsQfyJGtCWksrftJ6Wfh5UT4cB3lvtN+0G/j8ErwC41i5RXCkIiInZ0Pi2bRxdsZ+2hOABGda7D832b4uFaSN+vk5thyRhIOgku7nDLG9BhvKbCRIqBgpCIiJ1sO5HAhHnbOJOUiZebC28ObMmANrVsP8Fshg1T4ZdXwJwLlevBkJlQM9xeJYuUewpCIiIlzDAMZq0/xn+/30eOySCsaiWmjWhH4+qF7BKdfh6WPwiHfrLcb34n3PEReGqHe5HipCAkIlKC0rJyeWbZbr7ZeRqA21vW4O3BrfApbJfo4xtg6ThIPgUuHtDnTWg/VlNhIiVAQUhEpIQcjk3hwbnbOBybiquzE8/e1pSx3era3iXabIZ1H8Cvr4NhgsAGlqmw6i3tWbZIhaIgJCJSAlbtPM0zS3eRnm0i2M+DiOFtaV+3kM0O0+Jg+QNw+GfL/ZZ3Qd//gUch02cics0UhEREilF2rpk3vt/HzPXHAOhaP5CPhrUhyMfD9pOOrbNMhaWcAVdPuG0KtBmlqTARO1AQEhEpJqcTM5gwfxvbTyQCMPGGBjx+cyPbu0SbTbD2f/D7G2CYIagRDJkFwc3sV7RIBacgJCJSDNYeOsejC3ZwPi0bP09X3h8aTq+mwbafkBoLy+6DqN8t91sPh9vfBfdKdqlXRCwUhEREroHZbDD1t8O8//NBDANa1PJj2oh2hFYpZJfoqD8sISg1Bty84bZ3oc0I+xUtInmcHV2APaxatYqbbrqJ3r1788033zi6HBEpJxLSshk7azP/W2MJQcM6hrLkwa62Q5DZBL+9CbP7W0JQ1aZw328KQSIOVO7PCB04cICvv/6a559/nvPnzzN69Gh2795NrVqF7OYqInIZO08m8vC8bZxKzMDD1Zn/3tmSwe1CbD8h5SwsHQ/H1lrutxkFt74D7oWcORKRElcqglBubi6JiYn4+/vj5uZmc0x2djbe3lf2S6N+/fp8/fXXAGRlZREUFERWVtY11ywiFZNhGMzbeIJXv4kk22SmbqA300a2o2mNQnZ8PvIrLLsf0s6BWyW44wNodZfdahYR2xw6NRYdHc3zzz9P7dq1qVq1KuvWrSswJiMjgzFjxuDj40NAQABt2rRh27Ztece3b99OixYtrP5jMplwdXXl5MmTtGjRgho1ajBy5EjCwsLs+WOKSDmRnp3LpEU7eX7FHrJNZm5pHsyq/3S3HYJMufDLazBnoCUEBbeAB/5QCBIpRRx6RmjevHl4eHiwcuVKOnbsaHXM448/zh9//EFkZCQ1atTgscce49Zbb+XQoUP4+fnRuHFjFixYYPW5Li6Wbs7BwcEsWLCAEydO8Pjjj3PHHXfQpk2bEvu5RKT8OXIulYfmbuVgTCouzk4806cJ46+rZ3uX6OTTsGQcnFhvud9ujKVVhpuX/YoWkctyaBB6+umnAcuZIWtSUlKYOXMmU6dOzTuLM2XKFGbOnMnChQu577778Pb2pkWLFjbf49dff6VWrVq0aNGCJk2aEBoaypEjR2wGoaysrHxTZ8nJyVf744lIOfH97jM8tWQXqVm5VPX1YOqwNnQKC7T9hEM/w/L7IT0e3H0tU2EtB9utXhEpulJ91diOHTvIysqie/fueY/5+fkRHh7Oxo0bi/QaYWFhjBgxgrCwMKpWrYqvry99+/a1Of7NN9/E398/75/Q0NBr/jlEpGzKMZl57dtIHp63jdSsXDrWq8J3j3S3HYJMObDmJZg3yBKCqreyTIUpBImUWqVisbQt586dA6Bq1ar5Hq9atWrescupW7cuW7Zs4fjx4/j5+VG5cuVCxz/77LNMmjQp735ycrLCkEgFdDYpk4nzt7HleAIAD/QI48nejXF1sfH3x6RoWDIWTl74S1qH+6D36+DmaaeKReRqlOogdHHu3WQy5Xs8NzfX5tVlttSpU6dI4zw8PPDwKKQnkIiUe+sPx/HIgu3EpWbj6+nKe0Na07t5ddtPOPAjrHgQMhLAww/6fQzNB9itXhG5eqU6CNWsWROAmJgYqlWrlvd4TEwMXbp0cVRZIlJOmc0G0/44wnurD2A2oGkNPz4d2ZY6gTbaXuRmwy+vwIaplvs128DgGVClnv2KFpFrUqrXCIWHh+Pr68vPP/+c91hMTAy7du3iuuuuc2BlIlLeJKXncN/sLUz5yRKChrQLYfnDXW2HoITjMOPWSyGo00Mw9ieFIJEyxqFnhLKyskhJSSEhwTIHn5SURFxcHN7e3nh7e+Ph4cHkyZN57bXXaNKkCbVr1+aJJ56gUaNGDBo0qERri4iIICIiosC0nIiUP3tOJfHQvK2cPJ+Bu6szr/VvztAOtW0/Yd+3sPJhyEwCT3/o/wk0tX0RhoiUXk6GYRiOevMFCxYwceLEAo8/9dRTPPXUU4BlF9e3336b2bNnk5KSQrdu3Xj33XcJCSlkK/tilJycjL+/P0lJSfj5FbJzrIiUOYZhsHDzSV5ctZfsXDO1q3jzyYi2tKjlb/0Judmw5kXYOM1yv1Z7GDwdKhdtDaKI2E9Rv78dGoTKAgUhkfIpI9vECyv3sGSrZR+zm5pW470h4fh727gQ4/xRWDIGTm+33O8yEXq9BK7udqpYRK5EUb+/S/ViaRGRknAsLo2H5m1j35lknJ1g8i2NefD6+jg729glOnIlrJwIWcngVRkGTIPGt9q3aBEpEQpCNmiNkEj59NPes0xetJOUrFyCfNz5aFgbutYPsj44JxNWPw+bv7DcD+0Eg76CAO0tJlJeaGrsMjQ1JlI+5JrMTPnpAJ/9GQVA+zqViRjRlmA/Gxsexh+BxffC2V2W+90egxufB5cr28NMRBxDU2MiIhfEJmcy8evtbDp6HoDx3evx9K1NcLO1S/SepbDqUchOAe9AuPMzaHizHSsWEXtREBKRcm1jVDwTv97OuZQsfDxceWdwK25rWcP64JwM+PFZ2DrDcr92Vxj8FfjVtF/BImJXCkIiUi4ZhsHnf0bxzk8HMJkNGgf7Mm1kW8Kq+lh/Qtwhy1RYzB7ACa57Ano+Cy76NSlSnun/cBEpd5Izc5i8aCerI2MAGNimFq/f2QJvdxu/8nYtgm8eg5w08A6CQV9A/RvtV7CIOIyCkA26akykbIo8nczD87ZyLD4ddxdnXurXjOEda+c1cc4nOx1+eAq2z7Hcr3sdDPoSfAtpsCoi5YquGrsMXTUmUnYs3nKS51fsISvXTK0AL6aNbEurkADrg88dsEyFxUYCTtDjaejxFDi72LFiESkpumpMRCqMzBwTL6/ay4LNJwHo2bgqHwwNJ8Dbxq7PO+bDd09ATjpUqmY5CxTWw44Vi0hpoSAkImXaifh0Hpq3lb2nk3Fygkk3NWLCDQ2s7xKdnQbfTYad8y33w3rCwC/Ap5pdaxaR0kNBSETKrF/2xfD4wh0kZ+ZSpZI7H94dznUNq1ofHBNpmQqLOwBOztDzObhukqbCRCo4BSERKXNMZoP/rTlAxG9HAGhTO4CI4W2pGeBVcLBhWBZDf/8k5GaCbw3LVFjd7nauWkRKIwUhG3TVmEjpdC4li0cXbGf9kXgA7u1al+dua4q7q5VdorNS4NtJsHuR5X79XjDwc6hko7eYiFQ4umrsMnTVmEjpseXYeSbM30ZMchbe7i68PagVd7S2sevz2d2WqbD4w+DkYukT1u0xcLbRVkNEyhVdNSYi5YZhGHz111He+mE/uWaDBtV8+HRkWxpU87U22NIi44dnwJQFfrUsHePrdLF/4SJS6ikIiUiplpKZw9NLd/H97rMA9GtdkzcHtqSSh5VfX5nJ8M2jsHeZ5X7DW2DANKgUaMeKRaQsURASkVLrwNkUHpq7lai4NNxcnHihbzNGda5jfZfoMzstU2Hno8DZFXq9BF0maipMRAqlIOQguSYzri76BS1iy/Lt0Ty3bA8ZOSZq+nsSMaItbWpXLjjQMGDzl/DTc2DKBv9QGDwDQjvYv2gRKXMUhBxk9IxNJGXk0CUskC71A+lQtwq+nm6OLkvE4bJyTbz2bSRz/z4BwHUNg/jw7jZUqWRll+iMRPjmEYhcabnf+DboHwHeVexXsIiUaQpCNpTk5fPZuWa2HEsgK9fMnlPJfLH2KC7OTrSs5U+X+oF0CQukfd3Ktjtli5RT0QnpTJi3jZ3RSTg5wSM3NuSRXg1xsbZL9KmtsHgMJB4HZze4+VXo/BBYmzYTEbFBl89fRkldPh+TnMnfUfFsOBLPhqh4jsen5zvu5uJEeGgAXcIC6Vw/kLa1K+Ppph1wpfz67UAsjy/cQWJ6DgHebnwwNJyeja20vjAM2PgprH4BzDkQUBuGzIRa7exes4iUXkX9/lYQugx77SN0KjHDEoqOxPN3VDynEjPyHXd3daZd7cqWM0b1A2kdEmB9AzmRMsZkNvjw54N8/NthDANah/gTMaItIZW9Cw7OSICVE2H/t5b7Te+AflPBK8CuNYtI6acgVEwcsaGiYRicOJ+ed7Zow5F4YlOy8o3xcnOhfV1LMOpaP4gWNf20+FrKnPNp2Ty6YDtrD8UBMKpzHZ7v2xQPVytnP6O3WKbCkk6Aizv0/i90vE9TYSJilYJQMSkNO0sbhsGRc2lsiIrn7wvh6Hxadr4xPh6udKxXJW/xdbMafta7b4uUEttOJDBh3jbOJGXi5ebCW4Na0j+8VsGBhgEbpsLPL4M5FyrXgyEzoGYbu9csImWHglAxKQ1B6N/MZoODsSn5ptKSM3PzjfH3cqNTvSp0rR9Il/pBNAr2sb73ioidGYbBrPXH+O/3+8gxGYRVrcSnI9vRKNjKLtHp52HFQ3DwR8v95nfCHR+BZ+n4f1FESi8FoWJSGoPQv5nMBvvOJOdNpW06ep7UrPzBKLCSO50vnC3qUj+QsKBKCkZid2lZuTyzbDff7DwNwO0ta/D24Fb4WNsl+sRGWDIWkqPBxQP6vAntx2oqTESKREGomJSFIPRvuSYzu08l5a0v2nzsPJk55nxjqvl6XFhfFEiXsCBCq3gpGEmJOhybwoNzt3E4NhVXZyeeu60pY7rVLfi5M5th/Yfwy2tgmKBKfctVYTVaOaRuESmbFISKSVkMQv+WnWtmZ3QiG47Es/5IHNtOJJKdmz8Y1QrwytvDqEv9QGoGeDmoWimPVu08zTNLd5GebSLYz4NPRrSlXR0rmx6mxcHyB+Dwz5b7LYdA3/fBw8q0mYhIIRSErtE/N1Q8ePBgmQ5C/5aZY2LbiQT+PhLP+iPx7DiZSK45/8egTqA3XesH5k2nVfP1dFC1UpZl55p54/t9zFx/DICu9QP5aFgbgnw8Cg4+tg6WjoOUM+DqCbe+A23v0VSYiFwVBaFiUh7OCF1OenYuW44lsP7CGqPd0Yn8KxdRv2olutYPosuFcGS13YHIP5xOzGDC/G1sP5EIwMQbGvD4zY0K7hJtNsNf78Fvb4BhhqBGlqmw4OZ2r1lEyg8FoWJSEYLQv6Vk5rD52HnWH7YEo8gzyfz7U9Kkum/eVFqnsED8vdQnTS5Ze+gcjy7Ywfm0bPw8XXl/aDi9mgYXHJgaC8vuh6jfLPdbD4Pb3gUPH/sWLCLljoJQMamIQejfEtOz2Xj0fN7l+gdiUvIdd3KCFjUv9UnrUK+K9auApNwzmw2m/naY938+iGFAi1p+TBvRjtAqVnaJPvonLB0PqTHg5m0JQG1G2L9oESmXFISKiYJQQXGpWWyMOs/6I3FsiIon6lxavuMuzk60CvHPW3jdvk4VvNzVJ628S0jL5vFFO/j9wDkAhnWszUt3NCvYI89sgj+nwB9vW6bCqja1TIVVa2L/okWk3FIQKiYKQpd3sYHsxam0E+cLNpBtE1qZzhfOGLWpHaAGsuXMzpOJPDxvG6cSM/Bwdea/d7ZkcLuQggNTYmDZeMvZIIA2I+HWKeBu5YyRiMg1UBAqJgpCV+5iA9n1R+L4+0g8p5My8x33cHWmXZ3KdAkLpGuDQFqFBOCmPmllkmEYzNt4gle/iSTbZKZuoDfTRrajaQ0r/68c+Q2W3Qdp58CtkuWy+NZD7V+0iFQICkLFREHo2lxsILv+wvqiDVHxnPtXA1lvdxfa17X0SetaP5DmaiBbJqRn5/J/y/ewfPspAG5pHsyUIa3x8/zXwnlTLvz+Jqx9DzCgWnPLVFjVRnavWUQqDgWhYqIgVLzyGsheWF/0d9T5Ag1kfS82kL3QDqRpdTWQLW2OnEvloblbORiTiouzE8/0acL46+oV3CU6+bRlQfTxdZb77e6FPm+BmzbsFJGSpSBUTBSESpbZbHAgJiXvbNFGKw1kA7wvNpC17GPUsJoayDrS97vP8NSSXaRm5VLV14Opw9rQKSyw4MBDP8Py+yE9Htx94I4PoeVg+xcsIhWSglAxURCyL5PZIPJ0Mhui4thwxNJANi3blG9MkI87ncIu9kkLpJ4ayNpFjsnMWz/s56u/jgLQqV4VPh7epuCu46Zc+O11+Ot9y/3qLWHILAisb+eKRaQiUxC6RuW5xUZZknOxgeyReP6Ost5ANtjP48L6IssZI6t71sg1OZuUycT529hyPAGAB3vUZ3LvRgXXciVFw5JxcPJvy/0O90Hv18FNLVpExL4UhIqJzgiVLlm5JnaeTLowlRbHtuOJZJsKNpDtemF9UZf6gdTw13qUa7H+cByPLNhOXGo2vp6uvDekNb2bVy848OBPloapGQng4Qf9PobmA+xer4gIKAgVGwWh0i0zx8S24wlsiLJclWatgWzdQG+6XDhb1CUskKq+Vhp+SgFms8G0P47w3uoDmA1oWsOPT0e2pU5gpfwDTTnwyyuw/mPL/RrhMGQGVAmze80iIhcpCBUTBaGyJS0rly3HEy60A4lj96mkAg1kG1TzyVtf1DkskMpqIFtAUnoOkxbt4Jf9sQDc1T6EV/u3KLgRZuIJWDIWojdb7nd6EG5+FVwVNkXEsRSEiomCUNmWnJnD5ot90mw0kG1awy+vHUjHelUqfAPZPaeSeGjeVk6ez8Dd1ZnX+jdnaIfaBQfu/w5WPASZSeDpD/0joOkd9i9YRMQKBaFioiBUviSmZ/N31Hn+jrLeQNbZCVrUsvRJ61w/kA51K04DWcMwWLj5JC+u2kt2rpnaVbz5ZERbWtTyzz8wNxvWvAgbp1nu12oHg2dA5Tr2L1pExAYFoWKiIFS+xaVm5YWiDUfiiYrL30DW9WID2fqBdAkLol2dyuWygWxGtokXVu5hydZoAG5qGsx7Q1rj7/2vs2MJx2DxGDi9zXK/y0To9RK4anpRREoXBaFioiBUsZxNyswLRuuj4jh5PiPfcXcXZ8JrB+RNpbWpHYCHa9kORsfi0nho3jb2nUnG2QmevKUJD1wfVnA378hVsHIiZCWBZwDc+Sk0vtUhNYuIXI6CUDFREKrYohPS884WbYiK54yVBrLt61a+EIyCaBXiX6YayP609yyTF+0kJSuXIB93PhrWhq71g/IPys2C1c/Dps8t90M7waCvICDU/gWLiBSRglAxURCSiwzD4Hh8Ohui4vOayMalFmwg26GupU+apYGsPy6lsE9arsnMlJ8O8NmfUQC0r1OZiBFtCfb718aH8UdgyRg4s9Nyv9ujcOML4FKxF5SLSOmnIFRMFITEFksD2VTLNNqFna8T0nPyjfH1dKVTvSp0vrDzdZPqvg5vIBubnMnEr7ez6eh5AMZ3r8fTtzYpeCZrzzJY9Qhkp4BXFbjzM2jU2wEVi4hcOQWhYqIgJEV1sYHsxbNFG4/Gk/KvBrKVvd3oVC+Qrg0s+xg1sHMD2Y1R8Uz8ejvnUrLw8XBlyuBW3NqyRv5BOZnw07OwZbrlfu0ulqkw/1p2q1NE5FopCBUTBSG5WhcbyK4/EseGqHg2W20g60HnsCp5fdLqBnqXSDAyDIPP/4zinZ8OYDIbNA72ZdrItoRV9ck/MO4wLL4XYnYDTnDdJOj5HLhUjC0ERKT8UBAqJgpCUlz+2UB2w5F4thwv2EC2up9nXo+0LmHF00A2OTOHyYt2sjoyBoCBbWrx+p0t8Hb/V7jZtQi+eQxy0sA7CAZ+Dg16XfP7i4g4goJQMVEQkpKSlWtix4nEvD5p208UbCAbUvkfDWTDgqjuf2Vd3CNPJ/PwvK0ci0/H3cWZl/s1Z1jH0PxnnbLT4cenYdtsy/2618HAL8CvhvUXFREpAxSEiomCkNhLZo6JrRf7pEXFs9NKA9l6QZXyzhZ1vkwD2cVbTvL8ij1k5ZqpFeDFtJFtaRUSkH/QuQOWqbDYSMAJejwNPZ4C57K9N5KIiILQNYqIiCAiIgKTycTBgwcVhMTu0rJy2XzsPBui4vn7SLzVBrKNgn3yNnfsVM/SQDYzx8TLq/ayYPNJAHo2rsoHQ8MJ8P7X7s87vobvJkFOOlSqBoO+hLAedvrpRERKloJQMdEZISktkjNz2BR1Pm8qbd/Z/A1knZygSXU/TGYzB2NScXKCSTc1YsINDfJfsp+dBt8/CTvmWe7X62GZCvMNtu8PJCJSghSEiomCkJRWCWnZbDx6adfrgzGpeceqVHLno7vb0L3hv3aJjt1nmQo7tx+cnKHns3DdE5oKE5Fyp6jf37omVqSMqlzJnT4tatCnhWVR87kUSwPZs0mZ9G1dgxr+XpcGGwZsn2s5E5SbAT7VYfBXULe7g6oXESkdFIREyomqvh7c0bpmwQNZqZa1QLsWWu7XvxHu/Bx8qtq3QBGRUkhBSKQ8O7sHFo+G+MPg5AI3/h90exycy05jWBGRkqQgJFIeGQZsnQk/PA2mLPCtCYOnQ50ujq5MRKRUURASKW8yk+Hbx2DPUsv9hrfAgGlQKdChZYmIlEYKQiLlRUYiHPwJ/ngLzkeBsyv0egm6TNRUmIiIDQpCImVZWjwc+A4iV0HU72DOsTzuH2qZCgvt6NDyRERKOwUhkbIm5Szs+wb2rYJj68D4R0f7qk2gWX/o9CB4V3FcjSIiZYSCkEhZkHjyUvg58Tfwj31Qq7eCZv2gaX+o2shhJYqIlEUKQiKlVfwRS/CJXAWnt+U/Vqv9hfDTD6rUc0x9IiLlgIKQSGkSu/9S+InZ/Y8DTlCnqyX4NO0L/iEOK1FEpDxREBJxJMOAs7shcqUlAMUdvHTMyQXqXWcJP036qimqiEgJUBASsTfDgFNbL4WfhGOXjrm4Q9gNlmmvxrdpwbOISAlTEBKxB7MJTm68EH6+geRTl465ekGDXparvRrdAp7+jqtTRKSCURASKSmmXDi21nLWZ9+3kBZ76Zi7jyX0NO0HDW8G90qOq1NEpAJTEBIpTrlZEPWH5czPge8gI+HSMU9/aHy7Zdor7AZw83RcnSIiAigIiVy7nAw4/LPlSq+DP0JW8qVj3kHQ5EL4qXs9uLo7rk4RESmgQgWh48eP4+bmRs2aNR1dipR1WSmWvl77VsGhNZCTfumYT/VLe/zU7gIuFep/MxGRMqXC/Ibeu3cvt956K7179+bLL790dDlSFmUkwIEfLeHn8C9gyrp0zL/2pfAT0kFNTkVEyogKEYQyMjJ48cUXefLJJ9m5c6ejy5GyJC0O9n9rmfY6+geYcy8dq1LfcqVXs35QIxycnBxWpoiIXB2HByGz2czq1avZv38/gwcPJiSk4I65CQkJ/Pjjj6SkpNC1a1datGiRdyw9PZ2oqCirr31x3LPPPstLL73Etm3brI4TySf5zIXwsxKOrwPDfOlYtWaWsz7N+lluK/yIiJRpDg1Cy5Yt48knn6R69eqsX7+e8PDwAkFo165d3HTTTTRs2JDatWszadIknnvuOZ577jkADhw4wKhRo6y+/s6dO1mxYgVubm44Oztz6tQpEhISiI6Othq4pAJLPGE567NvFZzcRL6mpjVaW878NO0PQQ0cVqKIiBQ/hwahgIAA1qxZg7u7O6GhoVbH3H///XTr1o1ly5bh5OTEkiVLGDp0KHfeeSdNmzalTZs27Nmzx+Z7rFu3jtWrV/PDDz+QmJhIeno6ERERvPnmmyX1Y0lZEX/k0u7Op7fnPxbS8cKanzugcl2HlCciIiXPoUHoxhtvBCA6Otrq8RMnTrBx40Z++OEHnC5MQQwcOJCqVauyZMkSXnjhhcu+x//+97+82zNnzuSvv/4qNARlZWWRlXVpEWxycrLNsVLGGAac228JP5GrIHbvpWNOzlC764UzP33BT1cWiohUBA5fI1SYyMhIAJo0aZL3mLOzM40aNco7diUqV65MrVq1Ch3z5ptv8sorr1zxa0spZRhwZuelju7xhy4dc3aFetdfamrqU9VxdYqIiEOU6iCUkpICWKbQ/qly5cp5x65E//796d+/f6Fjnn32WSZNmpR3Pzk52ea0nZRSZvOFpqYrLH29Eo9fOubiDvVvvNDXq4+amoqIVHClOgh5e3sDlkD0zzCUnJxM1aol87d3Dw8PPDw8SuS1pQSZTXBiw4UFz99AyulLx1y9LP28mvWHhr3B089xdYqISKlSqoNQo0aNADhy5Ei+szJRUVF07drVUWVJaWHKsTQ1jVwJ+7+DtHOXjrn7WpqaNusPDW4Cd2/H1SkiIqVWqQ5CDRs2pGnTpsydO5eePXsC8Pvvv3PixAkGDBhQou8dERFBREQEJpOpRN9HrlBuFhz5zbLmZ/93kJl46ZhngKWvV9N+ENZTTU1FROSyHBqEIiMjWb16NUlJSQAsWbKEHTt20LlzZzp37gzAJ598wq233kpGRga1a9fmyy+/5IEHHqBDhw4lWtuECROYMGECycnJ+Pv7l+h7yWVkp19oarrS0t8r+x/rwypVvdDUtD/UvQ5c3BxXp4iIlDkODUKpqakcO3YMgEcffRSAY8eO5btKrGfPnuzevZtFixaRkpLCjBkz6Nu3ryPKFXvKTIZDqy3h5/DP+Zua+ta07O/T7EJTU2cXx9UpIiJlmpNhGMblh1VcF88IJSUl4eenRbYlKiMBDvxgCT9HfgVT9qVjAbUvtLYYALXaqampiIgUqqjf36V6jZBUAKnnLH299q2Co3/mb2oa2PBSR/cardXXS0REip2CkA1aLF2Ckk9bLnGPXAUn1v+rqWlzS/hp1h+qNlH4ERGREqWpscvQ1FgxSTh+aXfn6E35j9Vsc2Haqz8E1ndMfSIiUq5oakwcL+7QpaamZ3bmPxbayRJ+mt4Bles4pj4REanwFISk+BgGxEZe2N15leX2RU7OUKeb5axPk77gV8NxdYqIiFygICTXxjDg9PZL017nj1w65uwK9XpY1vw06QuVghxXp4iIiBUKQjZosXQhzGaI3nwp/CSduHTMxQMa9LJMezXuA16VHVeniIjIZWix9GVosfQFplzLFV6RqyyXu6ecuXTMzdvSzLRZP8u/PXwdV6eIiAhaLC3FwZQDR/+4EH6+g/S4S8c8/KBRH0v4qd9LTU1FRKRMUhCS/HIyLbs671sFB76HzKRLx7wqX2hq2h/CeoCrh+PqFBERKQYKQgLZaXBojSX8HPwJslMvHatUDZr2taz5qdtdTU1FRKRcURCqqDKTLKEnciUc/gVyMy4d86t1YYPDfpb9ftTUVEREyikFIRvK5VVj6ect012RqyDqt/xNTSvXvbS7c822amoqIiIVgq4au4wyf9VYaqylr9e+VXB0LRj/CHZBjSzBp2k/qN5Sfb1ERKTc0FVjFVnSqUvh5/h64B9ZN7jlpY7u1Zo4rEQREZHSQEGovDh/9NIGh6e25D9Ws+2FMz93qKmpiIjIPygIlWXnDsK+lZbwc3bXPw44Qe3Ol5qaBoQ6rEQREZHSTEGoLDEMiNlzqanpuf2Xjjm5QN1ul8KPb3XH1SkiIlJGKAiVdoYBp7ddCj/noy4dc3aDsJ6WNT+Nb4dKgQ4rU0REpCxSECqNzGY4udESfPZ9A0knLx1z9bS0tGjWz9LiwivAYWWKiIiUdQpCNth9HyFTLhxfdyn8pMZcOuZWCRr1tkx7NewNHj72qUlERKSc0z5Cl1Gi+wjlZl9oarrSstFhevylYx7+0LiPJfw06AVuXsX73iIiIuWY9hEqzbLT4NtJcOAHyPpnU9MqlqamzfpDvR7g6u64GkVERCoABSFHcPOG6E2WEOQTDE36Wtb81OkOLvojERERsRd96zqCkxPc8iZ4+kNoRzU1FRERcRAFIUdp3MfRFYiIiFR4ajEuIiIiFZaCkIiIiFRYCkI2RERE0KxZMzp06ODoUkRERKSEaB+hyyjRfYRERESkRBT1+1tnhERERKTCUhASERGRCktBSERERCosBSERERGpsBSEREREpMJSEBIREZEKS0FIREREKiwFIREREamwFIRERESkwlL3+cu4uPF2cnKygysRERGRorr4vX25BhoKQjZEREQQERFBdnY2AKGhoQ6uSERERK5USkoK/v7+No+r19hlmM1mTp8+ja+vL05OTlbHdOjQgc2bN1/RseTkZEJDQzl58mSZ6mFW2M9amt/ral/rSp9X1PFFGXe5MdaOl9XPFdjvs1UaPldX+lxHf66g7H629LkqnvHX+tlyxOfKMAxSUlKoWbMmzs62VwLpjNBlODs7ExISUugYFxcXm3+AhR0D8PPzK1O/VC7385TW97ra17rS5xV1fFHGXW5MYcfL2ucK7PfZKg2fqyt9bmn5XEHZ+2zpc1U846/1s+Woz1VhZ4Iu0mLpYjBhwoSrOlYW2fPnKc73utrXutLnFXV8UcZdbow+W45/n2t5rSt5rj5XV0+fq+IZf62frdL8udLUmIMkJyfj7+9PUlJSmfrblZRu+lxJSdFnS0pCafhc6YyQg3h4ePDSSy/h4eHh6FKkHNHnSkqKPltSEkrD50pnhERERKTC0hkhERERqbAUhERERKTC0uXzIhVETk4Ox48fByyXlFatWtXBFYmIOJ7OCJVCKSkpDBkyBB8fH8LDw9mzZ4+jS5Jy4MyZM/Tp04du3brxwgsvOLocKSfMZjP/+9//qFmzJv7+/jz88MOYTCZHlyXlwP79++nZsydeXl507tyZffv2lcj7KAiVQu+99x6urq6cPXuWRx55hHHjxjm6JCkHateuzeHDh3n77bcdXYqUI8ePH+fMmTNs27aNyMhI/vjjD1atWuXosqQcWLVqFW+++SZJSUn07duX//u//yuR91EQKiFbt27lxx9/tNnsLTMzk3Xr1rFx40ZycnLyHVuzZg3/+c9/8PHxYcyYMURFRZGYmGiHqqW027BhA59++ilRUVFWj6enp7Nq1SpmzZrF3r177VydlFXp6emsWbOG3bt32xwTHR3Nb7/9xpEjR/I9Xq9ePaZMmUL16tWpVasWoaGhBAYGlnTJUgYYhsGGDRv49ddfbY5JTU3lzz//ZOvWrZjN5nzHnnrqKTp16kRubi6GYRAcHFxihUoxmj17ttGqVSujevXqBmDk5OQUGPPHH38YVatWNZo0aWLUq1fPqF27trFjx468440aNTIOHjyYd79p06bGoUOH7FK/lE6//vqr0bp1a6Ndu3YGYCxevLjAmKioKKNOnTpGy5YtjYEDBxqVKlUyXnzxxQLjZsyYYTzwwAP2KFtKuYSEBOORRx4xatSoYfj7+xujR4+2Om7SpEmGp6en0bFjR8PHx8cYOnSo1d9tH3/8sTF+/PgSrlrKgo8//tho1KiRERwcbAQGBlods2LFCsPf399o2bKlUatWLaNJkyZGVFRUvjH333+/4eTkZISEhJTY96DOCBWz2NhYZs2axfvvv2/1eEZGBkOHDmX48OHs27ePI0eO0KlTJ4YNG5Z39qhq1arExMQAlkQdGxurha0VnLOzMzNnzuSvv/6yOeY///kPderUYdu2bSxdupTFixfz6quvsmXLFjtWKmVJfHw8YWFh7N27l/bt21sds3jxYqZOncpff/3Fxo0b2bVrF6tXr+bDDz/MN+6VV15h3759fP755/YoXUq5xMREVq1axTPPPGP1+Llz5xg5ciTPPPMMu3bt4tixY9SoUYOxY8fmG/fZZ5+RnZ3NO++8w7Bhw0qkVgWhYvbEE08QHh5u8/hPP/1ETEwMTz31FABOTk4888wz7Nu3j02bNgHQu3dvPvjgA+Li4pg2bRoNGzYsUuM4Kb969OhR6OcqKSmJH3/8kQceeABXV8vFoLfeeiv169dn4cKFeeMOHz5MbGwsycnJHD58mKysrJIuXUqx+vXr8+ijj1K5cmWbY2bNmsXNN99Mu3btAMtU2N13383MmTMByM3NZezYsaSnp/Phhx9iMplsLgmQiuP555+ncePGNo8vXboUs9nMI488AoCrqyuTJ0/m999/59ixYwA8/vjjHDx4kIyMDNLS0sjOzi6RWhWE7GzHjh0EBwdTs2bNvMfCw8NxdnZm586dAEyaNAl3d3caN27MrFmzmD59uqPKlTJi//79mEwmmjVrlu/xZs2a5Vsr1KdPHz7//HM2bdpEnz59OHTokL1LlTJmx44dtGnTJt9jbdq0ITIykpycHPbu3cvs2bN577338PT0xNPTk48//thB1UpZsWPHDho1aoS3t3feYxc/Z7t27QLg9ttvZ9CgQYSGhjJ37ty88F3ctI+QnSUmJlKlSpV8jzk7O+Pv709CQgIAPj4+zJ8/3xHlSRmVnJwMQEBAQL7HK1eunG9x6+HDh+1ZlpQD1n5nBQYGYjabSU5OpnXr1uTm5jqoOimrbH2ugLzvwptuuqnQBfzFRWeE7Mzd3Z2MjIwCj2dkZODu7u6AiqQ88PLyAix7UP1TcnJyvr9xiVwpa7+z0tPT846JXI3S9LlSELKzunXrEhMTk++S+bi4ODIzM6lbt67jCpMyrWHDhgAcPXo03+NHjx6lQYMGjihJyom6dety8uTJfI9FR0dTpUoVfH19HVSVlHV169YlOjo632MX79v7u1BByM569+5NRkYGq1evznts6dKleHh40LNnT8cVJmVacHAwHTt2zDelumfPHnbu3Em/fv0cWJmUdX369OH777/P+8ubYRgsW7aMPn36OLgyKcv69OnDyZMn2bp1a95jS5cuJTAw0OYVjCVFa4SK2d69ezl58mTewufVq1fj7OxMhw4dCAwMpEGDBjz00EOMGzeOV155hczMTJ5//nn+7//+r9ArN6RiO3HiBN9//33eWow1a9YQFxdHixYt6N69OwAffPABvXr1Yvjw4TRt2pQvv/ySO++8U19YUqgff/wRsFxK7+TkxI8//oiXlxc9evQALFfuzJ49mwEDBjBy5Ei+//57Dhw4wJw5cxxZtpRy27ZtIzY2lv3795OTk5P3OevevTs+Pj507dqVgQMHctddd/H8888TExPDG2+8wdSpU3Fzc7NrrU6GrnMsVh988EHeH/g/vfXWW3mXP5vNZqZPn86PP/6Iq6srAwYM4O6777ZzpVKW7N69m4iIiAKP33DDDQwdOjTv/uHDh5k3bx4JCQl06NCBYcOG4eysE79im7WgHBwczKxZs/Lunz59mvfff58DBw5Qu3ZtHnnkERo1amTPMqWMeemll9i4cWOBxz/77DPq1KkDWBpBf/LJJ/zxxx94e3szbNgwbr/9dnuXqiAkIiIiFZf+qigiIiIVloKQiIiIVFgKQiIiIlJhKQiJiIhIhaUgJCIiIhWWgpCIiIhUWApCIiIiUmEpCImI3R04cICffvrJ0WVgMplYu3YtixYt4uDBg44uR0QcQC02RKRE7N69m2PHjhEcHEzr1q3x8PDIO/bNN98wd+5cbrnlFofVZxgGN910EzExMbRq1QpfX1/tlixSASkIiUixio2NpV+/fhw9epQOHTqQkJDA6dOneeGFFxg7diwATZo0cXgPtIMHD/L7779z+vRpatSo4dBaRMRxFIREpFg99dRTZGRkcOzYMby8vACIi4vj559/zhvTsGHDfI0VFyxYUOB1nJ2dueuuu/LuHz58mD179hAcHEzbtm3znWGyZevWrRw/fpzQ0FA6dOiQ9/jBgwfz3vPnn3/Gzc2NAQMG4Onpme/5x48fZ8OGDQBUqlSJZs2aUb9+/Xxj9uzZQ0xMDN27d2f9+vXExcUxZMgQfv31V6pWrUrNmjXZuHEj3t7e9OzZk82bN3PkyBEAgoKCaN26NVWrVs17vV27dnH27Fl69+6d73127NjBuXPnuPnmmy/7c4tI0SkIiUix2rNnD126dMkLQWD5wv9nY+F/T42tWLEi32ts27aN48ePc9ddd5Gbm8v48eP5/vvv6dSpE9HR0aSlpbFy5UqaNm1qtYb09HT69evHrl27aN++Pdu2baNJkyZ88803+Pr6cuTIEdauXZtXi7OzM7feemuBIHTy5Mm82lJSUli7di2jR4/m448/zhuzZMkS5syZQ6VKlahatSrVq1dnyJAhvPrqq+Tm5nLq1CmaN29Oly5d6NmzJ9u3b+fXX38F4OzZs2zdupVp06YxcuRIwHJG7Y477uDUqVMEBQXlvc+YMWPo3bu3gpBIcTNERIrRhAkTjICAAGPGjBlGTEyM1TFTpkwxWrdubfXY7t27DR8fH+Odd94xDMMw3njjDSM8PNxITk7OG/PYY48Z3bp1s1nDyy+/bNSuXTvv/c+dO2fUrVvXePbZZ/PGrF271gCMjIyMIv9sx48fN/z9/Y3ff/8977GXXnrJAIxvvvkm39gePXoYAQEBxsmTJwt9zZUrVxp+fn55P5/ZbDbCwsKM999/P2/M9u3bDcDYv39/kWsVkaLRVWMiUqzeeustRo0axaRJkwgODiYsLIyJEydy9uzZyz73/Pnz9O/fn/79+/Pkk08CMGPGDFq3bs1PP/3E4sWLWbRoEYGBgWzYsIHMzEyrr7NgwQLGjx9PtWrVAMsZqQcffNDqFNzlZGZmsm7dOpYsWcL69eupWbMmmzZtyjemXr169O3bt8Bz77zzTkJCQgo8HhcXx6+//sqiRYtITU0lNTWV/fv3A+Dk5MTYsWOZMWNG3vivvvqKbt260bhx4yuuX0QKp6kxESlWPj4+fPTRR7z//vvs3r2bP//8k3fffZfvvvuO3bt34+PjY/V5ubm53HXXXVSpUoUvv/wy7/Fjx44RFBTEkiVL8o0fMmQI6enpBaazwLK2JywsLN9j9evX58SJExiGgZOTU5F+lnXr1jFw4ECCgoKoX78+3t7eJCQkEBsbm2+crcXW1h7/+OOPefbZZ2nVqhU1atTIWyv1z9ccM2YML730Elu2bKFly5bMnz+fKVOmFKlmEbkyCkIiUiJcXFwIDw8nPDycTp060blzZ9avX19gEfBFTzzxBHv37mXLli35wo2fnx8DBgzgqaeeKvJ7BwUFcf78+XyPnT9/nsDAwCKHIIAnn3ySkSNH8t577+U91r59ewzDyDfO1mv++/H09HQef/xxli9fzh133AFAamoqCxcuzPeaNWvW5LbbbmP69On06NGD7OzsfAvHRaT4aGpMRIrV0aNHCzx2cQorICDA6nNmzJjBZ599xvLly6lVq1a+Y3369GH69OlkZ2fne/zUqVM2a+jevTvLli3L99iSJUvo3r17UX6EPGfPns03HXXo0CF27dp1Ra/xT3FxcZhMpnyv+e8zXReNHz+er7/+mmnTpnHXXXfZPJMmItdGZ4REpFg9/fTTxMbG0qtXL2rXrs3x48eZNm0affr0oV27dgXGnzlzhoceeojbbruNY8eOcezYMeDS5fNvv/021113HZ06dWL06NG4urry119/kZGRwcqVK63W8Nprr9GhQwcGDRpEnz59WLNmDRs3bmTjxo1X9LMMGDCAV155haysLHJycnj//ffx9va+4v8mF4WGhtK2bVtGjx7N+PHjOXz4MF999RXOzgX/Tnr77bfj7e3NH3/8wX//+9+rfk8RKZyCkIgUq0WLFrFu3TpWr17Nb7/9RlBQEJ988gn9+vXDxcUFyL+homEYDBgwAMh/Gb2Liwt33XUXtWrVYufOncyePZutW7fi6+vLoEGDGDRokM0a6tevz44dO/jiiy9Yu3YtDRs25O2336ZevXp5Y6pWrcrQoUPzarLmnXfeoXHjxmzcuJFKlSoxZ84c/v77b0JDQ/PGtGjRwupzb7zxRpo0aZLvMScnJ9asWcPUqVP5448/qFWrFuvXr+fVV18tcCbMxcWFvn378scff9CtWzebNYrItXEy/j3ZLSIiDmc2m6lfvz4TJkxg8uTJji5HpNzSGSERkVJmxYoVfPfdd6Snp3P//fc7uhyRck2LpUVESpkff/wRFxcXVq9ejZ+fn6PLESnXNDUmIiIiFZbOCImIiEiFpSAkIiIiFZaCkIiIiFRYCkIiIiJSYSkIiYiISIWlICQiIiIVloKQiIiIVFgKQiIiIlJhKQiJiIhIhfX/2bxmnAEQn2UAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()\n", - "plt.loglog(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b6S8vzFipT5w" - }, - "source": [ - "# Part 3: Patch Predictions As QuPath\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from shapely.geometry import mapping\n", - "\n", - "\n", - "def py_patch_predictions_as_qupath_json(\n", - " preds: list | np.ndarray,\n", - " class_dict: dict,\n", - " patch_coords: list | np.ndarray,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> dict:\n", - " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", - " features = []\n", - " # pick a color for each class based on the class index, using a colormap\n", - " num_classes = len(class_dict)\n", - " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", - " class_colours = {\n", - " class_idx: [\n", - " int(cmap(class_idx)[0] * 255),\n", - " int(cmap(class_idx)[1] * 255),\n", - " int(cmap(class_idx)[2] * 255),\n", - " ]\n", - " for class_idx in class_dict\n", - " }\n", - "\n", - " tqdm_loop = tqdm(\n", - " range(np.asarray(patch_coords).shape[0]),\n", - " leave=False,\n", - " desc=\"Converting outputs to QuPath JSON.\",\n", - " disable=not verbose,\n", - " )\n", - "\n", - " for i in tqdm_loop:\n", - " class_idx = int(preds[i])\n", - " class_name = class_dict[class_idx]\n", - " polygon_geo = Polygon.from_bounds(*patch_coords[i])\n", - " polygon_feat = mapping(polygon_geo)\n", - "\n", - " feature = {\n", - " \"type\": \"Feature\",\n", - " \"id\": f\"patch_{i}\",\n", - " \"geometry\": polygon_feat,\n", - " \"properties\": {\n", - " \"classification\": {\n", - " \"name\": class_name,\n", - " \"color\": class_colours[class_idx],\n", - " }\n", - " },\n", - " \"objectType\": \"annotation\",\n", - " \"name\": class_name,\n", - " \"class_value\": class_idx,\n", - " }\n", - "\n", - " features.append(feature)\n", - "\n", - " return {\"type\": \"FeatureCollection\", \"features\": features}" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def rust_patch_predictions_as_qupath_json(\n", - " preds: list | np.ndarray,\n", - " class_dict: dict,\n", - " patch_coords: list | np.ndarray,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> dict:\n", - " \"\"\"Helper function to generate QuPath JSON per patch predictions.\"\"\"\n", - " num_classes = len(class_dict)\n", - " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", - " class_colours = {\n", - " class_idx: [\n", - " int(cmap(class_idx)[0] * 255),\n", - " int(cmap(class_idx)[1] * 255),\n", - " int(cmap(class_idx)[2] * 255),\n", - " ]\n", - " for class_idx in class_dict\n", - " }\n", - "\n", - " tqdm(\n", - " range(np.asarray(patch_coords).shape[0]),\n", - " leave=False,\n", - " desc=\"Converting outputs to QuPath JSON.\",\n", - " disable=not verbose,\n", - " )\n", - " features = rust_misc.patch_predictions_as_qupath_json(\n", - " class_colours, preds, class_dict, np.array(patch_coords).astype(\"float\")\n", - " )\n", - " return {\"type\": \"FeatureCollection\", \"features\": features}" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "sizeofarray = []\n", - "timings = []\n", - "timings = []\n", - "num_patches = 1\n", - "num_classes = 1\n", - "max_patches = 1000\n", - "while num_patches <= max_patches:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for _j in range(10):\n", - " rng = np.random.default_rng(42)\n", - " class_probs = rng.random(\n", - " (num_patches, num_classes),\n", - " dtype=np.float64,\n", - " )\n", - " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", - " preds = np.argmax(class_probs, axis=1).astype(np.float64).tolist()\n", - " x = np.arange(num_patches, dtype=np.float64) * 10\n", - " y = np.zeros(num_patches, dtype=np.float64)\n", - " patch_coords = np.column_stack((x, y, x + 10, y + 10))\n", - " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", - " classes_predicted = list(range(num_classes))\n", - " verbose: bool = False\n", - " start_time = time.time()\n", - " py_patch_predictions_as_qupath_json(\n", - " preds,\n", - " class_dict,\n", - " patch_coords,\n", - " verbose=False,\n", - " )\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_patch_predictions_as_qupath_json(\n", - " preds,\n", - " class_dict,\n", - " patch_coords,\n", - " verbose=False,\n", - " )\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " sizeofarray.append(num_patches)\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " num_patches *= 10\n", - " num_classes *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()\n", - "plt.loglog(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b6S8vzFipT5w" - }, - "source": [ - "# Part 4: Json.dump\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import json\n", - "import time\n", - "from pathlib import Path\n", - "\n", - "example_dict = {}\n", - "sizeofarray = []\n", - "timings = []\n", - "i = 1\n", - "maxarraysize = 10000\n", - "while i <= maxarraysize:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for j in range(len(example_dict), i):\n", - " example_dict[str(j)] = 1\n", - " for _j in range(10):\n", - " start_time = time.time()\n", - " with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", - " json.dump(example_dict, handle)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_misc.json_dump_python_object(\"example.txt\", example_dict)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " sizeofarray.append(i)\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of dictionary\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()\n", - "plt.loglog(sizeofarray, timings)\n", - "plt.xlabel(\"Size of dictionary\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "interpreter": { - "hash": "a3ed8fb525a8bde66cc7655a5df08d8d0f8699a69b9eb5ccab28dc0a7837eec6" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/pyproject.toml b/pyproject.toml index 9d97f797f..06edd3b82 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -303,4 +303,4 @@ python_version = "3.12" [tool.maturin] python-source = "." include = ["tiatoolbox/**/*"] -module-name = "tiatoolbox.rust_misc" +module-name = "tiatoolbox.rmisc" diff --git a/tiatoolbox/__init__.py b/tiatoolbox/__init__.py index e488b5f9b..6835082d2 100644 --- a/tiatoolbox/__init__.py +++ b/tiatoolbox/__init__.py @@ -14,7 +14,7 @@ from logging import LogRecord from types import ModuleType - from . import rust_misc + from . import rmisc __author__ = """TIA Centre""" __email__ = "TIA@warwick.ac.uk" diff --git a/tiatoolbox/rust_misc.pyi b/tiatoolbox/rmisc.pyi similarity index 100% rename from tiatoolbox/rust_misc.pyi rename to tiatoolbox/rmisc.pyi diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index fb99bfdc9..e9703516e 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -1,12 +1,16 @@ use pyo3::prelude::*; use ndarray::{Array1, Array3}; use numpy::{IntoPyArray, PyArray3, PyReadonlyArray2, PyReadonlyArray3}; +use numpy::PyUntypedArrayMethods; +use ndarray::Axis; +use numpy::PyReadonlyArrayDyn; use pyo3::types::{PyList, PyDict}; use std::collections::HashMap; use pythonize::depythonize; use serde_json::Value; use ordered_float::OrderedFloat; use pyo3::FromPyObject; +use pyo3::pyclass::CompareOp; #[derive(FromPyObject)] enum StringOrFloat { @@ -18,9 +22,99 @@ fn add(a: i32, b: i32) -> i32 { a + b } +#[pyfunction] +fn string_to_tuple(in_str: String) -> Vec { + /*Splits input string to tuple at ','. + + Args: + in_str (str): + input string. + + */ + in_str + .split(',') + .map(|substring| substring.trim().to_string()) + .collect() +} + +#[pyfunction] +fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, + layer_list: &Bound<'_, PyList>, + preds: &Bound<'_, PyAny>, + scale_factor: (f64, f64), + class_dict: &Bound<'_, PyDict>, + class_colours: &Bound<'_, PyDict>, + cv2: &Bound<'_, PyAny>, + poly_geo_fun: &Bound<'_, PyAny> +) -> PyResult> { + /*Helper function to save semantic segmentation as QuPath json.*/ + let class_colours: HashMap, Vec> = class_colours + .iter() + .map(|(key, value)| { + let key: f64 = key.extract()?; + let value: Vec = value.extract()?; + + Ok((OrderedFloat(key), value)) + }) + .collect::>()?; + let features = PyList::empty(py); + let retr_ccomp = cv2.getattr("RETR_CCOMP")?; + let chain_approx_none = cv2.getattr("CHAIN_APPROX_NONE")?; + let find_contours = cv2.getattr("findContours")?; + for type_class in layer_list.iter() { + let class_id: i64 = type_class.extract()?; let class_label = class_dict.get_item(class_id)?; + let layer = preds + .rich_compare(class_id, CompareOp::Eq)? + .call_method1("astype", ("uint8",))? + .call_method0("compute")?; + let result = find_contours.call1((layer, retr_ccomp.clone(), chain_approx_none.clone()))?; + + let result = result.cast::()?; + + let contours = result.get_item(0)?; + + for cnt in contours.try_iter()? { + let cnt = cnt?; + let py_array = cnt.cast::>()?; + //let array = py_array.to_owned(); + if py_array.shape()[0] >= 3 { + let cnt_array: PyReadonlyArrayDyn<'_, i32> = cnt.extract()?; + let cnt_scaled = cnt_array.as_array() + .index_axis_move(Axis(1), 0); + let exterior: Vec<(f64, f64)> = cnt_scaled + .outer_iter() + .map(|p| ( + p[0] as f64 * scale_factor.0, + p[1] as f64 * scale_factor.1, + )) + .collect(); + let coordinates = vec![exterior]; + let poly_geo = poly_geo_fun.call1((coordinates,))?; + let feature = PyDict::new(py); + feature.set_item("type", "Feature")?; + feature.set_item("geometry", poly_geo)?; + feature.set_item("id", format!("class_{}_{}", class_id, features.len()))?; + let classification = PyDict::new(py); + classification.set_item("name", &class_label)?; + classification.set_item("color", class_colours[&OrderedFloat(class_id as f64)].clone())?; + let properties = PyDict::new(py); + properties.set_item("classification", classification)?; + feature.set_item("properties", properties)?; + feature.set_item("objectType", "annotation")?; + feature.set_item("name", &class_label)?; + feature.set_item("class_value", class_id)?; + features.append(feature)?; + } + } + + } + Ok(features.unbind()) +} + #[pyfunction] fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResult<()> { //Equilivent to json.dump(obj, save_path) + //Caution: if obj is a dictionary and has a key of an integer it will throw an error let value: Value = depythonize(obj) .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; @@ -28,9 +122,13 @@ fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResul .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))?; let mut writer = std::io::BufWriter::new(file); - serde_json::to_writer(&mut writer, &value) + serde_json::to_writer_pretty(&mut writer, &value) .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + /* + serde_json::to_writer(&mut writer, &value) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + */ Ok(()) } @@ -239,11 +337,13 @@ fn contrast_enhancer<'py>(py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p } #[pymodule] -fn rust_misc(m: &Bound<'_, PyModule>) -> PyResult<()> { +fn rmisc(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_annotations, m)?)?; m.add_function(wrap_pyfunction!(json_dump_python_object, m)?)?; + m.add_function(wrap_pyfunction!(string_to_tuple, m)?)?; + m.add_function(wrap_pyfunction!(semantic_segmentations_as_qupath_json, m)?)?; Ok(()) } diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index bf0ee8837..55b3657c8 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -31,7 +31,7 @@ from tqdm.auto import tqdm, trange from tqdm.dask import TqdmCallback -from tiatoolbox import logger, rust_misc +from tiatoolbox import logger, rmisc from tiatoolbox.annotation.storage import Annotation, AnnotationStore, SQLiteStore from tiatoolbox.utils.exceptions import FileNotSupportedError @@ -427,14 +427,9 @@ def contrast_enhancer(img: np.ndarray, low_p: int = 2, high_p: int = 98) -> np.n """ # check if image is not uint8 - # check if image is not uint8 - dimension_for_rust = 3 - if img.dtype != np.uint8: msg = "Image should be uint8." raise AssertionError(msg) - if img.ndim == dimension_for_rust: - return rust_misc.contrast_enhancer(img, low_p, high_p) img_out = img.copy() percentiles = np.array(np.percentile(img_out, (low_p, high_p))) p_low, p_high = percentiles[0], percentiles[1] @@ -878,8 +873,11 @@ def save_as_json( raise FileExistsError(msg) if parents: save_path.parent.mkdir(parents=True, exist_ok=True) - with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 - json.dump(shadow_data, handle) + try: + rmisc.json_dump_python_object(save_path, shadow_data) + except ValueError: + with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 + json.dump(shadow_data, handle) def select_device(*, on_gpu: bool) -> str: @@ -1235,17 +1233,6 @@ def patch_predictions_as_annotations( verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" - preds = np.array(preds) - if np.issubdtype(preds.dtype, np.number): - return rust_patch_predictions_as_annotations( - preds.astype("float").tolist(), - keys, - class_dict, - class_probs, - patch_coords, - classes_predicted, - labels, - ) annotations = [] tqdm_loop = tqdm( patch_coords, @@ -1270,42 +1257,6 @@ def patch_predictions_as_annotations( return annotations -def rust_patch_predictions_as_annotations( - preds: list[float], - keys: list, - class_dict: dict, - class_probs: list | np.ndarray, - patch_coords: list | np.ndarray, - classes_predicted: list, - labels: list, - *, - verbose: bool = True, -) -> list: - """Helper function to generate annotation per patch predictions.""" - tqdm( - patch_coords, - leave=False, - desc="Converting outputs to AnnotationStore.", - disable=not verbose, - ) - if len(class_probs) == 0: - class_probs = np.empty((0, 2)) - if len(patch_coords) == 0: - patch_coords = np.empty((0, 2)) - return rust_misc.patch_predictions_as_annotations( - Annotation, - Polygon, - preds, - "labels" in keys, - "probabilities" in keys, - class_dict, - np.array(class_probs).astype("float"), - np.array(patch_coords).astype("float"), - classes_predicted, - labels, - ) - - def patch_predictions_as_qupath_json( preds: list | np.ndarray, class_dict: dict, @@ -1314,11 +1265,6 @@ def patch_predictions_as_qupath_json( verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" - preds = np.array(preds) - if np.issubdtype(preds.dtype, np.number): - return rust_patch_predictions_as_qupath_json( - preds.astype("float").tolist(), class_dict, patch_coords - ) features = [] # pick a color for each class based on the class index, using a colormap num_classes = len(class_dict) @@ -1365,37 +1311,6 @@ def patch_predictions_as_qupath_json( return {"type": "FeatureCollection", "features": features} -def rust_patch_predictions_as_qupath_json( - preds: list[float], - class_dict: dict, - patch_coords: list | np.ndarray, - *, - verbose: bool = True, -) -> dict: - """Helper function to generate QuPath JSON per patch predictions.""" - num_classes = len(class_dict) - cmap = plt.colormaps["tab20"].resampled(num_classes) - class_colours = { - class_idx: [ - int(cmap(class_idx)[0] * 255), - int(cmap(class_idx)[1] * 255), - int(cmap(class_idx)[2] * 255), - ] - for class_idx in class_dict - } - - tqdm( - range(np.asarray(patch_coords).shape[0]), - leave=False, - desc="Converting outputs to QuPath JSON.", - disable=not verbose, - ) - features = rust_misc.patch_predictions_as_qupath_json( - class_colours, preds, class_dict, np.array(patch_coords).astype("float") - ) - return {"type": "FeatureCollection", "features": features} - - def get_zarr_array(zarr_array: zarr.Array | np.ndarray | list) -> np.ndarray: """Converts a zarr array into a numpy array.""" if isinstance(zarr_array, zarr.Array): @@ -1750,8 +1665,11 @@ def save_annotations( def save_qupath_json(save_path: Path, qupath_json: dict) -> Path: """Saves QuPath JSON to disk.""" save_path = save_path.with_suffix(".json") - with Path.open(save_path, "w") as f: - json.dump(qupath_json, f, indent=2) + try: + rmisc.json_dump_python_object(save_path, qupath_json) + except ValueError: + with Path.open(save_path, "w") as f: + json.dump(qupath_json, f, indent=2) return save_path From 2f41cf0f6611772a4c0bd6ec986104f5a2508ef9 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 16:04:53 +0100 Subject: [PATCH 019/112] Removed rust code from tiatoolbox/utils --- tiatoolbox/utils/misc.py | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 55b3657c8..6c8002ed5 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -31,7 +31,7 @@ from tqdm.auto import tqdm, trange from tqdm.dask import TqdmCallback -from tiatoolbox import logger, rmisc +from tiatoolbox import logger from tiatoolbox.annotation.storage import Annotation, AnnotationStore, SQLiteStore from tiatoolbox.utils.exceptions import FileNotSupportedError @@ -873,11 +873,8 @@ def save_as_json( raise FileExistsError(msg) if parents: save_path.parent.mkdir(parents=True, exist_ok=True) - try: - rmisc.json_dump_python_object(save_path, shadow_data) - except ValueError: - with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 - json.dump(shadow_data, handle) + with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 + json.dump(shadow_data, handle) def select_device(*, on_gpu: bool) -> str: @@ -1665,11 +1662,8 @@ def save_annotations( def save_qupath_json(save_path: Path, qupath_json: dict) -> Path: """Saves QuPath JSON to disk.""" save_path = save_path.with_suffix(".json") - try: - rmisc.json_dump_python_object(save_path, qupath_json) - except ValueError: - with Path.open(save_path, "w") as f: - json.dump(qupath_json, f, indent=2) + with Path.open(save_path, "w") as f: + json.dump(qupath_json, f, indent=2) return save_path From 2983348c438004f13ad2faa81cb0bb5f04936759 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 16:29:04 +0100 Subject: [PATCH 020/112] Edited contrast_enhancer to use rust code --- tiatoolbox/utils/misc.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 6c8002ed5..5c9a85f05 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -31,7 +31,7 @@ from tqdm.auto import tqdm, trange from tqdm.dask import TqdmCallback -from tiatoolbox import logger +from tiatoolbox import logger, rmisc from tiatoolbox.annotation.storage import Annotation, AnnotationStore, SQLiteStore from tiatoolbox.utils.exceptions import FileNotSupportedError @@ -427,9 +427,14 @@ def contrast_enhancer(img: np.ndarray, low_p: int = 2, high_p: int = 98) -> np.n """ # check if image is not uint8 + # check if image is not uint8 + dimension_for_rust = 3 + if img.dtype != np.uint8: msg = "Image should be uint8." raise AssertionError(msg) + if img.ndim == dimension_for_rust: + return rmisc.contrast_enhancer(img, low_p, high_p) img_out = img.copy() percentiles = np.array(np.percentile(img_out, (low_p, high_p))) p_low, p_high = percentiles[0], percentiles[1] From d78f4c7583f9c1534843bc589b4ddd9618a76278 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 17:09:08 +0100 Subject: [PATCH 021/112] Updated benchmarking --- ...ring_misc_functions_in_rust_v_python.ipynb | 177 +++++++++--------- 1 file changed, 89 insertions(+), 88 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index a239de3d5..6248c2255 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -22,8 +22,7 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w", - "jp-MarkdownHeadingCollapsed": true + "id": "b6S8vzFipT5w" }, "source": [ "# Part 1: Contrast Enhancer\n", @@ -40,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -109,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -167,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "DZBiw_EepT5x" }, @@ -200,9 +199,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -216,8 +226,7 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w", - "jp-MarkdownHeadingCollapsed": true + "id": "b6S8vzFipT5w" }, "source": [ "# Part 2: Patch Predictions As Annotations\n", @@ -234,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -291,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -388,7 +397,6 @@ " patch_coords,\n", " classes_predicted,\n", " labels,\n", - " verbose=False,\n", " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", @@ -400,12 +408,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -427,8 +435,7 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w", - "jp-MarkdownHeadingCollapsed": true + "id": "b6S8vzFipT5w" }, "source": [ "# Part 3: Patch Predictions As QuPath\n", @@ -445,7 +452,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -517,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -554,7 +561,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -596,10 +603,7 @@ " python_times = np.append(python_times, python_end_time)\n", " start_time = time.time()\n", " rust_object = rust_patch_predictions_as_qupath_json(\n", - " preds,\n", - " class_dict,\n", - " patch_coords,\n", - " verbose=False,\n", + " preds, class_dict, patch_coords\n", " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", @@ -611,9 +615,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -636,21 +651,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'rmisc' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 22\u001b[39m json.dump(example_dict, handle)\n\u001b[32m 23\u001b[39m python_end_time = time.time() - start_time\n\u001b[32m 24\u001b[39m python_times = np.append(python_times, python_end_time)\n\u001b[32m 25\u001b[39m start_time = time.time()\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m rmisc.json_dump_python_object(\u001b[33m\"example.txt\"\u001b[39m, example_dict)\n\u001b[32m 27\u001b[39m rust_end_time = time.time() - start_time\n\u001b[32m 28\u001b[39m rust_times = np.append(rust_times, rust_end_time)\n\u001b[32m 29\u001b[39m sizeofarray.append(len(example_dict))\n", - "\u001b[31mNameError\u001b[39m: name 'rmisc' is not defined" - ] - } - ], + "outputs": [], "source": [ "import json\n", "import time\n", @@ -687,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -695,12 +698,12 @@ "output_type": "stream", "text": [ "[10, 100, 1000, 10000]\n", - "[[np.float64(0.0008439064025878906), np.float64(0.000819706916809082)], [np.float64(0.0009901285171508788), np.float64(0.0008368015289306641)], [np.float64(0.001258087158203125), np.float64(0.0010589838027954101)], [np.float64(0.005210328102111817), np.float64(0.0035884857177734377)]]\n" + "[[np.float64(0.0008447170257568359), np.float64(0.0008098840713500977)], [np.float64(0.0008617401123046875), np.float64(0.0008214950561523437)], [np.float64(0.002380967140197754), np.float64(0.0024411678314208984)], [np.float64(0.007615566253662109), np.float64(0.006029939651489258)]]\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGxCAYAAAB2qSLdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbN1JREFUeJzt3Xd4FWX6xvFveiGNGlpIgIQOKRSpKiKogAWUFjtipahY2f25rltEdxURwS7uWgABEbCBoIL0lkJCDSWUUAKBFNJzzvz+GAxmCZCEJJNyf66L64I378x5zhBybuadecbBMAwDERERESnC0eoCRERERKoihSQRERGRYigkiYiIiBRDIUlERESkGApJIiIiIsVQSBIREREphkKSiIiISDEUkkRERESK4Wx1AdWZ3W7n2LFjeHt74+DgYHU5IiIiUgKGYZCRkUHTpk1xdLz0+SKFpKtw7NgxAgICrC5DREREyuDIkSM0b978kl9XSLoK3t7egHmQfXx8LK5GRERESiI9PZ2AgIDCz/FLUUi6Cr8vsfn4+CgkiYiIVDNXulRGF26LiIiIFEMhSURERKQYCkkiIiIixdA1SRXMbreTl5dndRm1kouLC05OTlaXISIi1ZRCUgXKy8vj4MGD2O12q0uptfz8/GjcuLH6WImISKkpJFUQwzA4fvw4Tk5OBAQEXLZZlZQ/wzDIysoiOTkZgCZNmlhckYiIVDcKSRWkoKCArKwsmjZtiqenp9Xl1EoeHh4AJCcn06hRIy29iYhIqej0RgWx2WwAuLq6WlxJ7fZ7QM3Pz7e4EhERqW4UkiqYroWxlo6/iIiUlUKSVLhp06axaNEiq8sQEREpFV2TJEV8+umnrFu3DjBvoQ8ICGDYsGG0b9++RNu/8847NGrUiFGjRhWO/fDDD3Tr1o3hw4dXSM0iIiIVQWeSpIjVq1ezZs0aevbsSZcuXYiPj6dz58588803Jdp++fLlbNiwoYKrFBERqXg6kyQXadKkCePGjQPg8ccf59y5c/ztb3/D09OT1atX8+qrrxaZ/+WXX5KUlETDhg3Zvn07iYmJhdv/4x//KJy3atUqVq5cic1mY8SIEURERBTZT3x8PF999RVnzpyhS5cu3HfffYV3qIG5bBcUFES9evUuux8REan+Yo+kEn8sjbuvCbSsBp1Jkivq1KkTR44coVWrVkydOpX4+PjCr9ntdqZMmYKzszOtW7embt26NGnShJ49e9KzZ8/CkPPFF1/w17/+lfr165OSkkLPnj2Jiooq3M+PP/5IREQEx48fJygoiJkzZ9K3b98i3cp/+OEHJk2adNn9iIhI9WYYBp+sPchd76/npcXxbE08Y1ktOpNUSQzDIDvfZslre7g4lfkuL5vNxs8//0ynTp0ICQnh2muvZfbs2UybNg2AFStWcOLECe69914aNmxIQEAAwcHBhWeSflevXj1+/vnnwl5F+/bt47///S8REREYhsGkSZOYNGkSb7zxBgAPP/wwLVu25MMPP2TChAkl2o+IiFRvqVl5PLtgOyt3nQTg5o6NCfH3tqwehaRKkp1vo8Nfllvy2jv/dhOeriX/q96zZw/jxo2joKCAjRs3kpaWxvfffw+Y4WXy5Mm8/vrruLi4MHv2bIYOHUrDhg0vu8/+/fsXaebYtm1bjh49CkBSUhL79u1jzJgxhV/38/NjyJAhrF69ukhIutx+RESk+tp26AwT50RzLC0HVydH/m9oe+7tGWhpKxctt8lFfHx86NmzJ/3792fWrFkcOHCg8EzNXXfdRX5+Pt9++y1nzpxhyZIljB079or7/OO1RQBOTk6FDTd/f3RIgwYNisxp0KABJ0+eLPF+RESk+rHbDd5fvZ+RH2zkWFoOQfU9WfREb+7rFWR5rzudSaokHi5O7PzbTZa9dmn88cLt/+Xu7s4999zD7NmzSUpKol69etxyyy2FXy/LN3RAQAAAhw4dIjDwwgV6hw4dokWLFqXen4iIVA8p53J5ZkEsq/acAuDW0Ka8OqwT3u4uFldmUkiqJA4ODqVa8qrKHn74YSIiItizZw/3339/keWvevXqceZM6S6ya9iwIddeey1vv/02ffv2xdHRkV27dvHDDz8wb9688i5fRESqgE0HUpg0L5qT6bm4OTvy19s6Mrp7gOVnj/6oZnxqS6Xq0qUL4eHhbN26lQcffLDI126//Xbuuece8vLy8PLyKtIC4HLeffddBg0aREREBMHBwaxcuZLIyEiGDRtWEW9BREQsYrMbvPvrPt5auRe7Aa0a1mFWZATtm/hYXdpFFJKkiLFjx5KRkXHFeeHh4bi7u9OmTZsi48OHD2fr1q3ExsaSmZmJh4cHzzzzzEXXG919991kZmYW/rljx44kJCTwyy+/cPbsWV566SVCQ0OLbFOS/YiISNV1KiOXp7+KYe2+0wAMD2/G3+/oRB23qhlHHAzDMKwuorpKT0/H19eXtLQ0fHyKJuCcnBwOHjxIy5YtcXd3t6jCipGenk5gYCCzZs0iMjLS6nIuqyb/PYiIVCfr9p3myXkxnD6Xi4eLE3+7vSMjugVYUsvlPr//qGpGN6mynnvuOVasWEGrVq0YOXKk1eWIiEgVZ7MbvP1zAu/8koBhQBt/L2ZFRlja/6ikFJKkVCIiIujRowe33HILzs769hERkUs7mZ7DpLnRbDpo3tAzunsAL9/aEQ/X0t11bRV9ykmp/LHho4iIyKWs3nuKp7+K4UxmHnVcnXh1eGduD2tmdVmlYnkzydmzZxMaGkrjxo0ZOHAg0dHR5bLNleZMnjwZPz+/Ir969+5dbu9LRESkNiqw2Xl92W7un72ZM5l5tG/iw7cT+1a7gAQWh6S5c+fy+OOP89xzz7Fu3Tpat27NDTfcwPHjx69qm5LMycrK4rrrriMxMbHw1/Ll1jw2REREpCY4lprN6A838t6q/QDc07MF3zzRm1YNvSyurGwsDUlTp07lwQcf5J577qF169bMmjULNzc33nvvvavapqT7dXFxKXImydu76l9EJiIiUhX9vOskg2esYeuhs3i7OTMzMpx/3NEZ91I+9aEqsSwkpaamEhcXx4ABAwrHnJycuOGGG1i7dm2ZtynNfn/++WeaNm1K+/bteeSRRy56TpiIiIhcXl6BnX98t5OH/ruV1Kx8Ojfz5btJfRnapanVpV01y0LSsWPHAPD39y8y3qhRo8KvlWWbku63WbNmzJgxg40bNzJ79mx27txJnz59LtuYMDc3l/T09CK/REREaqsjZ7IY8cEGPl57EIAH+wSx8PFeBNavY3Fl5cPyu9scHYvmNGdnZ67U37Ik21xpzksvvVT4+xYtWvDNN9/QvHlz5s2bx0MPPVTs606dOpVXXnnlsrWJiIjUBsviT/DcwlgycgrwcXfm3yNCualjY6vLKleWhaRGjRoBcPr06SLjycnJhV8ryzZl2S+YD1kNDAxkz549l5wzZcoUJk+eXPjn9PT0wifY1xRbt24lMTERMK/Zat68OV26dMHFpfyeyJyUlMS2bdu47bbbym2fIiJSOXILbEz9YTf/WZ8IQFiAHzMjw2le19PawiqAZcttDRo0oFWrVqxZs6bI+G+//cY111xT5m3Ksl+AzMxMjh49etkg5ebmho+PT5FfNc3MmTN5/PHHmTdvHp9++inDhw+nXbt27Nixo9xeY8OGDdx3333ltj8REakciaczufO99YUB6ZFrW7HgsV41MiCBxXe3Pfnkk3z88cesW7eOvLw8pk6dyokTJ3j00UcL50yaNKlI/6KSbHOlObm5uTz44IPs3bsXwzA4fvw49913H66urmqWiPmw2YULF7J48WISEhKoW7cuTz75ZOHX9+3bx4oVK4psc/LkSRYtWlRkLD09nVWrVrFq1arC67dOnTrFxo0byc/PZ+HChSxcuJD4+PiKf1MiInJVvtt+jKHvrCU+KZ26ni7MfqAbfxrcHhcny1suVhhLr0maOHEip0+fZvDgwWRmZhIUFMTixYsJCQkpnJOVlVXkAumSbHOlOW5ubtx4443cddddJCQk4OLiQr9+/Vi3bh3NmlW/ZlcVydXVlUGDBvHRRx8Vjn333Xd8/PHHRcJNdHQ0I0eOpKCgAIBff/2VO++8k7Zt2+Ll5cX+/fuZMWMGLVu2ZN26deTn5zNv3jwAhg0bRqdOnSr3jYmISInk5Nv423c7mbPpMADdg+oyY0w4TXw9LK6s4jkYV7pKuhIYhkFOTg4eHhcf8OzsbAoKCi7qYXS5bUozJy8vD1dX1zLVfbmnCF/09HnDgPysMr3OVXPxBAeHEk194IEHSExMZNWqVYVjo0ePJjY2ll27dgEwffr0i0LSsmXLGDp0aGFIGjRoEKGhofz73/8GIC0tjU2bNjFo0CAWLlzIuHHjSE1NLZ/3dxkX/T2IiEiJ7T91jvFfRrH7RAYODvDE9a15+sY2OFfzs0eX+/z+I8vvbgNwcHC4ZJC51PjltinNnLIGpFLLz4JXLeoZ8adj4Fry2zFPnTrFwoULKSgoYNOmTSxatIjPP/+8VC/p5ubGoUOHyM7OxsPDA19fXwYNGlTaykVExCLfRB/lz9/Ek5Vno34dV94aFca1bRpaXValqhIhSaqW5ORk5s2bR25uLuvXr+eWW25h2LBhpdrHv/71L8aOHUvDhg3p06cPQ4cO5eGHH9bZHBGRKi47z8bLS+OZv/UoAD1b1WPG6HAa+dS+n98KSZXFxdM8o2PVa5fC7xdug3lBdrdu3XjxxReZNm0aYPagstvtRbbJyckp8uf27duzYcMGjh8/zi+//MI///lPli9fznfffXcVb0RERCrS3pMZjP8yioTkczg4wKQbQpg0IAQnx5JdslHTKCRVFgeHUi15VRX+/v68+eabREZG8vDDD9O+fXuaNWtGUlISubm5uLm5AbB69eoi2x0/fpwmTZrQpEkT7r77bux2e+Edcl5eXuTm5lb6exERkeIZhsGCbUf5y5J4cvLtNPR24+1RYfQObmB1aZZSSJIrGjlyJG+88QZTpkxh8eLFDBw4EHd3d0aPHs2wYcPYunUr8+fPL7LNPffcQ0BAAH369MFms/HWW29x5513AtC5c2dsNhsvvfQSoaGhtGvXTne3iYhYJDO3gP9bHM830UkA9AtpwLSRYTT0drO4MutV78vTpdx1796d66677qLx6dOn4+LiwvHjx/Hx8WHTpk0EBwezatUq2rZty9KlSwtDEMDy5cu54YYb2Lx5M9HR0bz00ku89957gPncvB9//JHTp0/z1VdfERsbW2nvT0RELth5LJ1b31nLN9FJODrAcze15b8P9lBAOq9KtACorkrVAkAsob8HEZGLGYbBnM2HeeXbneQV2Gns486MMeH0aFnP6tIqRbVqASAiIiKVIyMnnymL4vhu+3EA+rdtyJsjw6hXp5Ja4lQjCkkiIiK1RHxSGuPnRHEoJQtnRweeu6ktD/drhWMtvXvtShSSREREajjDMPjv+kRe/WE3eTY7zfw8mDEmnK6Bda0urUpTSBIREanB0rLyef7rWJbvOAnAwA7+/PuuLvh5anntShSSREREaqjow2eZODeao2ezcXFyYMot7XmwTxAOJXyeZ22nkFTBdPOgtXT8RaQ2MgyDT9Ye5LUfd1NgN2hRz5OZkeF0ae5ndWnVikJSBXFycgIgLy/vig/ZlYqTlZUFgIuLi8WViIhUjrOZeTy7IJafdycDMLhzY167sws+7vo5WFoKSRXE2dkZT09PTp06hYuLC46O6ttZmQzDICsri+TkZPz8/ApDq4hITbY18QyT5kZzLC0HV2dHXhragXuuaaHltTJSSKogDg4ONGnShIMHD3Lo0CGry6m1/Pz8aNy4sdVliIhUKLvd4P3f9vPmT3ux2Q1aNqjDzMhwOjb1tbq0ak0hqQK5uroSEhJCXl6e1aXUSi4uLjqDJCI13ulzuUyeH8tve08BcHtYU/45rDNebvqIv1o6ghXM0dFRj8MQEZEKsfFACpPmRpOckYubsyN/u70jI7sFaHmtnCgkiYiIVDM2u8HMX/bx9s97sRsQ3MiLWZERtG3sbXVpNYpCkoiISDWSnJHDU/NiWL8/BYC7ujbnb7d3xNNVH+nlTUdURESkmlibcJqnvorh9LlcPFyc+Mcdnbiza3Ory6qxFJJERESquAKbnbd/TmDmr/swDGjr782su8MJbqTltYqkkCQiIlKFnUjLYdK8aDYfPAPAmB4BvHxrR9xddPduRVNIEhERqaJ+3ZPMM/NjOZOZRx1XJ14d3pnbw5pZXVatoZAkIiJSxeTb7Lzx0x4+WH0AgA5NfJh1dwQtG9SxuLLaRSFJRESkCklKzWbinCiiDqcCcF+vQP40uL2W1yygkCQiIlJFrNh5kmcXxJKWnY+3mzOv39WFwZ2bWF1WraWQJCIiYrG8AjuvL9vNJ2sPAtCluS8zx0TQor6nxZXVbgpJIiIiFjpyJosJc6KIPZoGwNg+LXnxlna4OjtaXJkoJImIiFjkx7jjPP/1djJyCvD1cOGNEaEM7OBvdVlynkKSiIhIJcvJt/HqD7v4bMMhACJa+DFjTDjN62p5rSpRSBIREalEB09nMmFOFDuOpQPw6HWteHZQW1yctLxW1SgkiYiIVJKlscf406I4zuUWUNfThWkjw+jfrpHVZcklKCSJiIhUsJx8G698u5O5mw8D0COoHm+PCaOJr4fFlcnlKCSJiIhUoH3J55gwJ4rdJzJwcIAJ/YN5ckAIzlpeq/IUkkRERCrI19uO8n+L48nOt9HAy5W3RoXRL6Sh1WVJCSkkiYiIlLOsvAL+smQHC7cdBaB36/pMHxVGIx93iyuT0lBIEhERKUd7TmQwfk4U+5LP4egATw5ow4QbgnFydLC6NCklhSQREZFyYBgG87ce4eWlO8jJt9PI2423R4fTq3V9q0uTMlJIEhERuUrncgv4v2/iWBxzDIB+IQ14a1QYDbzcLK5MroZCkoiIyFXYcSyNiXOiOXA6EydHB54Z1IbHrm2No5bXqj2FJBERkTIwDIMvNh3m79/tJK/AThNfd2aMCad7UD2rS5NyopAkIiJSSuk5+Uz5Oo7v444DMKBdI94YEUrdOq4WVyblSSFJRESkFLYfTWXCnGgOn8nC2dGBF29px0N9W+LgoOW1mkYhSUREpAQMw+A/6xN59Ydd5NsMmvl5MDMynPAWda0uTSqIQpKIiMgVpGXl89zCWH7aeRKAQR38+fddofh6ulhcmVQkhSQREZHLiDp8lolzoklKzcbVyZE/DW7H/b2DtLxWCygkiYiIFMNuN/h47QH+tWwPBXaDFvU8mRUZQefmvlaXJpVEIUlEROR/nMnM49kFsfyyOxmAIV2aMHV4Z3zctbxWmygkiYiI/MGWxDNMnBPNifQcXJ0defnWDkT2aKHltVpIIUlERARzee291fuZtmIvNrtBqwZ1mBkZQYemPlaXJhZRSBIRkVrv9Llcnv4qhjUJpwG4I6wp/xjWGS83fUzWZvrbFxGRWm39/tM8OS+GUxm5uLs48rfbOjGiW3Mtr4lCkoiI1E42u8E7vyQw4+cE7AaENPJi1t0RtPH3tro0qSIUkkREpNZJTs/hyXkxbDiQAsCIrs155faOeLrqY1Eu0HeDiIjUKmsSTvH0VzGcPpeHp6sT/7ijE8MjmltdllRBCkkiIlIrFNjsTF+ZwKxV+zAMaNfYm5mREQQ38rK6NKmiFJJERKTGO56WzZNzY9iceAaAyGta8JehHXB3cbK4MqnKFJJERKRG+3V3MpPnx3A2Kx8vN2deHd6Z20KbWl2WVAMKSSIiUiPl2+y8sXwPH/x2AIBOzXyYOSaCoAZ1LK5MqguFJBERqXGOns1i4txoog+nAvBA7yCmDG6Hm7OW16TkFJJERKRG+WnHCZ5dEEt6TgHe7s78+64u3NypidVlSTWkkCQiIjVCXoGdqT/u4tN1iQCEBvgxc0w4AfU8rS1Mqi2FJBERqfYOp2QxYW4U24+mATCub0uev7kdrs6OFlcm1ZlCkoiIVGs/xB3nhYXbycgtwNfDhTdHhHJjB3+ry5IawPKQlJeXx88//8zJkyfp3LkzXbt2LZdtSrPfgwcPsnz5crp06ULv3r2v6v2IiEjlyMm38Y/vd/LFxsMAdA2sy4wx4TTz87C4MqkpLA1Jp06d4oYbbiAvL48uXbrw9NNPM2rUKN5///2r2qY0+83NzeXOO+9k9+7dPPLIIwpJIiLVwIFT5xg/J5pdx9MBePz61kwe2AYXJy2vSfmxNCRNmTIFgOjoaDw9Pdm2bRvdu3fn1ltvZciQIWXepjT7fe655+jevTt2u72i3qaIiJSjJTFJ/GlRHJl5NurVcWXayFCub9vI6rKkBrIsctvtdubPn8+DDz6Ip6d550HXrl3p3bs38+bNK/M2pdnv0qVLWb58OdOmTauotykiIuUkO8/Gi19v58l5MWTm2bimZT1+fLKfApJUGMvOJB05coSMjAw6dOhQZLxDhw5s3bq1zNuUdL9Hjx7l0Ucf5dtvv6VOnZJ1X83NzSU3N7fwz+np6SXaTkRErs6+5AzGfxnNnpMZODjAxP7BTBoQgrOW16QCWRaSfg8Yfn5+Rcbr1q17yfBRkm1KMsdms3H33XczadIkunXrVuKap06dyiuvvFLi+SIicvUWbjvKS4vjyc630cDLjemjwugb0sDqsqQWsCyCe3iYdx9kZGQUGU9PTy9cJivLNiWZM2fOHGJjY/H19eX999/n/fffJyUlhbi4ON5//30Mwyj29adMmUJaWlrhryNHjpTmLYuISClk5hYweX4Mzy6IJTvfRp/g+vzwZF8FJKk0lp1JCgwMxNXVlYMHDxYZP3jwIMHBwWXepiRzAgICGD16NNu3by/8enZ2NqdOnSImJgbDMHBwcLjo9d3c3HBzcyv9mxURkVLZfSKd8V9Gsf9UJo4O8PSNbXiifzBOjhf/bBapKA7GpU6bVILbb7+djIwMfv75ZxwcHDh27BgtW7bkgw8+4IEHHgBg9erVnDx5kpEjR5Z4m5LM+V9hYWFcf/31TJ8+vcT1p6en4+vrS1paGj4+PldxJEREBMAwDOZtOcJfl+4gt8COv48bb48Op2er+laXJjVIST+/LQ1Ju3fvpnfv3vTt25eePXvy2Wef0ahRI3755Recnc2TXOPGjWPjxo3Ex8eXeJuSzPlfCkkiItY6l1vAnxbFsTT2GADXtWnItJGh1PfSGXwpXyX9/Lb0toB27dqxfft2evbsycmTJ3n22WdZuXJlkSBz/fXXM2rUqFJtU5I5/2vEiBH06dOnYt6oiIhcVnxSGkNnrGFp7DGcHB144eZ2fPpAdwUksZSlZ5KqO51JEhG5OoZh8MXGQ/z9u13k2ew09XXnnchwugbWs7o0qcFK+vlt+bPbRESkdkrLzmfKou38EHcCgBvbN+Lfd4VSt46rxZWJmBSSRESk0sUeSWXC3CiOnMnGxclcXnuob8ti7ywWsYpCkoiIVBrDMJi9LpHXftxFvs2geV0PZkZGEBbgZ3VpIhdRSBIRkUqRmpXHswu2s3LXSQBu7tiY1+/qgq+Hi8WViRRPIUlERCrctkNnmTQ3mqTUbFydHPm/oe25t2egltekSlNIEhGRCmO3G3y45gD/Xr4Hm90gsL4nsyIj6NTM1+rSRK5IIUlERCpEyrlcnlkQy6o9pwAY2qUJU4d3xttdy2tSPSgkiYhIudt0IIVJ86I5mZ6Lm7MjL9/akTE9ArS8JtWKQpKIiJQbm93g3V/38dbKvdgNaNWwDrMiI2jfRA13pfpRSBIRkXJxKiOXp7+KYe2+0wAMD2/G3+/oRB03fdRI9aTvXBERuWrr953mya9iOJWRi7uLI3+/vRMjugVYXZbIVVFIEhGRMrPZDd7+OYF3fknAMKCNvxezIiMI8fe2ujSRq6aQJCIiZXIyPYcn50Wz8cAZAEZ1C+Cvt3XEw9XJ4spEyodCkoiIlNrqvaeY/FUMKZl5eLo68eqwztwR3szqskTKlUKSiIiUWIHNzpsr9vLeqv0AtG/iw6zIcFo19LK4MpHyp5AkIiIlciw1m0lzo9l66CwA9/Rswf8N6YC7i5bXpGZSSBIRkSv6ZfdJJs+PJTUrHy83Z167szNDuzS1uiyRCqWQJCIil5RXYOffy3fz0ZqDAHRu5svMyHAC69exuDKRiqeQJCIixTpyJouJc6OJOZIKwAO9g5gyuB1uzlpek9pBIUlERC6yLP4Ezy+MJT2nAB93Z/49IpSbOja2uiyRSqWQJCIihXILbEz9YTf/WZ8IQFiAH++MCSegnqe1hYlYQCFJREQAOJSSyYQ50cQlpQHwyLWteO6mtrg4OVpcmYg1FJJERITvth/jxa/jOJdbgJ+nC9NGhnJDO3+ryxKxlEKSiEgtlpNv4+/f7eTLTYcB6BZYlxljwmnq52FxZVLrpR+DI5ug4zDLSlBIEhGppfafOsf4L6PYfSIDgCeub83kgW1w1vKaWOnMAVj3NsTMMf8c0BN8mlhSikKSiEgt9E30Uf78TTxZeTbq13Fl2qgwrmvT0OqypDY7uQPWvgXxX4NhN8da9IacVIUkERGpeNl5Nl5eGs/8rUcB6NmqHm+PDsffx93iyqTWOrIF1k6DPT9cGAseCP0mQ2Bv6+pCIUlEpNZIOJnBE19GkZB8DgcHmHRDCJMGhODk6GB1aVLbGAYcXA1r3oSDv50fdIAOt5vhqEmopeX9TiFJRKSGMwyDBduO8pcl8eTk22no7cbbo8LoHdzA6tKktrHbYe+PZjhK2maOOTpDl9HQ9yloEGJpef9LIUlEpAbLzC3gpcXxLIpOAqBvcAPeGhVGQ283iyuTWsVWADsWwZppcGqXOebsDhH3Q++J4BdgbX2XoJAkIlJD7Tqezvg5URw4lYmjA0we2IYnrg/GUctrUlnycyB2DqydDqmHzDE3H+g+Dno+AV5V+2YBhSQRkRrGMAzmbD7MK9/uJK/ATmMfd2aMCadHy3pWlya1Re452PYprJ8J506YY571zWDUfRx4+FlaXkkpJImI1CAZOflMWRTHd9uPA3B924ZMGxlGvTquFlcmtULWGdj8IWx8z7x1H8CnGfSeBBH3gWv1egagQpKISA0Rn5TG+DlRHErJwtnRgeduasvD/VppeU0qXsYJ2DATtsyG/ExzrF5r6Ps0dBkFztUzpCskiYhUc4Zh8NmGQ/zz+13k2ew08/NgxphwugbWtbo0qenOHIT1MyD6C7DlmWP+nc3b+DvcDo5O1tZ3lRSSRESqsbTsfF5YuJ1lO8zrPm5s788bI7rg51k9/+cu1cTJnX/ojm0zxwKugX7PQshAcKgZZy8VkkREqqmYI6lMmBPF0bPZuDg5MOWW9jzYJwiHGvIBJVXQ0W1md+zd310Yaz0A+j1jdseuYd97CkkiItWMYRh8svYgr/24mwK7QUA9D2aOiSA0wM/q0qQmMgxIXGM2gDyw6vygA7S/1VxWaxpuZXUVSiFJRKQaOZuZx7MLYvl5dzIAgzs35rU7u+Dj7mJxZVLj2O2wd5l55ujoFnPMwcm8ELvvU9CwraXlVQaFJBGRamLboTNMnBPNsbQcXJ0deWloB+65poWW16R82QpgxzdmOEreaY45uZm38PeeCHUDra2vEikkiYhUcXa7wQe/HeCNn/Zgsxu0bFCHmZHhdGzqa3VpUpMU5ELMHFg3Hc4mmmOu3tD9IbMJpLe/ldVZQiFJRKQKSzmXy+T5sazeewqA20Kb8urwzni56ce3lJPcc7DtP2afowyzCSke9aDXE9D94WrTHbsi6F+ZiEgVtfFACk/Oi+Zkei5uzo68cltHRnUP0PKalI/ss7D5I7M7dvYZc8y7qbmk1vV+cK1jbX1VQKlDUmJiIvPnz+e3337j6NGjAAQEBHDttdcycuRIAgNrz1qliEhFsNkNZv26j+kr92I3oHXDOsy6O4J2jX2sLk1qgowTsGEWbJ0NeefMsbotze7YoaPB2c3a+qoQB8MwjJJMPHDgAM8//zxLliyhffv2dO/eHX9/c33y5MmTbN68md27d3PHHXfw+uuv06pVqwotvCpIT0/H19eXtLQ0fHz0w0tErl5yRg5PfxXDun0pANwZ0Zy/39ERT1ed+JerdDYR1v3eHTvXHGvU8Xx37DvAqfZ8j5X087vER6RXr1488sgjvPHGGwQFBRU7JzExkU8++YRevXpx8uTJUhctIlKbrdt3mifnxXD6XC4eLk78/Y5O3NW1udVlSXWXvNvsjh234EJ37OY9zAaQbW6qcQ0gy1OJzySlpKRQv379Eu20NHOrM51JEpHyUGCzM+PnBN75dR+GAW39vZl1dzjBjbytLk2qs6QoswFkke7YN5zvjt2nVoejcj+TdLnQYxgG+/fvp3Hjxnh5edWKgCQiUh5OpOUwaV40mw+aF86O6RHAy7d2xN2lej8YVCxiGJC49nx37F8vjLcbaoajZhHW1VYNOZZloy1btjB+/PjCP0dGRhISEkLjxo1Zs2ZNuRUnIlKTrdqTzOAZa9h88Ax1XJ14e3QYU4d3UUCS0jMM2LMMPhkE/x1qBiQHJ+gyGp7YBKO/VEAqgzJdpfXss8/y6quvArB9+3Z+/PFHtm7dyvLly/nzn//Mb7/9Vq5FiojUJPk2O2/+tJf3V+8HoEMTH2ZGhtOqoZfFlUm1Y7ed7479FpyMN8ec3CDi3vPdsYMsLa+6K1NI2rZtGxERZiJdsWIFw4cPp2vXrrRt25bXXnutXAsUEalJklKzmTQ3mm2HzgJwb89A/jykvc4eSekU5ELsPLM79pkD5pir1/nu2ONrZXfsilCmkOTj48OBAwfo2LEj3377LQ899BAAqampuoBZROQSVu48yTMLYknLzsfbzZnX7+rC4M5NrC5LqpO8TNj2X1j/DmQcM8c86pqPDenxsPl7KTdlCkkjR45kyJAhdOjQgbi4OIYOHQrAsmXLGDx4cLkWKCJS3eUV2PnXst18vPYgAF2a+zJzTAQt6ntaXJlUG9lnYfPHsPHdP3THbmIuqUXcD25aqq0IZQpJb7zxBiEhIRw6dIipU6dSt66ZXPfv389f/vKXci1QRKQ6O3Imiwlzo4k9kgrA2D4tefGWdrg6l+m+GaltziWb3bG3fAJ5GeZY3aDz3bHHqDt2BStxnyS5mPokicjlLIs/znMLt5ORU4CPuzNvjAhlUMfGVpcl1UHq4fPdsT+HghxzrFEH8zb+WtYduyKU9PO7xP+VGTFiBLt3777ivJ07dzJixIiS7lZEpMbJybfx8pJ4HvsiioycAsJb+PHDk/0UkOTKTu2Fbx6HGeGw5SMzIDXrBmPmwWProPNdCkiVqMRHumfPnvTs2ZPw8HBuvfVWunbtir+/P4ZhcOLECbZs2cLSpUuJi4vjpZdeqsiaRUSqrMTTmYyfE8WOY+kAPHpdK54d1BYXJy2vyWUci4Y102DXt8D5BZ5W15tnjoL61eru2FYq1XJbSkoKH3zwAfPmzSM+Pp7fN3VwcKBz586MGTOGhx9+uNZ03NZym4j80dLYY/xpURzncguo6+nCtJFh9G/XyOqypKoyDDi03uyOvf/nC+PthkLfydC8q3W11XAl/fwu8zVJaWlpJCUl4eDgQNOmTfH19S1zsdWVQpKIgLm89sq3O5m7+TAAPYLq8faYMJr4elhcmVRJhgEJK8xwdGSjOebgZC6l9X0aGrW3tr5aoNyf3fa/fH19a2UwEhH5o33J55gwJ4rdJzJwcIDx1wfz1I0hOGt5Tf6X3QY7l5jLaifjzDEnVwi/B3pPgnotra1PLlLmkJSRkcFPP/3EgQMHeO655wDYtWsX7dq1w0FrpyJSCyyKOsr/LY4nK89GAy9X3hoVRr+QhlaXJVVNQR5s/8p8dMgZ81E0uNSB7mPN7tg+aihaVZVpuW337t0MHDgQu93OsWPHCq9Nuv/++7npppuIjIws90KrIi23idROWXkF/GXJDhZuOwpAr1b1eXt0GI183C2uTKqUvCyI+gzWz4D0JHPM3Q96Pg49HgHPepaWV5tV6DVJt9xyC+Hh4fzzn//E0dGxMCRt27aNhx9+mKioqLJXXo0oJInUPntPZjD+yygSks/h6ABPDmjDhBuCcXLUGXQ5LzsVtpzvjp2VYo55NYbeE6DrA+DmbWV1QgWHJD8/PxITE/Hz88PBwaEwJGVmZlKvXj1yc3PLXnk1opAkUnsYhsH8rUd4eekOcvLtNPJ24+3R4fRqXTvu5pUSOHfKDEZbPoZcswUEfoHQ9ykIjQQXnWmsKir0wm3DMAqD0B+vPzpw4IAu5haRGudcbgH/900ci2PMB4r2C2nAW6PCaOClR0IIkHrEfOBs1H8vdMdu2B76TYaOw9X8sRor0+0XgwYN4l//+hdwISQlJyczYcIEbrnlllLt6+uvv+a6666jXbt2jBgxgj179pTLNleak5aWxt/+9jf69OlDaGgokZGRREdHl6p2Ean5dh5L57Z31rI45hhOjg48d1Nb/vtgDwUkgdMJsHg8zAiDzR+YAalpBIyeA4+vhy4jFZCquTKFpGnTprF48WJCQkKw2+3069ePVq1akZSUxGuvvVbi/SxZsoTRo0czYsQIvvzyS1xdXbn22ms5ffr0VW1TkjkTJkzA1dWV6dOn85///Advb2/69evHvn37ynJIRKSGMQyDLzYe4o5313HgdCaNfdyZ90hPxvcPxlHXH9Vux2Nh/v0wszvEfAH2Amh5Ldy3BB7+BdoNAUe1gKgJytxMMjMzkzlz5rB161bsdjsRERHce++9eHl5lXgfXbt2JTQ0lNmzZwOQn59PkyZNeOqpp/i///u/Mm9Tkjk2mw0nJ6fC/dpsNtzd3fnggw8YO3ZsierXNUkiNVN6Tj5TFsXx/fbjANzQrhFvjAilXh1XiysTSx3aYDaA3LfiwljbwWZ37IDu1tUlpVbhHbevVkZGBj4+PsybN49Ro0YVjo8aNYqUlBRWrlxZpm3Ksl+A+fPnc++99xIdHU2HDh1K9B4UkkRqnu1HU5kwJ5rDZ7JwdnTghZvb8VDfljp7VFsZBuz72QxHh9ebYw6O0OlOszu2f0dr65MyqfCO2wB2u52srKyLxktyNunoUbO/SOPGRZ+K3bhxY7Zv317mbUqz39WrV3P//feTnp6OYRgsXbr0sgEpNze3yJ176enpl5wrItWLYRj8Z30ir/6wi3ybQTM/D96JDCeiRV2rSxMr2G3mw2bXvAknzn92OLlCWCT0eRLqtbK2PqkUZQpJe/bs4bHHHmP9+vXk5eVd9PWSnJyy2+1mAc5FS3BxccFms5V5m9Lst0ePHqxatYrTp0/z4YcfEhkZybp162jXrl2xrz916lReeeWVK743Eale0rLyeW5hLD/tPAnAoA7+/PuuUHw9XSyuTCqdLR+2zze7Y6ckmGMuntBtLPQaDz5Nra1PKlWZQtL9999P48aNWbJkCX5+fmV64QYNGgCQkpJSZPz06dM0bFh8W/+SbFOa/Xp4eBAUFERQUBDdunVj3bp1zJw5k5kzZxb7+lOmTGHy5MmFf05PTycgIOCy71NEqrbow2eZMCeapNRsXJwc+NPg9jzQO0iPV6pt8rMh6nOzO3baEXPM3Reuecz8pe7YtVKZQlJsbCzLli0rc0AC8Pf3p0WLFqxfv57bbrutcHzdunUMGTKkzNuUZb+/8/LyKnb58Hdubm64uem2X5GawG43+GTtQV5ftpsCu0GLep7MjAynS3M/q0uTypSTBls+MZtAZp4yx+o0Mrtjdxur7ti1XJnuUQwKCiI5OfmqX/yJJ57g448/Jj4+HsMwePfdd0lMTOThhx8unPPiiy9y0003lWqbK83Jysriueee49Qp8x+EzWbjww8/ZMuWLQwfPvyq35eIVG1nM/MY99lW/vnDLgrsBkM6N+G7SX0VkGqTzNPw89/hrc7w8ytmQPJrAUPehKfizOuOFJBqvTKdSfrb3/7Ggw8+yOuvv07r1q0vOi39vxdNX8pzzz1HUlIS3bp1w83NDXd3d+bMmUPHjhfuFjh9+jRJSUml2uZKczw8PAgMDKRr167k5ORw7tw5AgMD+eKLLxg6dGhZDomIVBNbEs8waW40x9NycHV25C9DO3D3NS20vFZbpB2F9TNh23+gINsca9DW7I7d6U5w0nVockGZWgD88ssvDBs27JJ3d5V2l9nZ2aSmpuLv74/j/zTgSklJITc3l6ZNm5Z4m9LMSUlJoU6dOri7l/6ZOmoBIFJ92O0G763ez7QVe7HZDVo1qMPMyAg6NNW/3VohZb95MXbsPLDnm2NNw6HfM9BWzR9rmwrtk9SuXTsiIiJ44oknir0uqVOnTqXdZbWkkCRSPZw+l8vTX8WwJsHsun9HWFP+MawzXm56ZESNdyIO1kyDnYvBMO9+JqifeeaoVX/QGcRaqUL7JB0+fJjNmzcrGIhIlbdhfwpPzosmOSMXdxdH/nZbJ0Z0a67ltZru8EYzHCUsvzDW5mazO3aLa6yrS6qVMoWkkJAQjh49WuLO1CIilc1mN3jnlwRm/JyA3YDgRl7MioygbWNdjFtjGQbs/9kMR4fWmWMOjtBxmNkdu3Fna+uTaqdMIemee+7hnnvu4fXXXyc4OPii/5EFBQWVR20iImWSnJ7DU1/FsH6/2S9tRNfmvHJ7RzxdtbxWI9ntsPt8d+zjseaYowuEjYE+T0H91paWJ9VXma5JutJpaoseB1fpdE2SSNWzJuEUT38Vw+lzeXi6OvGPOzoxPKK51WVJRbDlQ9xCWDsNTu81x1w8oesD0GsC+DaztDypuir0mqSEhIQyFyYiUhEKbHamr0xg1qp9GAa0a+zNzMgIghtd+VmSUs3kZ0P0F7BuBqQdNsfcfOGaR8zu2HUaWFuf1BhlCknBwcHlXYeISJkdT8vmybkxbE48A0DkNS34y9AOuLs4WVyZlKucdNj6CWx4FzLPNzSu09B8plq3h8BdZ/SlfJU4JMXHxwPm7f2///5SaksLABGx3q+7k5k8P4azWfl4uTnz6vDO3Baqh5DWKJkpsOk92Pyh+RgRAN8W0GcShN8DLh7W1ic1VolDUufO5l0BhmEU/v5Sass1SSJinXybnTeW7+GD3w4A0LGpDzMjI2jZoI7FlUm5SUuCDee7Y+eff65mgzbmbfyd71J3bKlwJQ5Jx48fL/b3IiKV7ejZLCbOjSb6cCoA9/cKZMrg9lpeqylS9sO66RAz90J37Cah0O9ZaDdU3bGl0pQ4JDVu3Jhx48bx8ccfl/jZbCIi5e2nHSd4buF20rLz8XZ35l93duGWzk2sLkvKw4l48061Hd9c6I4d2Mfsjt16gLpjS6UrVQsABwcHLaX9gVoAiFSevAI7U3/cxafrEgEIbe7LzMgIAup5WluYXL0jm80eR3uXXRgLGWQuqwX2sq4uqbEqtAWAiEhlOpySxYS5UWw/al60O65vS56/uR2uzlp2qbYMAw78anbHTlxzftABOt5hhqMmXaysTgRQSBKRKu6HuOO8sHA7GbkF+Hq48OaIUG7s4G91WVJWdjvs+d48c3Qs2hxzdIHQ0WZ37AZqMSNVR6lDkrPzlTcpKCgoUzEiIr/Lybfxz+938fnGQwB0DazLjDHhNPPT7d7Vki0f4r+GtW/Bqd3mmLOH2R279wTwVVd0qXpKHZJmzpxZEXWIiBQ6eDqT8V9GsfN4OgCPXdeaZwa1wcVJy2vVTn4OxHwB696G1N+7Y/tAj4eh5xPqji1VWqlD0mOPPVYRdYiIALAkJok/LYojM89GvTquTBsZyvVtG1ldlpRWbgZsnQ0bZsG5k+aYZwOzO3b3h8Dd19r6REpA1ySJSJWQnWfjlW93MG/LEQB6tKzHjNHhNPZ1t7gyKZWsM7Dpfdj0AeSkmmM+zaHPk2Z3bFfdjSjVh0KSiFhuX3IG47+MZs/JDBwcYGL/YCYNCMFZy2vVR/pxszv21k8hP9Mcqx98vjv2CHB2tbY+kTIoVUjKzs6uqDpEpJZauO0oLy2OJzvfRgMvN6aPCqNviK5TqTbOHDCvN4qZA7Y8c6xxF+j3DLS/FRzVBV2qr1KFJHd3nfYWkfKRlVfAS4t38HXUUQD6BNfnrVFhNPLWz5lq4eQO8061+K8vdMdu0dsMR8Hqji01g5bbRKTS7T6Rzvgvo9h/KhNHB3jqxjaM7x+Mk6M+WKu8o1vNHkd7frgwFjzQfHRIYG/r6hKpAApJIlJpDMPgqy1HeHnpDnIL7Pj7uPH26HB6tqpvdWlyOYYBB1eb4ejgb+cHHaDD7WY4ahJqaXkiFUUhSUQqxbncAv60KI6lsccAuK5NQ6aNDKW+l5vFlckl2e2w90czHCVtM8ccnaHLaOj7FDQIsbQ8kYqmkCQiFS4+KY0Jc6JITMnCydGBZwe15dFrW+Go5bWqyVYAOxaZz1U7tcscc3aHiPuh90TwC7C2PpFKopAkIhXGMAy+2HiIv3+/i7wCO0193XknMpyugfWsLk2Kk58DsXNg7XRINR8Hg5sPdB9ndsf2amhpeSKVTSFJRCpEek4+L369nR/iTgBwY/tG/PuuUOrWUb+cKif3HGz7FNbPhHPm3xee9c1g1H0cePhZWp6IVRSSRKTcxR5JZcLcKI6cycbZ0YEXb2nHQ31b4qDbwquWrDOw+UOzQ3b2WXPMpxn0ngQR96k7ttR6CkkiUm4Mw2D2ukRe+3EX+TaD5nU9mBkZQViAn9WlyR9lnDC7Y2+ZfaE7dr3W0Pdp6DJK3bFFzlNIEpFykZqVx7MLtrNyl/kw05s7Nub1u7rg6+FicWVS6MxBWD8Dor+40B3bv7N5G3+H29UdW+R/KCSJyFXbdugsk+ZGk5SajauTI38e0p77egVqea2qSN5ldseOWwiGzRwLuAb6PQshA9UdW+QSFJJEpMzsdoOP1hzg38v3UGA3CKzvyazICDo187W6NAGzt9GaabD7uwtjrQeYjw4J7K1wJHIFCkkiUiZnMvN4Zn4Mv+45BcDQLk2YOrwz3u5aXrOUYUDiGrMB5IFV5wcdzIfN9psMTcOtrE6kWlFIEpFS23zwDJPmRnMiPQdXZ0f+emtHxvQI0PKalex2SFhuhqOjW8wxByfzQuy+T0HDtpaWJ1IdKSSJSInZ7QbvrtrHtBV7sRvQqmEdZkVG0L6Jj9Wl1V62Ati52FxWS95hjjm5mbfw954IdQMtLU+kOlNIEpESOZWRy+T5MaxJOA3A8PBm/P2OTtRx048RSxTkQuxcszv22YPmmKs3dH/IbALp7W9peSI1gX66icgVrd93mie/iuFURi7uLo787fZOjOjaXMtrVsg9B1H/hfXvQMZxc8yjnhmMeowDj7rW1idSgygkicgl2ewGM35OYMYvCRgGtPH3YlZkBCH+3laXVvtkn4XNH8HG9yD7jDnm3dRcUut6P7jWsbY+kRpIIUlEinUyPYcn50Wz8YD5gTyyW3Neua0THq5qOFipMk7Cxlmw5RPIO2eO1W1pdscOHQ3ObtbWJ1KDKSSJyEV+23uKp7+KISUzD09XJ/45rBPDwptbXVbtcvaQ2R076nOw5ZpjjTqe7459Bzjpx7dIRdO/MhEpVGCzM23FXt5dtR+Ado29mXV3BK0bellcWS2SvBvWTYft8y90x27e3eyO3eYmNYAUqUQKSSICwLHUbCbNjWbrIfNp8Hdf04KXhnbA3UXLa5UiKcrscfTH7tit+pvdsYP6KhyJWEAhSUT4ZfdJJs+PJTUrHy83Z167szNDuzS1uqyazzDg0DozHO3/5cJ4u6HmslqzrtbVJiIKSSK1Wb7Nzr+X7+HD3w4A0LmZLzMjwwmsrzulKpRhQMJPZjg6sskcc3CCziPMC7IbtbO2PhEBFJJEaq0jZ7KYODeamCOpADzQO4gpg9vh5qzltQpjt13ojn0y3hxzcoPwe6DPJKgbZGV1IvI/FJJEaqHlO07w3IJY0nMK8HF35l93hXJzp8ZWl1VzFeRC7Dzzguwz5lk7XL2g21joNR68dexFqiKFJJFaJLfAxtQfdvOf9YkAhAb4MXNMOAH1PK0trKbKy4Rtv3fHPmaOedSFax6HHg+DZz1r6xORy1JIEqklDqVkMmFONHFJaQA83K8lz93UDldnR4srq4GyU893x373D92xm5jdsSPuBze1VBCpDhSSRGqB77cf58Wvt5ORW4CfpwtvjghlQHs9ALXcnUs2g9HmjyEvwxyrGwR9noKwSHXHFqlmFJJEarCcfBv/+H4nX2w8DEC3wLrMGBNOUz8PiyurYVIPw7oZEP05FOSYY406QN/J0HGYumOLVFP6lytSQx04dY7xc6LZdTwdgCeub83kgW1wdtLyWrk5tRfWvgVx88FeYI4162Y2gGxzMzjqWItUZwpJIjXQ4ugk/vRNHFl5NurXcWXaqDCua9PQ6rJqjmPR5m38u74FDHOs1fXnu2P3U3dskRpCIUmkBsnOs/HXpTv4ausRAHq2qsfbo8Px93G3uLIaIvH37tg/XxhrN9RcVmuu7tgiNY1CkkgNkXAyg/Fzoth78hwODjDxhhCeHBCCk6POalwVw4CEFee7Y280xxwcodNdZnds/w7W1iciFUYhSaSaMwyDBduO8pcl8eTk22no7cbbo8LoHdzA6tKqN7sNdi453x07zhxzcjW7Y/eeBPVaWlufiFQ4hSSRaiwzt4CXFsezKDoJgL7BDXhrVBgNvXWreZkV5MH2r8wLss/sN8dc6kD3sdBzPPg0sbY+Eak0Ckki1dSu4+lMmBPF/lOZODrA5IFteOL6YBy1vFY2eVkQ9RmsnwHpZujE3Q96Pg49HlF3bJFaSCFJpJoxDIO5m4/wyrc7yC2w4+/jxozR4VzTqr7VpVVP2amw5WPY+B5knTbHvPzN7thdHwA3byurExELKSSJVCMZOfn86Zt4vo01nwN2fduGvDkilPpeWl4rtXOnzO7YWz6GXLOXFH6B0PcpCI0EF90RKFLbKSSJVBPxSWlMmBNFYkoWTo4OPH9TWx7u10rLa6WVesR84GzUfy90x27YHvpNho7D1R1bRArpp4FIFWcYBp9tOMQ/v99Fns1OMz8PZowJp2tgXatLq15OJ8Da6bB93oXu2E0j4Npnoc0t6o4tIhdRSBKpwtKy83lh4XaW7TgBwI3t/XljRBf8PF0trqwaOR5r3sa/cwmF3bFbXmt2x255nbpji8glKSSJVFExR1KZMCeKo2ezcXFy4MVb2jO2TxAO+lAvmUMbzAaQ+1ZcGGs72OyOHdDdurpEpNpQSBKpYgzD4JO1B3l92W7ybQYB9TyYOSaC0AA/q0ur+gwD9v1shqPD680xB0fodOf57tgdra1PRKoVhSSRKiQ1K49nF8SyclcyALd0asxrd3bB18PF4sqqOLvNfNjsmjfhxHZzzMkVwiKhz5NQr5W19YlItWR5SLLb7WzatImTJ0/SqVMngoODy2Wbksw5c+YM27Ztw9nZmbCwMOrW1YWwYp1th84wcU40x9JycHVy5KWh7bmnZ6CW1y7Hlg/b55vdsVMSzDEXT+g2FnqNB5+m1tYnItWapSEpLS2Nm2++mcOHD9OhQwfWr1/PxIkTee21165qmyvNMQyDJ554gqVLl9KxY0eysrLYvn0706dPZ+zYsRX+vkX+yG43+OC3A7zx0x5sdoOg+p7MjIygUzNfq0uruvKzIepzszt22hFzzN0XrnkMejwKddRYU0SunqUh6c9//jNnzpxh586d+Pr6snbtWvr168fAgQMZMGBAmbe50hzDMAgNDeXtt9/G1dW8S+i9997j0Ucf5cYbb6RFixaVdgykdks5l8vk+bGs3nsKgNtCm/Lq8M54uVl+krdqykmDLZ+YTSAzzWNGnUbQewJ0fRDcfaytT0RqFAfDMAwrXtgwDOrVq8eUKVN4/vnnC8evueYaOnTowKefflqmbcqyX4Dk5GT8/f35/vvvGTx4cIneQ3p6Or6+vqSlpeHjox/OUjqbDqQwaV40J9NzcXN25JXbOjKqe4CW14qTedp8bMjmjyA3zRzza2FebxR2j7pji0iplPTz27L/rh49epTU1FQ6depUZLxz587ExMSUeZuy7Bdg5cqVODg40KFDh0vOyc3NJTc3t/DP6enpl5wrcik2u8G7v+7jrZV7sRvQumEdZt0dQbvGCtoXSTsK62fCtv9AQbY51qCt2R27053gpAvaRaTiWBaS0tLM/w3Wq1f0ydr169cnNTW1zNuUZb+JiYk89dRTPP744wQFBV2y5qlTp/LKK69c8usiV5KckcPTX8Wwbl8KAMMjmvH32ztRR8trRaXsNy/Gjp0H9nxzrEmY2R277RB1xxaRSmHZT2Y3N/OBnOfOnSsyfu7cOdzdiz91XpJtSrvfY8eOMXDgQK655hqmT59+2ZqnTJnC5MmTC/+cnp5OQEDAZbcR+d26fad5cl4Mp8/l4uHixN/v6MRdXZtbXVbVciLufHfsxWDYzbGgfuaZo1b91R1bRCqVZSGpRYsWODs7c/jw4SLjhw4dolWr4nualGSb0uz32LFj9O/fnzZt2rBw4UJcXC5/6t7Nza0whImUVIHNzoyfE3jn130YBrT192ZmZDgh/t5Wl1Z1HN5k9jhKWH5hrM3NZnfsFtdYV5eI1GqWnbN2c3NjwIABLFiwoHDs9OnT/PLLLwwZMqRwbMuWLSxbtqzE25R0v8ePH6d///4EBwezaNEihR+pECfTc4j8eBMzfjED0ujuASwe30cBCS50x/50CMweZAak37tjP7YWIr9SQBIRS1l2dxtATEwMffv2ZdiwYfTq1YuPP/4YBwcH1q9fXxhaxo0bx8aNG4mPjy/xNleak5ubS3h4OCkpKfzrX/8qEpB69OhxyTNZ/0t3t8nlrNqTzOT5sZzJzKOOqxOvDu/M7WHNrC7LenY77P7OPHN0PMYcc3SBsDHQ5ymo39rK6kSkFqjyd7cBhIWFERUVxccff8ymTZuIjIzk8ccfvyi0/LETdkm2udKcvLw8unTpAsCPP/5YpCZ/f/8ShySR4uTb7ExbsZf3Vu0HoH0TH2ZFhtOqoZfFlVnMlg9xC80Lsk/vMcecPaDbg9BrAvgqQIpI1WLpmaTqTmeS5H8dS81m4txoth06C8C9PQP585D2uLs4WVyZhfKzIfoLWDcD0s5fK+jmC9c8YnbIrtPA2vpEpNapFmeSRGqSlTtP8uzCWFKz8vF2c+a1O7swpEsTq8uyTk46bJ0NG2ZBpvnAXuo0NJ+p1u0hdccWkSpPIUnkKuUV2PnXst18vPYgAF2a+zJzTAQt6ntaXJlFMlNg0/uw+QPzMSIAvgFmd+zwe8DFw9r6RERKSCFJ5CocOZPFhLnRxB5JBWBsn5a8cEtb3Jxr4fJa+rHz3bE/hfwsc6x+iNnjqPMIdccWkWpHIUmkjJbFH+e5hdvJyCnAx92ZN0aEMqhjY6vLqnwp+2HddIiZ+4fu2KHQ7xloNxQca2FgFJEaQSFJpJRyC2y8+v0u/rvhEADhLfx4Z0w4zevWsuW1E/HmnWo7Fl3ojh3Yxzxz1HqAumOLSLWnkCRSComnM5kwN4r4JPPhxo9e24pnb2qLi1MtepbYkS1mj6O9f2ifETLI7I4d2Mu6ukREyplCkkgJfRt7jCmL4jiXW0BdTxfeHBnKDe38rS6rchgGHFhlhqPENecHHaDjHWY4atLFwuJERCqGQpLIFeTk23jl253M3Wz2+OkeVJcZY8Jp4lsL7tKy22HP9+ZDZ49FmWOOLhA6Cvo8DQ2Cra1PRKQCKSSJXMb+U+cY/2UUu09k4OAA468P5qkbQ3Cu6ctrtgKIP98d+9Ruc8zZA7o+AL0ngG9zS8sTEakMCkkil/BN9FH+/E08WXk2Gni58taoMPqFNLS6rIqVnwMxX5p3q6X+3h3bB3o8DD2fUHdsEalVFJJE/kdWXgEvL9nBgm1HAejVqj5vjw6jkY+7xZVVoNwM2PopbJgJ506aY54NoNcT0H0cuPtaW5+IiAUUkkT+YO/JDMZ/GUVC8jkcHODJASFMvCEEJ8caejt71hmzO/amDyAn1RzzaQ59JkH4veBay9oaiIj8gUKSCGAYBgu2HuUvS+PJybfT0NuNt0eH0bt1DV1eSj9unjXa+inkZ5pj9YOh79PQeSQ4u1pbn4hIFaCQJLXeudwC/u+bOBbHHAOgX0gD3hoVRgMvN4srqwBnDsC6tyFmDtjyzLHGXczu2O1vVXdsEZE/UEiSWm3nsXQmzIniwOlMnBwdmDywDY9f1xrHmra8dnInrJ0G8V9f6I7dohf0exaC1R1bRKQ4CklSKxmGwZzNh3nl253kFdhp7OPOO5HhdA+qZ3Vp5evoVrPH0Z7vL4wF32ieOQrsbV1dIiLVgEKS1DoZOfm8uCiO77cfB+CGdo14Y0Qo9erUkOtwDAMOrja7Yx/87fygA3S43bzmqGmYldWJiFQbCklSq8QdTWPC3CgOpWTh7OjA8ze3ZVzfVjVjec1uN5+ntuZNSNpmjjk6Q5fR0PcpaBBiaXkiItWNQpLUCoZh8N/1ibz6w27ybHaa+XnwTmQ4ES3qWl3a1bMVwI5F5rLaqV3mmLM7RNwPvSeCX4C19YmIVFMKSVLjpWXl8/zXsSzfYTZJHNTBn3/fFYqvp4vFlV2lgtzz3bHfhrOJ5pibj9n8sefj4NXI0vJERKo7hSSp0aIPn2XCnGiSUrNxcXLgT4Pb80DvIByq891cuedg26ewfiacO2GOedY3HxvSfRx4+FlanohITaGQJDWSYRh8vOYgry/bTYHdoEU9T2ZGhtOluZ/VpZVd1hnY/KHZITv7rDnm0wx6T4KI+9QdW0SknCkkSY1zNjOPZxfE8vPuZACGdG7C1Ds74+NeTZfXMk5c6I6dd84cq9favFOtyyh1xxYRqSAKSVKjbE08w8S50RxPy8HV2ZGXhnbgnmtaVM/ltbOJ5vVG0V+CLdcc8+8M/Sabt/OrO7aISIVSSJIawW43eG/1fqat2IvNbtCyQR1mRobTsWk1fHp98i5Y+xbELQTDZo4FXGN2xw4ZqO7YIiKVRCFJqr3T53J5+qsY1iScBuD2sKb8c1hnvNyq2bd30jbzNv7d310Yaz3gQndshSMRkUpVzT5FRIrasD+FJ+dFk5yRi7uLI6/c1pGR3QKqz/KaYUDiGrMB5IFV5wcdzIfN9psMTcOtrE5EpFZTSJJqyWY3mPnLPt7+eS92A4IbeTErMoK2jb2tLq1kDAP2LjPD0dEt5piDk3khdt+noGFbS8sTERGFJKmGkjNyeGpeDOv3pwBwV9fm/O32jni6VoNvZ1sB7FxsLqsl7zDHnNzMW/h7T4S6gZaWJyIiF1SDTxWRC9YmnOapr6I5fS4PDxcn/nFHJ+7s2tzqsq6sIBdi58La6XD2oDnm6g3dHzKbQHr7W1qeiIhcTCFJqoUCm53pKxOYtWofhgHtGnszMzKC4EZeVpd2eXmZsO0/sP4dyDhujnnUM4NRj3HgUQOeHSciUkMpJEmVdzwtmyfnxrA58QwAY3q04OVbO+DuUoX7BGWfhc0fwcb3INusG++m5pJa1/vBtY619YmIyBUpJEmV9uueZCZ/FcPZrHzquDox9c4u3Bba1OqyLi3jJGycBVs+udAdu25Lszt26GhwdrO2PhERKTGFJKmS8m123vhpDx+sPgBAx6Y+zIyMoGWDKnoG5uwhWD8Doj6/0B27Ucfz3bHvACf9UxMRqW70k1uqnKTUbCbOiSLqcCoA9/UK5E+D21fN5bVTe8zu2NvnX+iO3by72R27zU1qACkiUo0pJEmVsmLnSZ5dEEtadj7e7s78684u3NK5idVlXSwpCtZOg13fAYY51qq/2R07qK/CkYhIDaCQJFVCXoGd137czex15u3xoc19eWdMBC3qe1pc2R8YBhxaZzaA3P/LhfF2Q81ltWZdratNRETKnUKSWO5wShYT5kax/WgaAA/1bckLN7fD1dnR4srOMwxI+MkMR0c2mWMOTtB5hNkdu1F7S8sTEZGKoZAklvox7jjPL9xORm4Bvh4uvDEilIEdqkhjRbvtQnfsk/HmmJMbhN8DfSZB3SArqxMRkQqmkCSWyMm38eoPu/hswyEAIlr48U5kBM38PCyuDCjIg+3zzAuyz5h31+HqBd3GQq/x4N3Y2vpERKRSKCRJpTt4OpMJc6LYcSwdgMeua80zg9rg4mTx8lpeJkR9ZnbHTk8yxzzqwjWPQ4+HwbOetfWJiEilUkiSSrUkJok/LYojM89GvTquvDkylP5tG1lbVHYqbDnfHTvLfGguXo3Pd8d+ANyq+KNPRESkQigkSaXIybfxyrc7mLv5CAA9guoxY0w4jX3drSvqXDJsfBc2fwx5GeZY3SDo8xSERao7tohILaeQJBVuX3IG47+MZs/JDBwcYEL/YJ4cEIKzVctrqYfNJbWoz6Agxxxr1AH6ToaOw9QdW0REAIUkqWALtx3lpcXxZOfbaODlxvRRYfQNaWBNMaf2wrrpsP0rsBeYY826nu+OfTM4VpGWAyIiUiUoJEmFyMor4KXFO/g66igAvVvXZ/roMBp5W7C8dizG7I69cymF3bFbXmd2x255rbpji4hIsRSSpNztOZHB+DlR7Es+h6MDPHVjG8b3D8bJsZLDyKH1ZgPIfSsvjLUdYnbHbt6tcmsREZFqRyFJyo1hGHy15QgvL91BboGdRt5uzBgTTs9W9SuzCDMUrXkTDm8wxxwcodNd0Pdp8O9QebWIiEi1ppAk5eJcbgF//iaOJTHHALi2TUOmjQylgVcl3SFmt8GupWY4OhFnjjm5Qtjd0OdJqNeycuoQEZEaQyFJrorNbvDd9mNMW7GXQylZODk68MygNjx2bWscK2N5rSAP4uab3bFT9pljLnWg24PQawL4NKn4GkREpEZSSJIysdsNfog/ztsrE0hIPgdAE1933hkTTregSuhMnZf1h+7Y5sXhuPvBNY/BNY+qO7aIiFw1hSQpFbvdYNmOE7y9MoE9J80GjD7uzozr14oH+wTh7e5SsQVkp8KWj893xz5tjnn5/6E7tnfFvr6IiNQaCklSIoZhsHzHSaav3MvuE2Y48nZ35qG+LXmwT0t8PSo4HJ07ZXbH3vIx5JrPfMMvEPo+BaGR4GJh524REamRFJLksgzDYMXOk0xfmcDO42Y48XJzZmyfIB7q2wpfzwoOR2lHzSW1bf+FgmxzrGE7szt2pzvVHVtERCqMPmGkWIZh8MvuZKavTCAuKQ2AOq5OPNinJeP6tcTP07ViCzi9D9a9BbHzLnTHbhphNoBsO1jdsUVEpMIpJEkRhmGwas8ppq/cS+xRMxx5ujpxf+8gHu7Xinp1KjgcHY+FNdNg5xIudMe+1jxz1Op6dccWEZFKo5AkgBmOfks4zVsr9hJzJBUADxcn7usdyCP9WlG/ovsdHdpwvjv2igtjbQeb4Sige8W+toiISDEUkmo5wzBYu88MR1GHUwFwd3Hkvl5BPHJtq4ptBmkYsO/n892x15tjDo7mtUZ9nwb/jhX32iIiIlegkFRLGYbBhv0pvLVyL1sSzwLg5uzIPT0DefS6VhX7IFq7HXZ/a4aj47HmmKMLhEWa3bHrt6641xYRESkhhaRaaOOBFKat2Mvmg2cAcHV25O5rWvD4da1p5FOB4ciWD9t/746dYI65eEK3sdBrPPg0rbjXFhERKSWFpFpk88EzvLViLxsOpADg6uTImB4BPH59MI19KzAc5WdD1OewfgakHTHH3H3N7tg9HoU6lfgAXBERkRJSSKoFtiae4a2Ve1m3zwxHLk4OjO7egif6t6aJr0fFvXBOGmz5xGwCmXnKHKvTCHpPgK4PgrtPxb22iIjIVVJIqsGiDp/lrRV7WZNgPr7DxcmBEd0CGN8/mGZ+FRiOMk+bjw3Z/BHkmm0E8G0BfZ+EsLvBpQJfW0REpJwoJNVAMUdSeWvFXlbvNc/eODs6MKJbc8b3D6Z5Xc+Ke+G0o7B+Jmz7z4Xu2A3aQr/fu2NXcHduERGRcqSQVIPEHU3jrZV7+WV3MgBOjg7cFdGcCTcEE1CvAsPR8e2w+QOI/Qrs+eZYkzC49lloO0TdsUVEpFqy/NNr2bJlDBkyhG7duvHggw+SmJhYLttcaY5hGKxcuZK77rqLTp06sWXLlvJ5QxaIT0pj3H+3cOvMtfyyO9kMR12b88sz1/H6XV0qJiAV5MH2BfDJIPigH0R/YQakoH5w7zfwyCpof6sCkoiIVFuWfoItW7aMW2+9lX79+vHmm2+SmppK3759SU1NvaptSjLnxRdfZOrUqVx//fXs2LGDzMzMinujFWTnsXQe+WwrQ99Zy8pdyTg6wPCIZvw8+TreGBFKYP065f+iaUnwyz/grY6waBwc2QSOztBxOIz9CR74DlrfoMeHiIhItedgGIZh1Ytfc801tGnThs8//xyA3NxcGjduzAsvvMCLL75Y5m1KMic7OxsPDw+OHj1KQEAAv/76K9dff32p6k9PT8fX15e0tDR8fCrvTq3dJ9KZviKBZTtOAGYeuT20KRMHhNC6oVf5v6BhwMHfYMtHsPsHMGzmuFdjs8dR1/vBu3H5v66IiEgFKOnnt2Vnks6dO8eWLVsYPHhw4Zibmxs33ngjv/76a5m3Kel+PTyq3x1We09mMP7LKG6evoZlO07g4AC3hTZlxdPXMX10ePkHpJx08w61WdfAZ7fBrm/NgBTYF0b8B56Oh+tfUEASEZEaybILt5OSkjAMgyZNmhQZb9KkCTt27CjzNmXZb0nl5uaSm5tb+Of09PSr2l9JJaVm89qPu/lu+zF+P+83pEsTnhwQQht/7/J/weTd5lmj2HmQd84cc6kDoaOh+zjw71D+rykiIlLFWBaSCgoKAHB1dS0y7ubmRn5+fpm3Kct+S2rq1Km88sorV7WP0jIMg4f/u5Wdx81Adkunxjx5YwjtGpfz8p4tH3Z/D1s+hsQ1F8YbtDGDUehos0u2iIhILWFZSKpf33wURUpKSpHxlJQUGjRoUOZtyrLfkpoyZQqTJ08u/HN6ejoBAQFXtc8r2XEsnZ3H03FzdmTRE73p2LScg0rGSYj6L2ydDRnHzTEHR2g7GHo8DC2v00XYIiJSK1l2TVLjxo1p2rQpmzZtKjK+YcMGunbtWuZtyrLfknJzc8PHx6fIr4q2KCoJgBs7+JdfQDIMOLQBFo4171L79Z9mQPJsAP2ehafiYPSX0Op6BSQREam1LG0B8Oijj/Lxxx9z4MABAD777DP27t3LuHHjCue8/PLLDBs2rFTblGROdVBgs7M09hgAw8ObXf0O8zLNbtjv94VPb4b4r83eRs17wPCPYPJOGPAS+Da/+tcSERGp5iztuP2nP/2JxMRE2rVrR4MGDcjKymL27NmEhYUVzklKSiIhIaFU25RkzpIlS/jzn/9ceA3Tgw8+SJ06dXjiiSd44oknKvqtl8iafac5fS6X+nVcubZNw7LvKGW/ea1R9JcXnqXm7AGd7zKX1JqElk/BIiIiNYilfZJ+d/bsWU6fPk2LFi1wc3Mr8rVjx46RlZVFcHBwibcpyZzU1FSOHj160TaNGjWiUaNGJaq7ovskTZobzdLYYzzQO4i/3taxdBvbbbB3uXmX2v5fLozXbQndHzIfNOtZr3wLFhERqQZK+vldJZ7dVrduXerWrVvs15o2bVrqbUoyx8/PDz8/v1LVWZnO5Rbw006zWeSw0iy1ZaZA9GewZTakHT4/6AAhg8yzRq0H6FEhIiIiJVAlQpJc7Me44+Tk22nVsA5dmpfggu2j28yzRvGLwHa+l5NHXQi/1+yKXa9lxRYsIiJSwygkVVHfRJt3tQ0Pb4bDpe4wy882Q9GWj+BY9IXxJmHmWaNOd4JL9essLiIiUhUoJFVBx9Oy2XDA7PN0e1gxS21nE82+RlGfQ/YZc8zJ1XzIbI+HoVlX3bovIiJylRSSqqDF0ebjR3oE1SOgnqc5aLebF2Bv+ci8IJvz19v7BpjLaRH3QZ2ra5YpIiIiFygkVTGGYfBNtHnX3bCIZnBqL+xaAjFz4MyBCxNb9TfPGrW5GRydLKpWRESk5lJIqmIycwu4xiOJYW4rGLnpr/DD3gtfdPOFsEjzFv4GIZbVKCIiUhsoJFUxXo75/P30ZHDIhhTA0QVaXQcdbjevOXLzsrpEERGRWkEhqapx9YT2t0J+FrS/DdrcBB5+VlclIiJS6ygkVUXDP9TdaSIiIhZT6+WqSAFJRETEcgpJIiIiIsVQSBIREREphkKSiIiISDEUkkRERESKoZAkIiIiUgyFJBEREZFiKCSJiIiIFEMhSURERKQYCkkiIiIixVBIEhERESmGQpKIiIhIMRSSRERERIrhbHUB1ZlhGACkp6dbXImIiIiU1O+f279/jl+KQtJVyMjIACAgIMDiSkRERKS0MjIy8PX1veTXHYwrxSi5JLvdzrFjx/D29sbBwaHc9puenk5AQABHjhzBx8en3PYrRek4Vw4d58qjY105dJwrR0UeZ8MwyMjIoGnTpjg6XvrKI51JugqOjo40b968wvbv4+Ojf4CVQMe5cug4Vx4d68qh41w5Kuo4X+4M0u904baIiIhIMRSSRERERIqhkFQFubm58fLLL+Pm5mZ1KTWajnPl0HGuPDrWlUPHuXJUheOsC7dFREREiqEzSSIiIiLFUEgSERERKYZCkoiIiEgxFJKqmLS0NLZu3cqRI0esLqVaMAyDhIQEdu/eTV5e3iXnnThxgi1btpCSklLhc2q6LVu2sGnTpmK/lpGRwdatW0lMTLzk9uU1pyZLTU1l27ZtpKWlFft1m83G9u3biYuLw263V+icmspms5GQkEBUVBRnzpy55LwDBw6wbds2MjMzK3xOTREXF3fJnxFgNmKOi4tj+/bt2Gw2y+dcliFVxowZMwwPDw+jffv2hoeHhzF8+HAjJyfH6rKqrJkzZxoBAQFGSEiIERISYjRo0MD47LPPiswpKCgwHnroIcPd3d3o0KGD4ebmZvzlL3+pkDm1wZw5cwxHR0ejfv36F33to48+Mjw9PY22bdsaderUMW655Rbj3LlzFTKnpsrLyzOeeOIJw8PDw4iIiDACAgKMf/7zn0XmREVFGYGBgUazZs2Mxo0bG61btzbi4uIqZE5N9dtvvxlBQUFG8+bNjfDwcMPDw8MYO3asUVBQUDgnNTXV6N+/v+Ht7W20adPG8Pb2Nr788ssi+ymvOTXF7NmzjbCwMKNu3brF/owwDMPYvn270bp1a6NJkyZGs2bNjMDAQCMqKsqyOVeikFRFbNy40XBwcDCWLl1qGIZhJCUlGU2bNjWmTJlicWVV11//+lcjKSmp8M/vvfee4eTkZOzYsaNwbPr06Yafn5+xZ88ewzAMY82aNYazs7OxZMmScp9T0+3bt89o1qyZ8fjjj1/0A3D79u2Go6OjMWfOHMMwDCM5OdkICgoyJk6cWO5zarLHHnvMCAgIMPbt22cYhhnO33///cKv5+XlGa1atTLuv/9+wzAMw263GyNGjDDatWtn2Gy2cp1Tk7Vq1cq49957C99rXFyc4ezsbHz++eeFcx544AGjQ4cORmpqqmEY5s8XFxeXwr+b8pxTU7z44ovGtm3bjLfeeqvYkGSz2Yx27doZo0aNMux2u2EYhnHPPfcYrVq1MvLz8yt9TkkoJFURjzzyiBEWFlZk7P/+7/8Mf39/iyqqfgoKCgwnJyfjk08+KRzr0qWL8dhjjxWZd+ONNxq33357uc+pyXJzc41u3boZ//nPf4x///vfF/0AnDx5shEcHFxk7LXXXjN8fX0L/3deXnNqqsOHDxuOjo4XnQ39o59++skAinzAxsTEGICxZs2acp1Tk3l7exszZ84sMtagQQNj2rRphmEYRlZWluHu7l4koNpsNsPf3994+eWXy3VOTXSpkPTbb78ZgBEfH184tmfPHgMwVqxYUelzSkLXJFUR0dHRdO3atchYjx49OHnyJMePH7eoquolOjoam81GcHAwAPn5+ezYsaPY4xodHV2uc2q6KVOm0LJlS+6///5iv36p79+0tDQOHDhQrnNqqlWrVmG32xk6dCiHDx8mJiaGc+fOFZkTHR2Nr68vrVu3LhwLDQ3F1dW18HuxvObUZK+++ipvvvkmX3zxBStWrOCRRx6hSZMm3HfffQDs2rWLnJycIt+Ljo6OdO3atfD4lNec2iQ6Oho3Nzc6duxYONamTRt8fHyKfG9W1pySUEiqIs6cOUP9+vWLjP3+58tdVCimzMxMxo0bx3XXXUe/fv0A8yJ4m81W7HH9/ZiW15ya7Mcff2TBggV88MEHl5xTku/f8ppTUx07dgwfHx+ee+45+vTpw7333kujRo2YOnVq4Zzijg8U/V4srzk12dChQ2nVqhUvvPACzz33HF9//TXjx4+/6Hvtcv/my2tObVKZ37/l9T3uXOKZUqFcXFzIyckpMpadnQ2Aq6urFSVVGzk5Odxxxx3k5eUxf/58HBwcAPOY/v71P8rOzi48puU1p6bKzc3l/vvvZ+LEiezYsQOAxMRECgoKWLt2LW3atKFRo0Yl+v4trzk1lYuLC+np6bi4uHDo0CEcHR354YcfGDp0KD169GDAgAHFHh+4+Pu1PObUVLm5ufTv359BgwaxfPlynJyc2LlzJz179sTJyYlx48bpZ0cFqczv3/L6HteZpCoiMDCQpKSkImNJSUk4OjrSvHlzi6qq+nJzc7njjjs4cuQIv/zyC40aNSr8mq+vL35+fsUe1xYtWpTrnJoqPz+fNm3asHz5cl588UVefPFFvv/+ezIzM3nxxRfZtm0bcOnvX6DwGJXXnJoqKCgIgEceeQRHR/NH8+DBgwkICGDNmjWAeXxOnz5dpN1FZmYmaWlpRY5hecypqeLj40lMTOSxxx7DyckJgA4dOtC/f3+WLl0KmMcHuOy/+fKaU5sEBgZy9uxZsrKyCsdyc3NJSUkpcswqa05JKCRVEQMHDmTlypVF/kKXLFlCnz598PDwsLCyquv3gJSYmMivv/5K48aNL5pz44038u233xb+uaCggO+//56BAweW+5yayMvLi7Vr1xb5NX78eHx9fVm7di233HILYH7//vbbb0X6+ixZsoTw8PDCU97lNaemuv7663F1dS3ygZqVlcXZs2dp2LAhAAMGDCA/P59ly5YVzlm6dCmOjo7ccMMN5Tqnpvr9WB49erTI+NGjRwu/FhQURHBwcGFoAjh+/DibN28u/DdfXnNqkxtuuAFHR0e+++67wrEffviBgoICBgwYUOlzSqTEl3hLhUpPTzdatWplDBo0yFiyZInxwgsvGM7Ozsbq1autLq3KuvXWWw1vb29jwYIFxpo1awp/HT58uHDO9u3bDU9PT+Oxxx4zli5datx5551Go0aNjOPHj5f7nNqiuLvbsrOzjQ4dOhjXXnutsXjxYuMvf/mL4eTkZPz444/lPqcme+WVV4zAwEDjs88+M7777jvjlltuMQICAoyUlJTCOY8//rjRuHFj47PPPjM+/fRTo379+sbkyZOL7Ke85tRUt99+uxEQEGB8+umnxo8//mg89NBDhrOzs7F58+bCOQsXLjScnZ2Nf/7zn8aiRYuMHj16GBEREUVuHy+vOTXFjh07jDVr1hiTJk0yfH19C38mZ2ZmFs55+umnjQYNGhiffvqp8dlnnxn+/v7GE088UWQ/lTnnShwMwzDKFAml3J04cYLXXnuNuLg4/P39GT9+PH369LG6rCrr+uuvp6Cg4KLxRx55pPAuFYDY2FjeeustDh8+TNu2bXn++edp2bJlkW3Ka05tMG/ePL744osi/0MDOH36NK+//jrR0dHUr1+fxx57jP79+1fInJrsiy++YMGCBeTn5xMaGsrkyZMLz3CA2Sn6vffe4/vvv8fBwYHbbrutyBJdec6pqfLy8vjwww9ZvXo16enptG7dmscff5zOnTsXmbd8+XI+/vhjzp49S/fu3XnhhRfw8/OrkDk1wQsvvMC6desuGv/8888Lf1ba7XY+/PBDli5dimEYDBkyhMcff7xw6bOy51yJQpKIiIhIMWr+fxlEREREykAhSURERKQYCkkiIiIixVBIEhERESmGQpKIiIhIMRSSRERERIqhkCQiIiJSDIUkESk3eXl5zJs3j9TUVKtLISEhgW+++Ybly5eXaL7dbmfevHmkpKQA5fNeqtLxEJHSU0gSkVI5efIkK1eu5KeffuLkyZNFvpaens6YMWNITEy0prjzZs+eTffu3fniiy/49ddfS7RNXl4eY8aMISEhASj9e8nJyWHevHlFnjtXVY6HiJSNs9UFiEj18dJLL/Hmm2/So0cP6tSpQ1xcHNdeey0ffvghnp6euLm5MWrUKOrWrWtpnR999BEvvPACU6ZMKfM+SvteUlNTGTNmDHFxcfj6+pZpHyJStSgkiUiJrFq1in/84x+sXbu28JmCdrudr776itzc3MKQdMcddxSGhE2bNnHw4MGL9tWrVy8CAwMB82zLhg0bAAgLC8Pf3/+KtZw4cYLNmzfj5uZG79698fb2BiA/P5+vv/6agwcPsn//fubNm0doaCjt27cvdj8JCQns3LmT1q1bExwcXORr//tefpeRkcHGjRsxDINevXrh7e2NYRgsWbIEgGXLlhEfH0/Dhg3p169fsfu4VP0AmZmZfPvttwwdOpTk5GR27dpF8+bNCQ0NLbKP+fPnY7fbcXJyIjAwkPDwcFxcXIrdT2JiInv37qVr167ExMTQoUMHQkJCiuzvm2++oXPnzhcdB5FarVSPwxWRWuudd94x3N3dDbvdfsk5p06dMgAjOjraMAzDePfdd41Ro0YV/ho0aJABGHPmzDEMw3xCet26dY1rr73WuPnmmw1fX19j5syZV6zDw8PDuP76643w8HCjXr16xq+//moYhmFkZmYao0aNMry8vIxu3boZo0aNMpYsWVLsfl577TXDzc3NGDBggNGpUyfjlltuMQBjw4YNxb4XwzCMBQsWGL6+vkZYWJgxaNAgIyQkxNi4caNhs9mM22+/3QCMm2++2Rg1apTx8ssvF7uPy9VvGIZx8OBBAzBuvfVWo0OHDsaQIUMMLy8vY+LEiUXqj4yMNEaNGmXceeedRkhIiNGhQwfj8OHDF+1n6NChRtu2bY0RI0YYa9asMe6++25j2LBhRfYVGxtrAMbOnTsve+xFahuFJBEpkU2bNhkODg7GY489ZsTFxRUblooLBb8rKCgwBgwYYHTt2tXIysoyDhw4YNSpU8dYtWpV4ZwtW7YY7u7uxq5du4qtISEhwXBxcTHmzZtXODZx4kQjKCjIyMnJKRxr3bq18d57713yvezdu9dwcnIyvv32W8MwDMNutxtjxoy5bEhKSEgwXF1djenTpxfu58SJE4Xzjx8/bgBGXFzcJY9HSer/PdyMHTu28BivWrXKcHBwMA4dOlTs+7HZbMadd95pPPDAA4Vjv+9n5MiRhs1mKxxftWqV4eLiYiQnJxeOTZo0yejVq9clj5dIbaULt0WkRHr06MHcuXNZvXo1nTt3xtfXl1tvvZUVK1aUaPvJkycTHx/P4sWL8fDwYO7cudSvX59Tp06xYMEC5s+fz4EDB6hXrx5r1qwpdh9ff/01AQEBjBo1qnDsz3/+M4mJiWzatKnE7+Xrr78mJCSEoUOHAuDg4MBzzz132W3mzp1L48aNmTRpUuGYv78/PXv2LNXrlrT+Rx99FAcHBwD69u2Lo6Mje/fuLTJn586dfPfdd8yfP5+GDRuyefPmi15z/PjxODpe+FF/3XXXERQUxOeffw6YF6x/+eWXjB07tsTvQ6S20DVJIlJio0aNYtSoUSQlJbFx40Y+/fRTBg0aVHjty6X85z//4f333+fXX3+lefPmACQmJpKXl8fChQuLzO3Xrx8NGjQodj+HDh2iVatWRcb8/f2pU6cOhw4dKvH7OHz4MEFBQUXGWrZsecVtgoODC4NLWZSm/nr16hX+3snJCWdnZ3JycgDIzs7m1ltvJTo6mu7du+Pr68uRI0dITk6+6DWbNGly0dhDDz3Ep59+yuTJk1myZAk5OTlFgpuImBSSRKTUmjVrxp133snw4cPp1KkTc+bMuWRI2rhxI4899hjvvvsuvXv3Lhz38fGhbt26zJs3r8Sv26BBg4vOuOTm5pKVlXXJYFWc+vXrExUVVWTs7Nmzl93Gz8+vsIdSWZVX/Z9//jkJCQkcOnQILy8vAGbOnMlf//rXi+YWF+oeeOABXnrpJTZv3szs2bO56667ilw8LiImLbeJSIkcO3aMvLy8ImN2u528vDz8/Pwuuc3w4cN59NFHeeihh4p87eabb2bXrl2sXr26yHhGRgYZGRnF7q9v377Exsayf//+wrGFCxfi7u5OREREid9L3759iYqK4siRI4VjixYtuuw2gwYNYvv27cTExBQZP3XqFEBhWPn9bE9F1n/ixAmaNWtW+JpgLuWVlL+/P0OHDuUf//gHK1asuOjvRkRMOpMkIiWyadMmnnnmGe644w7at29Pfn4+8+fP59SpU0yYMKHYbR577DEKCgro3r17kTNGvXr14sYbb+SRRx5h6NChTJw4kdatW7Nnzx6++eYbfvrpp2LPbAwaNIjBgwczcOBAnnrqKdLS0nj99dd56aWXStQ64Hc33XQT1157LTfeeCMTJ07kxIkTfPrpp5fdZuDAgdx7770MGDCAJ598kkaNGrF48WLuu+8+IiMj8fLyom3btrz++usMGzYMf3//i27bL6/6hw4dyt///neeeuopOnXqxDfffENMTAxOTk4l3sfDDz/M4MGDCQkJoV+/fiXeTqQ2UUgSkRIZNmwYvXr14quvvmLLli04Oztzxx13sHDhwsKlov9tnhgaGoqnpyffffddkX01b96cwMBAPvjgA4YPH87333/P+vXr6dChAxs2bLjs0tPXX3/NZ599xrp163Bzc+Orr75iyJAhReYMHTr0iv1+vv32W2bNmsW2bdto3bo1GzZs4Pnnn7/kewHz2qrFixezfPlykpOTeeaZZxg4cGDh17/77js++ugjfvjhB4KDg+nRo8dF+7hS/XXq1GHUqFEXhcSRI0fSrFkzACIiIlizZg1ffPEF69atY8iQITz77LPMnTv3ivv53aBBg/D09OTBBx+87HESqc0cDMMwrC5CREQq1y+//MLNN9/MoUOHir24W0R0JklEpFY5ceIEK1as4PXXX2fs2LEKSCKXoQu3RURqkZMnT/Ljjz8yYsQIpk2bZnU5IlWalttEREREiqEzSSIiIiLFUEgSERERKYZCkoiIiEgxFJJEREREiqGQJCIiIlIMhSQRERGRYigkiYiIiBRDIUlERESkGApJIiIiIsX4fzT5FyoAFbO8AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -723,9 +726,7 @@ }, { "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "# Part 5: String To Tuple\n", "\n" @@ -733,7 +734,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -754,7 +755,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -813,12 +814,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -847,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -883,7 +884,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -897,7 +898,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -917,7 +918,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -1015,7 +1016,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -1053,13 +1054,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d365f01361e34553a29c8c1d741d0fc1", + "model_id": "91bd3ce8dd744f93aff71e9e64e7f5ef", "version_major": 2, "version_minor": 0 }, @@ -1073,7 +1074,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bc4e50b7c9d04ef6aff28154fdff42eb", + "model_id": "c25ed7377bcd4581adbb1dae89f379a6", "version_major": 2, "version_minor": 0 }, @@ -1087,7 +1088,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "45166513db844393836230348485d387", + "model_id": "c6a7d77d6c4843879bc92f8e88620c43", "version_major": 2, "version_minor": 0 }, @@ -1101,7 +1102,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c15165240d104839b33aa4ee04aa1969", + "model_id": "df454582b2b24afc86d6116800808257", "version_major": 2, "version_minor": 0 }, @@ -1115,7 +1116,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "edeb4e6992a44a328e0dcd96399fc1f7", + "model_id": "cdf7681087a14f208e54ed47c96b2ff3", "version_major": 2, "version_minor": 0 }, @@ -1129,7 +1130,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "df21d6f4096945bbbf0eb0ebf3368a34", + "model_id": "3f8b1c51b42f4c5f858b82de339382a3", "version_major": 2, "version_minor": 0 }, @@ -1143,7 +1144,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8f613417b5604e70887d6d2e3832610b", + "model_id": "9341a9539fea479789791a8834d9e0fe", "version_major": 2, "version_minor": 0 }, @@ -1157,7 +1158,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eb4420ca9fc34f0e9106c6152f0aff7c", + "model_id": "b32c2fefc3fe413692f877048b49f8d3", "version_major": 2, "version_minor": 0 }, @@ -1171,7 +1172,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f3fff0b0ee3c45c3a820f618f0d169dc", + "model_id": "e9f4c245539043fd9d940112ed0f18e0", "version_major": 2, "version_minor": 0 }, @@ -1185,7 +1186,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "13d277b0a55e405fbd31e10592e5cc8b", + "model_id": "2680fa5e1d5940e6bf45c2f76874e094", "version_major": 2, "version_minor": 0 }, @@ -1199,7 +1200,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9628bf57b85942ae8fbdf6db0067fe44", + "model_id": "0055f8f93d5745bb84c5f69e72a3d843", "version_major": 2, "version_minor": 0 }, @@ -1213,7 +1214,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0cce79ea4e4b44f5b077a8273529f57c", + "model_id": "28a526d221a24008bce9a59230abbbd0", "version_major": 2, "version_minor": 0 }, @@ -1227,7 +1228,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0f76aa032504fe997d1e3d87845b523", + "model_id": "ac6a5fd275884dc19b7e49b265771596", "version_major": 2, "version_minor": 0 }, @@ -1241,7 +1242,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "264bcfd6eb6d43d4a06b36bad856bc72", + "model_id": "00505849fa82430ca3e9a366d15466ce", "version_major": 2, "version_minor": 0 }, @@ -1255,7 +1256,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d15c53497af84ec9a77b1794bfaef7b9", + "model_id": "a56eac4174814b15ba447a6c1149b47b", "version_major": 2, "version_minor": 0 }, @@ -1269,7 +1270,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6d91d6f33a6d46e0b31aece1e1392a41", + "model_id": "e53329fd254a431b9e8e7f26a7a55114", "version_major": 2, "version_minor": 0 }, @@ -1283,7 +1284,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "918f3f154306415896420265c56eff12", + "model_id": "53462eb4c77949358b0a048bf363f904", "version_major": 2, "version_minor": 0 }, @@ -1297,7 +1298,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1b66b5e329884007b87eae7c8b317894", + "model_id": "5111eb1ed74f4a84be3de8c81b6d1310", "version_major": 2, "version_minor": 0 }, @@ -1311,7 +1312,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0b00f48c61cf41d189933e9113d8bb38", + "model_id": "7b352e98d952406fac9954fe2a3f2f6e", "version_major": 2, "version_minor": 0 }, @@ -1325,7 +1326,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1010c73b2e6240d188b5b9e6df57ed27", + "model_id": "6353e083c1da448a9a9600367ee69a78", "version_major": 2, "version_minor": 0 }, @@ -1339,7 +1340,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "923e25a7907842fd8010737003ae4a49", + "model_id": "65d81377d54344b0bba7169586c8d22d", "version_major": 2, "version_minor": 0 }, @@ -1353,7 +1354,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "667cc05be60f4d0088af9ba8a226ac0f", + "model_id": "beea9d305e314447ac7e0774f9761224", "version_major": 2, "version_minor": 0 }, @@ -1367,7 +1368,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "11709fb46fff405c8195dd9a7b54d39b", + "model_id": "911302eac0b1468da5c25b22e97564dd", "version_major": 2, "version_minor": 0 }, @@ -1381,7 +1382,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1638d089d7744c36819e8e2d574c3289", + "model_id": "ad0d81fe90f94298a341a360418785ed", "version_major": 2, "version_minor": 0 }, @@ -1395,7 +1396,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "784fb6a378ad4213b3b78887038e6341", + "model_id": "eeb51fb3d4614688b575d371a888f569", "version_major": 2, "version_minor": 0 }, @@ -1409,7 +1410,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a912115e525040888c0cb81bf5338c39", + "model_id": "c2f312a760ee42e9a6cd04f09ce62bf9", "version_major": 2, "version_minor": 0 }, @@ -1423,7 +1424,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2947a389cdc94f88b2ae49b43fa38c7d", + "model_id": "2102253f044b420fad59fdf6fb355b7d", "version_major": 2, "version_minor": 0 }, @@ -1437,7 +1438,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2e24aa80c03c4198b92a0ea0a5611602", + "model_id": "8127cbfd1d174a1ebf74445bc705bbfb", "version_major": 2, "version_minor": 0 }, @@ -1451,7 +1452,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a45887506ecd43b7b08c72707d834fa9", + "model_id": "030ed57f77854d76a61e652a142f5346", "version_major": 2, "version_minor": 0 }, @@ -1465,7 +1466,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6cb380331b7046d1a7e54189e2f02c14", + "model_id": "42d51766d0184b37bafbf5dc2d17e854", "version_major": 2, "version_minor": 0 }, @@ -1565,19 +1566,19 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[np.float64(0.03663942813873291), np.float64(0.028421545028686525)], [np.float64(0.3490354061126709), np.float64(0.29458606243133545)], [np.float64(3.453840160369873), np.float64(2.9241767644882204)]]\n" + "[[np.float64(0.03665416240692139), np.float64(0.03360826969146728)], [np.float64(0.3465502977371216), np.float64(0.30228404998779296)], [np.float64(3.503210759162903), np.float64(2.9717938184738157)]]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From f3e80224e6597f209156ab3551b2294ad76dc77d Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 17:22:59 +0100 Subject: [PATCH 022/112] Added new tests to cover all branches --- ...ring_misc_functions_in_rust_v_python.ipynb | 136 ++++++++---------- tests/test_utils.py | 24 ++++ 2 files changed, 87 insertions(+), 73 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index 6248c2255..c53ad5ee7 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -204,7 +204,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAb5hJREFUeJzt3Xd0VFXbxuHfpPcECJ3QeycJiBRBmhW7qEixACoidgV9lWJBFBUVLIANLIioCDZ67ymU0DshQEIIpNeZ8/1xXvOZV0qAJCeZ3NdaWXr27DPzZAiZm1OebTMMw0BERETESbhYXYCIiIhIUVK4EREREaeicCMiIiJOReFGREREnIrCjYiIiDgVhRsRERFxKgo3IiIi4lQUbkRERMSpuFldgBUcDgfHjx/H398fm81mdTkiIiJSCIZhkJqaSo0aNXBxOf/xmXIZbo4fP05ISIjVZYiIiMhliI2NpVatWud9vFyGG39/f8B8cwICAiyuRkRERAojJSWFkJCQ/M/x8ymX4ebvU1EBAQEKNyIiImXMxS4p0QXFIiIi4lQUbkRERMSpKNyIiIiIUymX19wUhsPhICcnx+oyyiV3d3dcXV2tLkNERMoohZtzyMnJ4dChQzgcDqtLKbeCgoKoVq2a+hCJiMglU7j5H4ZhcOLECVxdXQkJCblgkyApeoZhkJGRQUJCAgDVq1e3uCIRESlrFG7+R15eHhkZGdSoUQMfHx+ryymXvL29AUhISKBKlSo6RSUiIpdEhyX+h91uB8DDw8PiSsq3v4Nlbm6uxZWIiEhZo3BzHrrWw1p6/0VE5HIp3Mh5vffee/z8889WlyEiInJJdM2Nk/jyyy9Zu3YtYN5KHRISwu23306zZs0Ktf9HH31ElSpVuOeee/LH/vjjD8LDw7njjjuKpWYREZHioCM3TmLlypWsXr2ajh070rp1a2JiYmjVqhW//PJLofZfuHAh69evL+YqRUREip+O3DiR6tWrM2TIEAAee+wx0tLSGD9+PD4+PqxcuZI333yzwPxvv/2WuLg4KleuzLZt2zh8+HD+/q+//nr+vBUrVrBkyRLsdjt33303oaGhBZ4nJiaGH374gaSkJFq3bs2gQYPy73gC8/RW3bp1qVix4gWfR0REyr6oo2fYezKVezvUtqwGHblxYi1btiQ2Npb69eszYcIEYmJi8h9zOByMHj0aNzc3GjRoQIUKFahevTodO3akY8eO+eHkm2++YezYsVSqVInTp0/TsWNHoqKi8p/nzz//JDQ0lBMnTlC3bl2mTJlCly5dCnR3/uOPPxg5cuQFn0dERMq+uZHHuPezDbz0y3Y2HDxtWR06cnMRhmGQmWu35LW93V0v+64hu93O0qVLadmyJY0aNeKaa67hiy++4L333gNg8eLFnDx5koEDB1K5cmVCQkJo2LBh/pGbv1WsWJGlS5fm95rZv38/X3/9NaGhoRiGwciRIxk5ciSTJk0CYOjQodSrV49p06YxYsSIQj2PiIiUbXl2B2/9uZsZaw4B0Kd5VVrWDLSsHoWbi8jMtdP81YWWvPbO8dfh41H4P6I9e/YwZMgQ8vLy2LBhA8nJyfz++++AGTqeeeYZJk6ciLu7O1988QU333wzlStXvuBzXnvttQWa6DVp0oRjx44BEBcXx/79+7nvvvvyHw8KCuKmm25i5cqVBcLNhZ5HRETKruTMXJ74PppVe08BMLJHQ57q1RgXF+taeui0lBMJCAigY8eOXHvttUydOpWDBw/mHxm56667yM3NZcGCBSQlJfHrr7/y0EMPXfQ5/3ntDICrq2t+o8O/l0gIDg4uMCc4OJj4+PhCP4+IiJRNB06lcfvUtazaewovdxem9G/HM32aWBpsQEduLsrb3ZWd46+z7LUvxT8vKP5fXl5eDBgwgC+++IK4uDgqVqzIDTfckP/45Zz+CgkJAeDIkSPUqVMnf/zIkSPUrm3dhWQiIlL8lu9JYOT30aRm5VEj0Itpg8ItPRX1Two3F2Gz2S7p1FBpNnToUEJDQ9mzZw+DBw8ucJqoYsWKJCUlXdLzVa5cmWuuuYYPPviALl264OLiwq5du/jjjz+YPXt2UZcvIiKlgGEYzFh9iAl/7sJhQHidCnwyIIzK/p5Wl5avVHxqHzp0iLS0NOrVq4efn98F5x44cIATJ04UGPP19aVdu3bFWaJTaN26Ne3atSMiIoIHH3ywwGO33norAwYMICcnBz8/vwK3gl/Ixx9/TJ8+fQgNDaVhw4YsWbKE/v37c/vttxfHtyAiIhbKyrXz0i/b+TkqDoB7wkMYf1sLPN1K1wLHloab+fPn8+KLL+JwOHBzc+Pw4cM8++yzjB8//rz7vPPOO8ydO5emTZvmj9WvX5+ZM2eWRMml1kMPPURqaupF57Vr1w4vLy8aN25cYPyOO+4gIiKCrVu3kp6ejre3N88+++y/rqe5//77SU9Pz99u0aIF+/btY9myZZw5c4ZXXnmFNm3aFNinMM8jIiKlW3xKFo/MimRL7FlcXWy8clMzBneqWyrXArQZhmFY9eLTpk3j+uuvz78+Y9myZfTs2ZPFixfTq1evc+7z6KOPkpiYyNy5cy/7dVNSUggMDCQ5OZmAgIACj2VlZXHo0CHq1auHl5fXZb9GaZSSkkKdOnWYOnUq/fv3t7qcC3LmPwcRkbJma+xZhs2KID4lm0Bvd6b2D6VLo+CL71jELvT5/U+WHrkZNmxYge2uXbvi5uZGXFzcBffLysoiKiqKwMBA6tWrh4uLbvq6mOeff57FixdTv359+vXrZ3U5IiJSRsyLjuOFn7aRk+egURU/pg8Kp26wr9VlXZDl19ycPXuWmJgYUlJS+OKLL2jTpg133nnnBfdZuHAhR48e5eTJk3h6evLZZ59x4403nnd+dnY22dnZ+dspKSlFVn9ZERoaSocOHbjhhhtwc7P8j11EREo5u8Pg7YW7+WzlQQB6Nq3C5Hvb4u/lbnFlF2f5p9yePXsYNWoUiYmJJCQkMGnSpAteVHzdddcxfvx4qlSpgt1uZ/To0dx9991s27aNBg0anHOfCRMmMG7cuOL6FsqEfzbaExERuZCUrFye/D6a5XvMxnzDuzfg2T5NcLW4f01hWXrNzf9asWIF1113HTNnzuSee+4p1D52u51KlSoxZswYnn766XPOOdeRm5CQkHJ3zU1Zoj8HERFrHEpMZ8jXmzlwKh1PNxfevqs1t7ataXVZQOGvuSlVF6t0796dDh068OeffxZ6H1dXVypVqnTB63Q8PT0JCAgo8CUiIiIFrd53ilunrOHAqXSqBXjx46NXl5pgcyksCzcOh4OsrKwCY7m5uRw9epRKlSrlj+3fv5/o6Gjgv4tYZmYW2Gffvn0cOXKEli1bFn/RIiIiTsgwDL5Yc4jBX2wiJSuPdrWDmD+iM61rBVld2mWx7Jqb7Oxs2rdvz5AhQ2jevDlnz55l2rRpZGRkFFhw8a233mLDhg3ExMSQm5tLWFgYQ4YMoUWLFhw9epQ333yT0NBQXVMiIiJyGbLz7Pznlxh+jDQXM74rrBav39YSr0tcAqg0sSzceHt7s2jRIqZMmcLChQvx9fXl2muv5Ycffihw5KZRo0bk5OQA4OHhwdKlS/noo4+YPHkyFSpU4IUXXmDIkCG4u5f+q7dFRERKk4TULB6dFUnU0bO42OClG5vxcJd6pbIx36UoVRcUl5Ty2sSvLNGfg4hI8YqJS2bozAhOJGcR4OXGR/1D6da4stVlXVCZaOInRSciIoLDhw8D4O7uTq1atWjdunWRHtGKi4sjMjKSW265pcieU0RESt6Crcd5fu5WsnId1K/sy4xB4dSvfOG1HcsShRsnMWXKFH7//Xe6detGXl4e0dHRuLm5MX/+fFq0aFEkr7F+/XqGDBnC2bNni+T5RESkZDkcBu8u3sPU5QcA6N6kMh/e146AMtCY71Io3DiRFi1a5K+5lZOTQ6dOnXjyySdZsmQJYN55dujQIXr37p2/T3x8PGvXruWOO+7IH0tJSSEqKgowOxsHBARw6tQpNmzYQG5ubv5rNG3aVHepiYiUEalZuTz9w1aW7IoH4JFr6vPC9U3LTGO+S6Fw46Q8PDzo06cP06dPzx/77bffmDFjBjExMflj0dHR9OvXj7y8PACWL1/OnXfeSZMmTfDz8+PAgQN8+OGH1KtXj7Vr15Kbm8vs2bMBuP322xVuRETKgCOn0xk6M4K98Wl4uLkw8c5W3N6ultVlFRuFm4sxDMjNsOa13X3gCq5YP3jwIMHBl7Zq64QJE3j44Yd55513AEhOTmbjxo20aNGCZ599liFDhlzRiuwiIlKy1u1PZPh3UZzNyKWKvyfTBoXTNiTI6rKKlcLNxeRmwJs1rHntl46DR+FXXj116hRz584lLy+PjRs38vPPPzNr1qxLeklPT0+OHDlCZmYm3t7eBAYG0qdPn0utXERELGYYBjPXH2H8bzuxOwza1Apk2qBwqgY4/x2oCjdOJCEhgdmzZ5Odnc26deu44YYbuP322y/pOd5++20eeughKleuTOfOnbn55psZOnSobscWESlDcvIcjJkfw/ebYgG4vV1NJtzRqkw35rsUCjcX4+5jHkGx6rUvwT8vKI6Pjyc8PJxRo0bx3nvvAeDi4oLD4Siwz/8ugdGsWTPWr1/PiRMnWLZsGW+88QYLFy7kt99+u4JvRERESkpiWjaPfRPJ5sNnsNlg1PVNGXZN/TLfmO9SKNxcjM12SaeGSouqVavy7rvv0r9/f4YOHUqzZs2oWbMmcXFxZGdn4+npCcDKlSsL7HfixAmqV69O9erVuf/++3E4HDz55JMA+Pn5FVhdXURESpcdx5MZNjOSuLOZ+Hu68eF97bi2aRWryypxCjdOrF+/fkyaNInRo0czb948evfujZeXF/feey+33347ERERzJkzp8A+AwYMICQkhM6dO2O323n//fe58847AWjVqhV2u51XXnmFNm3a6FZwEZFS5I/tJ3h2zlYyc+3UC/Zl+qBwGlZxnsZ8l8KyVcGlaLVv355u3br9a3zy5Mm4u7tz4sQJAgIC2LhxIw0bNmTFihU0adKE+fPn54cXgIULF9KjRw82bdpEdHQ0r7zyCp988gkANWvW5M8//yQxMZEffviBrVu3ltj3JyIi5+ZwGLy3eC/Dv40iM9dO10bBzBveudwGG9DaUlpbqpTSn4OIyMWlZ+fxzJwtLNxhNuYb0qUeo25oipurcx670NpSIiIiTiw2KYOhMyPYfTIVD1cXXr+9Jf3CQ6wuq1RQuBERESljNhw8zfBvo0hKzyHYz5PPBoYRVqeC1WWVGgo3IiIiZcg3G44wdv4O8hwGrWoGMm1QGNUDva0uq1RRuBERESkDcu0Oxi3YwTcbjgLQt00N3r6zNd4e5aMx36VQuBERESnlktJzGP5tJBsOJmGzwXN9mjC8e4Ny1ZjvUijcnEc5vImsVNH7LyJi2nUihaEzIzh2JhNfD1c+uLcdvZpXtbqsUk3h5n+4upqH93JycvD21jlMq2RkmCuxu7u7W1yJiIh1Fu44ydM/bCEjx06dSj5MHxRO46r+VpdV6inc/A83Nzd8fHw4deoU7u7uuLg4Z6+A0sowDDIyMkhISCAoKCg/bIqIlCeGYfDRsv28t3gvAJ0bVmJq/1CCfDwsrqxsULj5HzabjerVq3Po0CGOHDlidTnlVlBQENWqVbO6DBGREpeRk8fzP27j9+0nAHigU11evqkZ7k7amK84KNycg4eHB40aNSInJ8fqUsold3d3HbERkXIp7mwmQ7+OYOeJFNxdbbx2a0vu7VDb6rLKHIWb83BxcVHbfxERKTGbDyfx6KxITqfnUMnXg08HhtG+bkWryyqTFG5EREQsNnvTUV75NYZcu0Hz6gFMHxxOzSDd1HK5FG5EREQskmt38Mbvu/hq3WEAbmpVnXfubo2Phz6er4TePREREQucSc/h8e+iWHfgNADP9m7MiB4N1ZivCCjciIiIlLC98akMnRnBkdMZ+Hi48l6/tlzfUneIFhWFGxERkRK0ZGc8T86OJj3HTq0K3swYHE7TagFWl+VUFG5ERERKgGEYfLziAJMW7cEw4Kp6FflkQBgVfdWYr6gp3IiIiBSzzBw7L/y0jQVbjwMwsGMdXu3bXI35ionCjYiISDE6kZzJsJmRbI9Lxs3FxthbWjCgYx2ry3JqCjciIiLFJPLIGR6ZFUliWjYVfNz5ZEAYHetXsrosp6dwIyIiUgx+jIjl5V9iyLE7aFrNn+mDwgmp6GN1WeWCwo2IiEgRyrM7mPDnbj5fcwiA61pU5b1+bfH11EduSdE7LSIiUkSSM3IZ8X0Uq/clAvBkz0Y82bMRLi5qzFeSLA03OTk5fPXVVyxcuJC0tDRatGjBE088Qb169S6436pVq5g6dSrx8fG0atWKl156ierVq5dQ1SIiIv+2PyGVoTMjOZSYjre7K+/2a8ONrfTZZAVL70F78MEH2blzJw888ABPPfUUhw4don379sTGxp53n+XLl9OzZ08aNWrE888/z759++jcuTOpqaklWLmIiMj/W747gdunruNQYjo1g7yZ+9jVCjYWshmGYVj14hkZGfj4/P/FVTk5Ofj6+jJ9+nQeeOCBc+7TuXNnQkJCmD17dv5zVK9enVdffZVnn322UK+bkpJCYGAgycnJBASoK6SIiFwewzCYtuogb/21G8OA9nUr8MmAMIL9PK0uzSkV9vPb0iM3/ww2AOvXr8dut9OqVatzzs/IyGDDhg307du3wHP06tWLJUuWFGutIiIi/5SVa+eZOVuZ8KcZbO7rEMK3Qzoq2JQCll9QvGHDBp566ilSUlI4efIk8+bNIyws7JxzY2NjcTgc1KhRo8B4jRo1WLp06XlfIzs7m+zs7PztlJSUoileRETKpZPJWTwyK4Ktx5JxdbExpm9zBnasoxW9SwnL+z43a9aMyZMn8/bbb3PNNdfwxBNPcPTo0XPOzc3NBcDTs2Aq9vb2zn/sXCZMmEBgYGD+V0hISNF9AyIiUq5siT3LLVPWsPVYMkE+7sx6qAODrq6rYFOKWB5uAgMD6dixIzfffDM//fQTHh4efPDBB+ecW7FiRQCSkpIKjJ8+fZpKlc7f8XH06NEkJyfnf13ogmUREZHz+TnqGP0+W09CajaNq/ox//EudGoYbHVZ8j8sDzf/5OrqSuXKlUlMTDzn4zVq1KBatWps3ry5wPjGjRtp167deZ/X09OTgICAAl8iIiKFZXcYTPhjF8/M2UpOnoNezary8/DO1K6kjsOlkWXhJjMzk3fffbfA6aT58+ezefNmbrjhhvyxCRMmcP/99+dvP/TQQ8yYMYO4uDgAfvrpJ3bu3MlDDz1UcsWLiEi5kZyZy8Nfb+azVQcBGHFtQ6YNDMNPHYdLLcv+ZDw9PTlz5gw1atSgevXqnD17lszMTCZOnMi9996bP+/AgQNs3bo1f/vVV19l3759NGzYkJCQEI4dO8aUKVNo3769Fd+GiIg4sYOn0hgyM4KDp9Lxcnfhnbva0LdNjYvvKJaytM8NmBcJ7927F19fX2rVqoWbW8G8dfDgQdLS0mjdunWB8ePHjxMfH0/Dhg3x9/e/pNdUnxsREbmYlXtPMeK7KFKz8qge6MW0geG0qhVodVnlWmE/vy0PN1ZQuBERkfMxDIPP1xzizT924TAgrE4FPhkQShV/L6tLK/cK+/mtE4YiIiL/lZVr5+VfYvgp6hgAd4fV4vXbW+Lp5mpxZXIpFG5ERESAhJQsHvkmkuijZ3GxwX9uas6DndW/pixSuBERkXJv27GzDJsZycmULAK83Jh6fyhdG1W2uiy5TAo3IiJSrv26JY4X5m4jO89Bg8q+zBjcnnrBvlaXJVdA4UZERMolh8Ng0qI9fLziAAA9mlZh8r1tCfByt7gyuVIKNyIiUu6kZuXy1OwtLN2dAMCj3Rrw/HVNcHXR9TXOQOFGRETKlcOJ6QyZGcH+hDQ83Fx4+87W3NauptVlSRFSuBERkXJjzb5EHv8uiuTMXKoGeDJtYDhtQoKsLkuKmMKNiIg4PcMw+GrdYV7/fRd2h0HbkCCmDQyjSoAa8zkjhRsREXFq2Xl2Xp23gx8iYgG4o11N3ryjFV7uasznrBRuRETEaZ1KzeaxbyKJOHIGFxuMvqEZQ7rWU2M+J6dwIyIiTikmLplhMyM4npyFv5cbH93Xju5NqlhdlpQAhRsREXE6v287wbM/biEr10H9YF+mDw6nQWU/q8uSEqJwIyIiTsPhMHh/yV4+WrYfgGsaV+aj+9oR6K3GfOWJwo2IiDiFtOw8nv5hC4t3xgMwtGs9Rt3QTI35yiGFGxERKfNikzIY8nUEe+JT8XB1YcIdrbgzrJbVZYlFFG5ERKRMW3cgkce/jeJMRi6V/T35bGAYobUrWF2WWEjhRkREyqxZ6w8zdsFO7A6D1rUCmTYwnGqBasxX3inciIhImZOT52Dsgh18t/EoALe2rcHEO1urMZ8ACjciIlLGnE7L5rFvo9h0KAmbDV64rimPdquvxnyST+FGRETKjF0nUhjydQRxZzPx83Tjg3vb0rNZVavLklJG4UZERMqEv2JO8MycrWTk2KlbyYfpg8JpVNXf6rKkFFK4ERGRUs3hMPhw2T4mL9kHQJeGwUzp344gHw+LK5PSSuFGRERKrYycPJ6ds5U/Y04C8GDnurx8YzPcXF0srkxKM4UbEREplY6dyWDozEh2nUjB3dXGG7e1ol/7EKvLkjJA4UZEREqdTYeSePSbSJLScwj28+DTAWGE161odVlSRijciIhIqfL9pqO8Mi+GPIdBixoBTBsUTs0gb6vLkjJE4UZEREqFXLuD137bycz1RwC4qXV1Jt3VBm8PNeaTS6NwIyIiljuTnsPwb6NYf/A0AM/1aczj1zZUYz65LAo3IiJiqT0nUxkyczOxSZn4erjy/j1t6dOimtVlSRmmcCMiIpZZtOMkT/+whfQcOyEVvZkxqD1Nqqkxn1wZhRsRESlxhmEwdfl+Ji3aC8DV9Svx8f2hVPBVYz65cgo3IiJSojJz7Dw/dyu/bTsBwOCr6/Cfm5vjrsZ8UkQUbkREpMQcP5vJ0JkR7DiegpuLjfG3tqT/VbWtLkucjOXhJjU1lS1btuDm5kbLli3x97/wudatW7dy6NChAmMBAQH06NGjOMsUEZErFHkkiUdmRZKYlkNFXw8+uT+Uq+pXsroscUKWhRvDMHjmmWeYPXs2jRo1IiMjgwMHDvDRRx8xYMCA8+73ySefsGDBAtq3b58/VqdOHYUbEZFSbM7mWF6et51cu0HTav7MGBxOrQo+VpclTsrScFOnTh0OHjyIt7fZefKDDz7goYceolu3boSEnH/9kKuvvpq5c+eWVKkiInKZ8uwO3vhjF1+uPQzADS2rMenuNvh6Wn7iQJyYZVdvubi48NRTT+UHG4D77ruP3Nxctm/ffsF9U1JSWLRoERs3biQtLa24SxURkctwNiOHB77cnB9snurViKn9QxVspNiVqp+wlStXAtC0adMLztu4cSNvvfUWcXFxnDp1iilTptC/f//zzs/OziY7Ozt/OyUlpWgKFhGRc9qfkMqQryM4fDoDb3dX3r+nDde3rG51WVJOlJr77mJjYxk5ciRDhgyhfv3655135513EhcXx7Jly9izZw8vvPACDz74IDt37jzvPhMmTCAwMDD/60KnvERE5Mos3RXPbVPXcfh0BjWDvPnpsU4KNlKibIZhGFYXER8fT/fu3alduzbz58/H09Oz0PsahkFwcDCjRo3i+eefP+eccx25CQkJITk5mYCAgCuuX0REzN/Hn648yNsLd2MY0KFeRT65P5RKfoX/nS5yISkpKQQGBl7089vy01IJCQn06NGDWrVqMW/evEsKNgA2m43AwEASEhLOO8fT0/OSn1dERAovK9fOiz9t49ctxwHof1VtxvZtgYdbqTlBIOWIpeHm1KlT9OjRgxo1ajB//vwCFxf/bcuWLSQlJdGjRw8cDgdnz56lYsWK+Y9v3bqVw4cPExoaWpKli4jIf51MzmLYrAi2HUvGzcXGmFtaMLBjHavLknLMstNS2dnZdOjQgZMnTzJ58uQCwaZdu3bUqWP+xRgyZAgbNmwgJiaG3NxcWrVqxR133EGLFi04evQokydPpk2bNvzxxx+4uRUuqxX2sJaIiFxY1NEzPDIrklOp2VTwcWfq/aF0ahBsdVnipEr9aamcnBzq1atHvXr1+OGHHwo85ufnlx9u2rVrh6+vLwDu7u5s2rSJGTNm8Ndff1GhQgWmTJnCXXfdhc1mK/HvQUSkPJsbeYyXft5Ojt1Bk6r+TB8UTu1Kaswn1isVFxSXNB25ERG5fHaHwVt/7mL6anMpnD7Nq/LePW3xU/8aKWal/siNiIiUPcmZuYz8PpqVe08BMLJHQ57q1RgXFx09l9JD4UZERArlwKk0hn4dwcHEdLzcXZh0dxtubl3D6rKktMlKgRNboN41lpWgcCMiIhe1fE8CI7+PJjUrjxqBXkwbFE7LmoFWlyWlSV4ORHwBq96GvGwYuQX8KltSisKNiIicl2EYzFh9iAl/7sJhQHidCnwyIIzK/uodJv/lcMDOX2DpeDhz2Byr1AhSjyvciIhI6ZKVa+elX7bzc1QcAPeEhzD+thZ4urlaXJmUGodWweJX4Xi0ue1XFbqPgnaDwNW6iKFwIyIi/xKfksUjsyLZEnsWVxcbr9zUjMGd6qrthpjid8DiMbB/sbnt4Qedn4SOw8HTz9raULgREZH/sTX2LMNmRRCfkk2gtztT+4fSpZEa8wlwNhaWvwlbvwcMcHGDsAeh24uWnYI6F4UbERHJNy86jhd+2kZOnoNGVfyYPiicusG+VpclVss8A6vfg42fgf2/C1E3vw16vgqVGlha2rko3IiICHaHwdsLd/PZyoMA9Gxahcn3tsXfy93iysRSuVmwaRqsfheyzppjdbpA7/FQK8zS0i5E4UZEpJxLycrlye+jWb7HbMw3vHsDnu3TBFc15iu/HA7YPgeWvQ7JseZY5WbQexw06gOl/NorhRsRkXLsUGI6Q77ezIFT6Xi6ufD2Xa25tW1Nq8sSqxgGHFgKi8dC/HZzzL8G9HgZ2twHLmXjTjmFGxGRcmr1vlM8/m0UKVl5VAvwYtqgMFrXCrK6LLHK8S3mbd2HVprbnoHQ5Sno+Bi4e1tZ2SVTuBERKWcMw+DLtYd5/fedOAxoVzuIzwaEUSXAy+rSxApnDsPS1yBmrrnt6gHth8I1z4FPRUtLu1wKNyIi5Uh2np3//BLDj5HHALgrrBav39YSL/eycbpBilD6aVj1DmyeAY5cc6xVP+jxH6hQx9rarpDCjYhIOZGQmsWjsyKJOnoWFxu8dGMzHu5ST435ypucDNjwMaz9ALJTzLH615oXC1dvY21tRUThRkSkHIiJS2bozAhOJGcR4OXGR/1D6da49DRdkxJgz4Ot35lN+FJPmGPVWpm3dTfoYW1tRUzhRkTEyS3Yepzn524lK9dB/cq+zBgUTv3K1rfIlxJiGLD3L1gyFk7tNscCa0PPV6DlXeDiYml5xUHhRkTESTkcBu8u3sPU5QcA6N6kMh/e144ANeYrP45FwKJX4Og6c9u7AnR9DjoMBTfnXdld4UZExAmlZefx1OwtLNkVD8Aj19TnheubqjFfeZG4H5aOg13zzW03L7jqUejyNHgHWVpaSVC4ERFxMkdOpzN0ZgR749PwcHNh4p2tuL1dLavLkpKQlgArJ0LkV+DIA2zQ9n64djQElp+fAYUbEREnsm5/IsO/i+JsRi5V/D2ZNiictiFBVpclxS07DdZPgXUfQU6aOdboOug1Fqo2t7Q0KyjciIg4AcMwmLXhCOMW7MTuMGhTK5Bpg8KpqsZ8zs2eC1Ffw4qJkJ5gjtUIhT6vQd0u1tZmIYUbEZEyLifPwZj5MXy/yVzg8PZ2NZlwRys15nNmhmFeT7N0PJzeb45VrA89X4Xmt5X6hS2Lm8KNiEgZlpiWzWPfRLL58BlsNhh1fVOGXVNfjfmc2ZF15hpQxzab2z7B0O1FCHsA3DwsLa20ULgRESmjdhxPZtjMSOLOZuLv6caH97Xj2qZVrC5LikvCbrNXzd4/zW13H7h6BHR6ArwCLC2ttFG4EREpg/7YfoJn52wlM9dOvWBfpg8Kp2EVNeZzSiknYMWbEP0NGA6wuULoIOg+CvyrWV1dqaRwIyJShjgcBpOX7uPDpfsA6NoomCn3hRLoo8Z8Ticr2Vz/af3HkJdpjjW9GXqOgcqNra2tlFO4EREpI9Kz83hmzhYW7jAb8w3pUo9RNzTFzdX52ueXa3nZEPEFrHwbMpPMsZCO5hpQta+ytrYyQuFGRKQMiE3KYOjMCHafTMXD1YXXb29Jv/AQq8uSouRwwI6fzTugzh4xx4Ibm71qmtxY7u+AuhQKNyIipdyGg6cZ/m0USek5BPt58tnAMMLqVLC6LClKB1fA4jFwYou57VcVuo+GdgPBVR/Vl0rvmIhIKfbNhiOMnb+DPIdBq5qBTBsURvVAb6vLkqJycrsZag4sNbc9/KHzk3D1cPDwtba2MkzhRkSkFMq1Oxi3YAffbDgKQN82NXj7ztZ4e6gxn1M4GwvL34CtswEDXNwg/GHo9gL4BltdXZl3yeHm8OHDzJkzh1WrVnHs2DEAQkJCuOaaa+jXrx916tQp8iJFRMqTpPQchn8byYaDSdhs8FyfJgzv3kCN+ZxB5hlY/S5snAb2bHOsxR3Q8xWzw7AUCZthGEZhJh48eJAXXniBX3/9lWbNmtG+fXuqVq0KQHx8PJs2bWL37t3cdtttTJw4kfr1S+8fUkpKCoGBgSQnJxMQoMZHIlJ67D6ZwpCvIzh2JhNfD1c+uLcdvZpXtbosuVK5WbDpMzPYZCWbY3W7Qu9xUDPM2trKkMJ+fhf6yM3VV1/NsGHDmDRpEnXr1j3nnMOHD/P5559z9dVXEx8ff8lFi4iUZwt3nOTpH7aQkWOndkUfZgwOp3FVf6vLkivhsMO2H2DZG5Binu2gSnPoNQ4a9dYdUMWk0EduTp8+TaVKlQr1pIWde/jwYT744APWrVuHm5sbXbp04cUXX6RixYoX3O/XX3/lww8/JD4+nlatWvHaa6/RsGHDQtUGOnIjIqWLYRh8tGw/7y3eC0CnBpWY2j+UCr5aJ6jMMgzYv8S8WDhhhzkWUBOufRna3AsuunbqchT287vQnZ8uFFYMw2D//v2kpaVddO7f7HY71113HXXr1uWjjz7ijTfeYMWKFfTs2ZPs7Ozz7vfbb79x11130bdvXz7//HMMw6Br164kJSUV9lsRESk1MnLyGPFddH6weaBTXb5+qIOCTVkWFwVf94Vv7zKDjWegeaTmiUhod7+CTQko9JGbf9q8eTNfffUVU6dOBeC+++5j9uzZ+Pr68ueff9K1a9dCPU9eXh5ubv9/ZmzPnj00bdqUlStXcs0115xzn/DwcFq1asWXX34JQE5ODtWrV+eZZ57h5ZdfLtTr6siNiJQGcWczGfp1BDtPpODuauO1W1tyb4faVpcllyvpECx7DWJ+MrddPaDDMOj6LPhc+IyEFE6RH7n5p+eee47+/fsDsG3bNv78808iIiJ46aWXCh0wgALBBswjQMB57whITU0lKiqK6667Ln/Mw8ODXr16sWLFikv8LkRErLP5cBK3fLSGnSdSqOTrwXdDOyrYlFXpifDnizCl/X+DjQ1a32seqbnuDQUbC1xWn5vIyEhCQ0MBWLx4MXfccQdhYWE0adKEt95667KLeeWVV6hbty4dOnQ45+PHjh3DMAyqVSu4Cmq1atXYtm3beZ83Ozu7wKmulJSUy65RRORKzd50lFd+jSHXbtC8egDTB4dTM0iN+cqcnAzYMBXWfAA5qeZYgx7mKajqra2trZy7rHATEBDAwYMHadGiBQsWLODhhx8G4OzZs5d9mmfs2LH88ccfLFu2DE9Pz3POcTgcALi7F1z91sPDA7vdft7nnjBhAuPGjbusukREikqe3cHrv+/iq3WHAbipVXXeubs1Ph7qp1qm2PNgy7ew/E1IO2mOVWttLmzZ4FpraxPgMsNNv379uOmmm2jevDnbt2/n5ptvBuCvv/7ixhtvvOTne+utt3jnnXf47bffuOqq8694Ghxsdm08ffp0gfHExMT8x85l9OjRPPPMM/nbKSkphIRowTkRKTln0nMY8X0Ua/ebv7+e7d2YET0aqjFfWWIYsOdPWDIWEveYY0G1ocer0PJOcNHq7KXFZYWbSZMm0ahRI44cOcKECROoUMFcwO3AgQO8+uqrl/RcEydOZPz48fz2229ce+2FE2/VqlUJCQlh/fr13HLLLfnja9eu5frrrz/vfp6enuc9GiQiUtz2xqcydGYER05n4OPhynv92nJ9y2oX31FKj9hNsPhVOLre3PauCNc8D+0fBjd9vpQ2l3W3VFGZNGkSY8aMYcGCBfTo0eOcc1566SW2bNnCH3/8AcCbb77J+++/z+rVq2natCnTpk1j+PDhREdH06pVq0K9ru6WEpGSsmRnPE/9sIW07DxqVfBmxuBwmlbT750yI3EfLB0HuxaY225e0HE4dHkKvAItLa08KvIOxXfffTevvfYaTZs2veC8nTt3MmbMGH788ccLzjtz5gzPP/88fn5+DBs2rMBjEyZM4O677wYgISGBo0eP5j/24osvcuzYMdq0aYOvry+urq588803hQ42IiIlwTAMPl5xgEmL9mAYcFW9inwyIIyK6l9TNqTGw8q3IPJrMOxgc4G298O1L0FADaurk4sodLjp2LEjHTt2pF27dvTt25ewsDCqVq2KYRicPHmSzZs3M3/+fLZv384rr7xy0ecLDAxk375953ysSpUq+f8/YcIEsrKy8rddXV35+OOPeeedd0hKSqJ69er/uqVcRMRKmTl2XvhpGwu2HgdgYMc6vNq3Oe6uuiaj1MtOhXUfwbopkJtujjW+HnqNhSrNLC1NCu+STkudPn2azz77jNmzZxMTE1OgL02rVq247777GDp0aKGXabCKTkuJSHE5kZzJsJmRbI9Lxs3FxthbWjCgYx2ry5KLsedC5FewciKknzLHaoZB79egbmdLS5P/V9jP78u+5iY5OZm4uDhsNhs1atQgMLDsnHtUuBGR4hB55AyPzIokMS2bCj7ufDIgjI71S/c/9so9w4Cdv8LS8ZB0wByrWB96joHmt2phy1KmyK+5+V+BgYFlKtCIiBSnHyNiefmXGHLsDppW82f6oHBCKvpYXZZcyOG15h1QcRHmtm9l6PYihD0Aru4X3FVKt8sON6mpqSxatIiDBw/y/PPPA7Br1y6aNm2qvg0iUm7k2R1M+HM3n685BMB1LaryXr+2+HrqWsBSK2GX2atm71/mtrsvdHoCOo0AT39LS5OicVmnpXbv3k3v3r1xOBwcP348/9qbwYMHc9111+WvO1Va6bSUiBSF5IxcRnwfxep9iQA82bMRT/ZshIuL/oFXKiXHwYo3Yct3YDjA5moepen2IvhXtbo6KYRivebmhhtuoF27drzxxhu4uLjkh5vIyEiGDh1KVFTU5VdeAhRuRORK7U9IY+jMCA4lpuPt7sq7/dpwY6vqVpcl55KVDGvehw2fQN5/775t1te8ria4kbW1ySUp1nATFBTE4cOHCQoKwmaz5Yeb9PR0KlasWGCRytJI4UZErsTy3QmM/D6a1Ow8agZ5M21QGC1q6BrEUicvGzZ/Dqvegcwkc6z21eYaUCHnXqBZSrdivaDYMIz8APPP62sOHjyoi4xFxGkZhsG0VQd566/dGAa0r1uBTwaEEeyn9vulisMBMT/BsvFw9r9NYIObmL1qmtygO6DKgcsKN3369OHtt9/m3XffzQ83CQkJjBgxghtuuKFICxQRKQ2ycu2M/nk7v0THAXBfhxDG3dISDzc15itVDiyHJWPgxFZz26+a2VW47f3gqou8y4vLOi0VGxtL9+7dcXFxYf/+/XTp0oXo6GiqVavG6tWrqV69dJ931mkpEbkU8SlZDJsVydbYs7i62BjTtzkDO9bRnaGlyYltZqg5sMzc9vCHLk+a60B5+FpbmxSZYj0tFRISwrZt2/juu++IiIjA4XDQv39/Bg4ciJ+f32UXLSJS2myJPcuwmREkpGYT5OPOx/1D6dQw2Oqy5G9nj8Ky12HbHMAAF3dzpe5rngdf/TmVV5auCm4VHbkRkcL4OeoYo37eTk6eg8ZV/ZgxqD21K6kxX6mQkQSr34VN08CeY461vBN6vAIV61lbmxSbYu9QDOBwOMjIyPjXuI7eiEhZZncYvP3Xbj5bdRCAXs2qMvnetvipMZ/1cjNh42ew5j3zFm+AetdAr3FQM9Ta2qTUuKy/qXv27OHRRx9l3bp15OTk/OvxcngwSEScREpWLiO/j2bFHnPxxBHXNuSZ3o3VmM9qDjtsnQ3L34AU86JuqrY0Q03DnroDSgq4rHAzePBgqlWrxq+//kpQUFARlyQiYo2Dp9IYMjOCg6fS8XJ34Z272tC3TQ2ryyrfDAP2LTaXS0jYYY4F1IIeL0Pre8DF1dLypHS6rHCzdetW/vrrLwUbEXEaK/eeYsR3UaRm5VE90ItpA8NpVUt9uywVFwmLx8Dh1ea2VyB0fRY6PALuXtbWJqXaZYWbunXrkpCQoHAjImWeYRh8vuYQb/6xC4cBYXUq8MmAUKr468PTMkkHYel42PGLue3qCVcNgy7PgE9Fa2uTMuGyws348eN58MEHmThxIg0aNPhXr4dq1aoVSXEiIsUpO8/Oy7/EMDfyGAB3h9Xi9dtb4ummUx2WSDsFq96GiC/AkQfYoM29cO3LEBRidXVShlxWuKlUqRIxMTF07dr1nI/rgmIRKe0SUrJ45JtIoo+excUG/7mpOQ92rqvGfFbISYf1H8PaDyAn1Rxr2MtcLqFaK0tLk7LpssLN8OHDuemmmxg+fLhOTYlImbPt2FmGzYzkZEoWAV5uTOkfyjWNK1tdVvljz4PoWbDiLUg7aY5Vb2subFm/m6WlSdl2WeHm6NGjbNq0SQ3wRKTM+XVLHC/M3UZ2noMGlX2ZMbg99YLVnr9EGQbs/h2WjoPEveZYUB3o+Sq0uANctF6XXJnLCjeNGjXi2LFjNG/evKjrEREpFg6HwaRFe/h4xQEAejStwuR72xLg5W5xZeXM0Y2w+FWI3WBue1eEbi9A+EPgptXVpWhcVrgZMGAAAwYMYOLEiTRs2PBf56jr1q1bFLWJiBSJ1Kxcnpq9haW7EwB4tFsDnr+uCa5qzFdyEveZvWp2/2Zuu3nD1cOh85PmLd4iReiy1pa62AV3pf2CYq0tJVJ+HE5MZ8jMCPYnpOHh5sLbd7bmtnY1rS6r/Eg9aV5TEzUTDDvYXKDdAOg+GgLUIFEuTbGuLbVv377LLkxEpKSs3Z/I8G+jSM7MpWqAJ9MGhtMmJMjqssqH7FRY+yGsnwK5/12DsMmN0HMMVGlqbW3i9C4r3DRs2LCo6xARKTKGYfDVusO8/vsu7A6DtiFBTBsYRpUANeYrdnk5EPkVrJwIGYnmWK325h1QdTpZWpqUH4UONzExMQC0bNky///Pp2XLlldWlYjIZcrOs/PqvB38EBELwB3tavLmHa3wcldjvmJlGGZH4aXj4cwhc6xiA+g1BprdooUtpUQVOty0amU2UjIMI///z6e0X3MjIs4pMS2bR2dFEnHkDC42GH1DM4Z0rafGfMXt0GrzDqjjUea2bxXo/iKEDgZX3Y0mJa/Q4ebEiRPn/H8RkdIgJi6ZYTMjOJ6chb+XGx/d147uTapYXZZzi99p3gG1b6G57e4LnUfC1SPA08/S0qR8K3S4qVatGkOGDGHGjBlaO0pESpXft53g2R+3kJXroH6wL9MHh9Ogsj5ci01yHCx/E7Z+B4YDbK4Q/iB0exH8FCjFepd0K7jNZnOKU066FVzEOTgcBu8v2ctHy/YDcE3jynx0XzsCvXUqpFhknoU178PGTyEvyxxrfiv0eBWCdaOJFL9ivRVcRMRqadl5PP3DFhbvjAdgaNd6jLqhmRrzFYe8bNg0HVZPgswz5lidzuYdULXCra1N5BwUbkSkzIlNymDI1xHsiU/Fw9WFCXe04s6wWlaX5XwcDtj+Iyx7HZKPmmOVm5qrdTe+XndASal1yeHGze3iu+Tl5V1WMSIiF7PuQCKPfxvFmYxcKvt78tnAMEJrV7C6LOdzYJl5B9TJ7ea2f3W49iVo0x9c9e9iKd0u+Sd0ypQpxVGHiMhFzVp/mLELdmJ3GLSuFci0geFUC1RjviJ1YissHgMHl5vbngHQ5Sm46jHw8LG0NJHCuuRw8+ijjxZ5EStWrGD37t3ccsst1Khx4bVGVq9ezY4dOwqMVaxYkX79+hV5XSJSOuTkORi3YAffbjRPjdzatgYT72ytxnxF6cwR8/TT9jnmtos7dBgKXZ8D30rW1iZyiSw9trhgwQJeeOEFfH19iYyMpGnTphcNN99++y2LFy+md+/e+WM1a2oRPBFndTotm8e+jWLToSRsNnjhuqY82q2+GvMVlYwkWDUJNk8He4451vIu6PEfqFjP2tpELpOl4cbT05Off/4Zf39/QkJCCr1fu3bt+PTTT4uxMhEpDXadSGHI1xHEnc3Ez9OND+5tS89mVa0uyznkZsKGT2DNZMhONsfqdYPe46BGO0tLE7lSlxRuMjMzi/TF+/TpA8CxY8cuab+EhARmzpxJYGAg7du3v+jRHhEpe/6KOcEzc7aSkWOnbiUfpg8Kp1FVf6vLKvscdtjyndmEL/W4OVa1FfQeCw166g4ocQqXFG68vErHhXtHjhzhr7/+Ii4ujk2bNjFx4kRGjhx53vnZ2dlkZ2fnb6ekpJREmSJyGRwOgw+X7WPykn0AdGkYzJT+7Qjy8bC4sjLOMGDfIvNi4VO7zLHAEPP0U6t+4OJibX0iRajM3c/34IMPMmXKlPxb0r/88kuGDBlC586dCQsLO+c+EyZMYNy4cSVZpohchoycPJ6ds5U/Y04C8GDnurx8YzPcXPXBe0WORZq3dR9ZY257BcE1z0H7oeBeOv7RKlKUytxvjKuuuqpAr50HH3yQ4OBgFi1adN59Ro8eTXJycv5XbGxsSZQqIpfg2JkM7vxkPX/GnMTd1cbbd7ZmTN8WCjZX4vQBmDMYZvQwg42rJ3R+Ep7cAp2eULARp1Xmjtyci5eXF2fOnDnv456ennh6epZgRSJyKTYdSuLRbyJJSs8h2M+DTweEEV63otVllV1pp2DlRIj8Ehx5gA3a3Gc24Qsq/M0bImVVqQ83K1euJD4+nn79+mG324mNjaVu3br5j69Zs4ajR4/SqVMn64oUkcv2/aajvDIvhjyHQYsaAUwbFE7NIG+ryyqbctJh/VRY+wHkpJljDXubyyVUa2lpaSIlydJws2fPHpYvX87Zs2cBmD9/Prt37yY8PJzwcHMxtlmzZrFhwwb69euHYRj07duX9u3b06JFC44ePcrnn3/O/fffz6233mrhdyIilyrX7uC133Yyc/0RAG5qXZ1Jd7XB20ON+S6ZPReiZ8GKtyDNXEiUGu3MhS3rXWNtbSIWsDTcJCUlsWXLFgAeeeQRMjIy2LJlC7Vq/f8CeN27d6dOnTqAua5VVFQUP/74I9HR0VStWpU///yTrl27WlG+iFymM+k5DP82ivUHTwPwXJ/GPH5tQzXmu1SGAbt/gyVj4fR+c6xCXej5KjS/XXdASbllMwzDsLqIkpaSkkJgYCDJyckEBARYXY5IubLnZCpDZm4mNikTXw9X3r+nLX1aVLO6rLLn6AbzDqjYjea2TyXo9iKEPQhuum1enFNhP79L/TU3IuI8Fu04ydM/bCE9x05IRW9mDGpPk2pqzHdJTu2BJeNgz+/mtps3dBoBnUaCl/6xJgIKNyJSAgzDYOry/UxatBeAq+tX4uP7Q6ngqyMMhZZyAlZMMK+tMRxgc4F2A6H7aAiobnV1IqWKwo2IFKvMHDvPz93Kb9tOADD46jr85+bmuKt/TeFkpcC6D827oHIzzLEmN0GvMVC5ibW1iZRSCjciUmyOn81k2KwIYuJScHOxMf7WlvS/qrbVZZUNeTlmn5qVEyHDvPCaWh3MO6DqXG1tbSKlnMKNiBSLyCNJPDIrksS0HCr6evDJ/aFcVb+S1WWVfg4H7PwFlr4GZw6ZY5UamUdqmt6shS1FCkHhRkSK3JzNsbw8bzu5doOm1fyZMTicWhV8rC6r9Du0yrwD6ni0ue1XFbqPgnaDwFW/rkUKS39bRKTI5NkdvPHHLr5cexiAG1pWY9LdbfD11K+aC4rfYa7WvX+xue3hZ64B1XE4ePpZW5tIGaTfOCJSJM5m5DDiu2jW7E8E4KlejRjZoxEuLjqNcl7Jx2DZG7D1e8AAFzezT023F8GvstXViZRZCjcicsX2J6Qy5OsIDp/OwNvdlffvacP1LXV78nllnoE178OGT8GebY41v83sLFypgaWliTgDhRsRuSJLd8Xz5OwtpGXnUTPIm+mDwmleQ83kzik3CzZPh1WTIOusOVani3kHVK0wS0sTcSYKNyJyWQzD4NOVB3l74W4MAzrUq8gn94dSyc/T6tJKH4cDts+BZa9Dcqw5VrkZ9B4HjfroDiiRIqZwIyKXLCvXzos/bePXLccB6H9Vbcb2bYGHmxrzFWAYcGApLB4L8dvNMf8a0ONlaHMfuGgFdJHioHAjIpfkZHIWw2ZFsO1YMm4uNsbc0oKBHetYXVbpc3yLeVv3oZXmtmcgdHkKOj4G7t5WVibi9BRuRKTQoo+eYdisSE6lZlPBx52p94fSqUGw1WWVLmcOmw34Yuaa264e0H4oXPMc+FS0tDSR8kLhRkQK5afIY4z+ZTs5eQ6aVPVn+qBwaldSY7586adh9STYNB0cueZYq37Q4z9QQUe2REqSwo2IXJDdYfDWn7uYvtpcCqBP86q8d09b/NSYz5STARs/gTWTITvFHKt/rXmxcPU2lpYmUl7pt5OInFdyZi4jv49m5d5TAIzs0ZCnejVWYz4Ahx22fAvLJ0CqeWE11VpBr3HQsKe1tYmUcwo3InJOB06lMfTrCA4mpuPl7sKku9twc+saVpdlPcOAvQthyRg4tdscC6xtnn5qdTe46I4xEasp3IjIv6zYk8AT30eTmpVHjUAvpg0Kp2XNQKvLst6xCPMOqCNrzW3vCtD1OegwFNzU30ektFC4EZF8hmEwY/UhJvy5C4cB4XUq8MmAMCr7l/MP7sT9sHQc7Jpvbrt5wVWPQpenwTvI0tJE5N8UbkQEMBvzvfTLdn6OigPgnvAQxt/WAk+3ctxoLi0BVk6EyK/AkQfYoO39cO1oCKxldXUich4KNyJCQkoWw2ZFsiX2LK4uNl65qRmDO9XFVl6XBchOg/VTYN1HkJNmjjW6DnqNharNLS1NRC5O4UaknNsae5ZhsyKIT8km0Nudqf1D6dKonDbms+dC1NewYiKkJ5hjNULNhS3rdbW2NhEpNIUbkXJsXnQcL/y0jZw8B42q+DF9UDh1g32tLqvkGQbsWmBeV3N6vzlWoR70fBVa3K6FLUXKGIUbkXLI7jB4Z+EePl15AICeTasw+d62+Hu5W1yZBY6sN++AOrbJ3PYJhm4vQtgD4OZhaWkicnkUbkTKmZSsXJ6avYVlu83TLsO7N+DZPk1wLW+N+RJ2m0dq9vxhbrv7wNUjoNMT4BVgbW0ickUUbkTKkUOJ6Qz5ejMHTqXj6ebC23e15ta2Na0uq2SlnIAVb0L0N2A4wOYKoYOg+yjwr2Z1dSJSBBRuRMqJ1ftO8fi3UaRk5VEtwItpg8JoXSvI6rJKTlYyrP0A1n8MeZnmWNOboecYqNzY2tpEpEgp3Ig4OcMw+HLtYV7/fScOA9rVDuKzAWFUCfCyurSSkZcDEZ/DyrchM8kcC7nKvAOqdkdraxORYqFwI+LEsvPsvDIvhjkRxwC4K6wWr9/WEi/3ctCYz+GAHT/D0vFw9og5VqmR2aum6U26A0rEiSnciDiphNQsHvsmisgjZ3CxwUs3NuPhLvXKR2O+gyvNO6BObDG3/apC99HQbiC46teeiLPT33IRJxQTl8zQmRGcSM4iwMuNj/qH0q1xZavLKn4nY8zVuvcvMbc9/KHzk3D1cPAoh/17RMophRsRJ7Ng63Gen7uVrFwH9Sv7MmNQOPUr+1ldVvE6GwvL34CtswEDXNwg/GHo9gL4ltNuyyLlmMKNiJNwOAzeW7yXKcvNDrvdm1Tmw/vaEeDMjfkyz8Dqd2HjNLBnm2Mt7oCer0DF+tbWJiKWUbgRcQJp2Xk8NXsLS3bFA/DINfV54fqmztuYLzcLNn1mBpusZHOsblfoPQ5qhllbm4hYzsXKF8/MzOSrr76iY8eOBAUFsWbNmkLt98UXX9CmTRuqVatG7969iY6OLuZKRUqvI6fTuePjtSzZFY+Hmwvv39OG0Tc2c85g47DDlu/hozDzguGsZKjSHPr/CIMXKNiICGBxuBk7dizLly/n+eefJzk5mby8vIvu8/333/PYY4/x/PPPs3btWho0aECPHj04ceJECVQsUrqs25/IrVPXsjc+jSr+nsx55Gpub1fL6rKKnmHAviXw2TUw71FIOQYBNeHWj+HRNdC4j27tFpF8NsMwDKte3DAMbDYbx44dIyQkhOXLl9O9e/cL7tO6dWs6derEp59+CoDdbqdmzZoMGzaM8ePHF+p1U1JSCAwMJDk5mYAArSEjZY9hGMzacIRxC3Zidxi0qRXItEHhVHXGxnzHo82jNIdWmduegdD1GbjqEXD3trY2ESlRhf38tvSam0vtt3H27Fm2b9/OK6+8kj/m6upKjx49Cn1KS6Ssy8lzMGZ+DN9vigXg9nY1mXBHK+drzJd0CJa9BjE/mduuHtBhGHR9FnwqWlubiJRqZeqC4uPHjwNQtWrVAuNVqlQhKirqvPtlZ2eTnZ2dv52SklI8BYoUs8S0bB77JpLNh89gs8Go65sy7Jr6ztWYLz0RVr0Dmz8HRy5gg9b3QI+XIai21dWJSBlQpsLN31xcCl4q5ObmxoXOrk2YMIFx48YVd1kixWrH8WSGzYwk7mwm/p5ufHhfO65tWsXqsopOTgZsmAprPoCcVHOsQQ/oNQ6qt7a2NhEpU8pUuKlSxfxFnpiYWGA8ISEh/7FzGT16NM8880z+dkpKCiEhIcVTpEgx+GP7CZ6ds5XMXDv1gn2ZPiichlWcpDGfPQ+2fAvL34S0k+ZYtdbmwpYNrrW2NhEpk8pUuAkODqZ+/fqsXr2a2267LX981apV3HXXXefdz9PTE09PzxKoUKRoORwGk5fu48Ol+wDo2iiYKfeFEujjBI35DAP2/AlLxkLiHnMsqDb0eBVa3gkult7MKSJlWKn/7TFy5Eg6deqUv/3kk08yY8YM1q5dS05ODhMmTODkyZM88sgjFlYpUvTSs/MY/m1UfrAZ0qUeXz7Q3jmCTexm+PIGmH2fGWy8K8B1E2BEBLS+W8FGRK6IpUduvvvuO4YPH55/vczNN9+Mm5sbo0aNYtSoUQBkZGQUuAD4iSeeIDExkRtvvJH09HTq1q3LvHnzaNSokSXfg0hxiE3KYOjMCHafTMXD1YXXb29Jv3AnOJWauB+WjoVdC8xtNy/o+Bh0fgq8gywsTESciaV9bnJycsjIyPjXuJeXF15eZr+OzMxM8vLy8Pf3LzDHMAyysrLw9r70PhfqcyOl2YaDpxn+bRRJ6TkE+3ny2cAwwupUsLqsK5OWACvegsivwLCDzQXa9ofuL0FgTaurE5Eyokz0ufHw8MDDw+OCc84XXmw222UFG5HS7JsNRxg7fwd5DoNWNQOZNiiM6oFl+Oc8OxXWTYF1H0FuujnW+HroNRaqNLO0NBFxXmXqgmIRZ5VrdzBuwQ6+2XAUgL5tavD2na3x9iijjfnsueZRmpUTIf2UOVYzDHq/BnU7W1qaiDg/hRsRiyWl5zD820g2HEzCZoPn+jRhePcGZbMxn2HAzl9h6XhIOmCOVawPPcdA81u1/pOIlAiFGxEL7T6ZwpCvIzh2JhNfD1c+uLcdvZpXvfiOpdHhteYaUHER5rZPMHQfBWEPgKsT3OElImWGwo2IRRbuOMnTP2whI8dO7Yo+zBgcTuOq/hffsbRJ2GX2qtn7l7nt7gudRkCnJ8CzDH4/IlLmKdyIlDDDMJiybD/vLt4LQKcGlZjaP5QKvhe+uL7USTludhXe8i0YDrC5Qthg6DYK/Mvo0ScRcQoKNyIlKCMnj+d/3Mbv208A8ECnurx8UzPcXctQ07qsZFgzGTZ8AnmZ5lizvuZ1NcHqNyUi1lO4ESkhcWczGfp1BDtPpODuauO1W1tyb4cytMp1Xra5UveqdyAzyRyrfbW5BlRIB2trExH5B4UbkRKw+XASj86K5HR6DpV8Pfh0YBjt61a0uqzCcTgg5idYNh7OmreqE9zE7FXT5AbdASUipY7CjUgxm73pKK/8GkOu3aB59QCmDw6nZlAZacx3YDksGQMntprbftXg2peg7f3gql8fIlI66beTSDHJszt4/fddfLXuMAA3tarOO3e3xsejDPy1O7HNDDUHlpnbHv7Q5UnoOBw8fK2tTUTkIsrAb1mRsudMeg4jvo9i7f7TADzbuzEjejQs/Y35zh6FZW/Ath8AA1zcof3DcM3z4BtsdXUiIoWicCNSxPbGpzJ0ZgRHTmfg4+HKe/3acn3LalaXdWEZSbD6Xdg0Dew55ljLO6HHf8wOwyIiZYjCjUgRWrIznqd+2EJadh61KngzY3A4TauV4pXnczNh42ew5j3zFm+AetdAr3FQM9Ta2kRELpPCjUgRMAyDj1ccYNKiPRgGXFWvIp8MCKNiaW3M57DD1tlmE76UY+ZY1ZZmqGnYU3dAiUiZpnAjcoUyc+y88NM2Fmw9DsDAjnV4tW/z0tmYzzBg32JzuYSEHeZYQC3o8TK0vgdcyugq5CIi/6BwI3IFTiRnMmxmJNvjknFzsTH2lhYM6FjH6rLOLS4SFo+Bw6vNba9A6PosdHgE3L2srU1EpAgp3IhcpsgjZ3hkViSJadlU8HHnkwFhdKxfyeqy/i3pICx9DXb8bG67esJVw6DLM+BTRhoJiohcAoUbkcvwY0QsL/8SQ47dQdNq/kwfFE5IRR+ryyooPRFWvg0RX4AjF7BBm3vNJnxBZWjZBxGRS6RwI3IJ8uwOJvy5m8/XHALguhZVea9fW3w9S9FfpZx0WP8xrP0AclLNsQY9ofc4qNbK2tpEREpAKfqNLFK6JWfkMuL7KFbvSwTgyZ6NeLJnI1xcSsmdRfY82PINLJ8AaSfNseptzIUt63e3tDQRkZKkcCNSCPsT0hg6M4JDiel4u7vybr823NiqutVlmQwDdv8OS8dB4l5zLKgO9HwVWtwBLqXwri0RkWKkcCNyEct3JzDy+2hSs/OoGeTNtEFhtKgRaHVZpqMbYfGrELvB3PauCN1egPCHwM3T2tpERCyicCNyHoZhMG3VQd76azeGAe3rVuCTAWEE+5WC0JC4z+xVs/s3c9vNG64eDp2fNG/xFhEpxxRuRM4hK9fO6J+380t0HAD3dQhh3C0t8XCz+BRP6klY8RZEzQTDDjYXaDcAuo+GgBrW1iYiUkoo3Ij8j/iULIbNimRr7FlcXWyM6ducgR3rWLuid3YqrP0Q1k+B3AxzrPEN0GssVGlqXV0iIqWQwo3IP2yJPcuwmREkpGYT5OPOx/1D6dQw2LqC7LkQ+ZV5tCbDvEuLmuHQ5zWo08m6ukRESjGFG5H/+iX6GC/+tJ2cPAeNq/oxY1B7aleyqDGfYcDOebB0vNlhGKBiA+g1BprdooUtRUQuQOFGyj27w+Dtv3bz2SozRPRqVpXJ97bFz6rGfIfXmHdAxUWa275VoPuLEDoYXN2tqUlEpAxRuJFyLSUrl5HfR7NizykARlzbkGd6N7amMV/8TvMOqH0LzW13X+g8Eq4eAZ5+JV+PiEgZpXAj5dbBU2kMmRnBwVPpeLm78M5dbejbxoI7jpLjYPmbsPU7MBxgc4XwB6Hbi+BXpeTrEREp4xRupFxatfcUI76LIiUrj+qBXkwbGE6rWiXcHybzLKx5HzZ+CnlZ5lizW6DnGAhuWLK1iIg4EYUbKVcMw+DzNYd4849dOAwIq1OBTwaEUsXfq+SKyMuGzTNg1TuQecYcq93JXAMqpH3J1SEi4qQUbqTcyM6z8/IvMcyNPAbA3WG1eP32lni6uZZMAQ4HxMyFZa/B2aPmWOWmZq+axtfrDigRkSKicCPlQkJKFo98E0n00bO42OA/NzXnwc51S64x34FlsHgMnNxmbvtXh2tfgjb9wVV/DUVEipLlv1VTU1OZN28e8fHxtGrViuuuu+6C8//8808iIyMLjFWpUoVhw4YVZ5lShm07dpZhMyM5mZJFgJcbU/qHck3jyiXz4ie2mqHm4HJz2zMAujwFVz0GHhb10BERcXKWhptjx47RpUsXqlSpQlhYGO+99x6dO3dmzpw55/0X9a+//srKlSu5884788eys7NLqmQpY37dEscLc7eRneegQWVfZgxuT71g3+J/4TNHYNnrsH2Oue3iDh2GQtfnwLdS8b++iEg5Zmm4efHFF6lcuTJr167F3d2dp556ihYtWvDTTz9x1113nXe/Fi1a8Prrr5dgpVLWOBwGkxbt4eMVBwDo0bQKk+9tS4BXMTfBy0iCVZNg83Sw55hjLe+CHv+BivWK97VFRASwMNzY7XbmzZvHW2+9hbu7+YHTpEkTunbtyty5cy8YbmJjY3nvvfcIDAykU6dONGvWrKTKljIgNSuXp3/YwpJdCQA82q0Bz1/XBNfibMyXm2ne0r36fchONsfqdYPe46BGu+J7XRER+RfLws3Ro0fJyMigcePGBcYbN27Mxo0bL7hvdnY2hw8fJi4ujuHDhzN69GjGjh17wfn/PHWVkpJyRbVL6XU4MZ2hMyPYl5CGh5sLb9/Zmtva1Sy+F3TYYev3ZhO+lDhzrGor6D0WGvTUHVAiIhawLNykpaUBEBhYsHFaUFBQ/mPn8sQTT/Dpp5/mb8+bN4/bb7+d3r1707lz53PuM2HCBMaNG1cEVUtptnZ/IsO/jSI5M5eqAZ5MGxhOm5Cg4nkxw4B9i8zlEhJ2mmOBIebpp1b9wMWleF5XREQuyrLfwL6+5kWd/3sUJTk5Of+xc2nRokWB7dtuu43q1auzfPny8+4zevRokpOT879iY2OvoHIpbQzD4Ku1hxj0xSaSM3NpGxLEghFdii/YHIuEr26G7/qZwcYrCPq8DiMioM29CjYiIhaz7MhN7dq18fb2Zv/+/fTp0yd/fN++fTRp0uSSnsvFxeWCR3s8PT3x9PS87Fql9MrJc/DqrzHM3mwG1jva1eTNO1rh5V4MjflOH4Cl42HnPHPb1RM6PgpdngbvCkX/eiIiclks+yemm5sbffv2ZdasWeTl5QFw4MABVq1axR133JE/7/fff2fatGmAeRHytm3bCjzPH3/8QVxcHN27dy+x2qV0SEzLpv/0DczeHIuLDV6+sRnv9mtT9MEm7RT8/hxM7fDfYGMzm+89EWkumaBgIyJSqtgMwzCsevHDhw/TuXNn6tevT/v27Zk7dy5t2rTh119/xeW/h/aHDBnChg0biImJIS8vj86dO1O1alVatGjB0aNH+emnn3j00UeZPHlyoV83JSWFwMBAkpOTCQgIKKbvTopTTFwyw2ZGcDw5C38vNz66rx3dmxTxCto56bB+Kqz9AHL+e2SwYW9zuYRqLYv2tURE5KIK+/ltabgBOHPmDD/++GN+h+JbbrklP9iAecFwbGwsTzzxBGBeX7F48WKio6OpUKECnTt3/td1OBejcFO2/b7tBM/+uIWsXAf1g32ZPjicBpX9iu4F7HkQPRNWvAVp8eZYjXbmUZp61xTd64iIyCUpM+HGCgo3ZZPDYTB5yV4+XLYfgGsaV+aj+9oR6F1EjfkMA3b/BkvGwel95liFutDzVWh+uy4UFhGxWGE/vy1fW0qkMNKy83jmhy0s2mkeSRnatR6jbmhWdI35jm6Axa9C7H97LPlUgm4vQtiD4OZRNK8hIiIlQuFGSr3YpAyGfB3BnvhUPFxdmHBHK+4Mq1U0T35qLywdZx6xAXDzhk4joNNI8NJRPRGRskjhRkq19QdOM/zbSM5k5FLZ35PPBoYRWrsI7k5KPQkrJkDULDDsYHOBdgOh+2gIqH7lzy8iIpZRuJFSa9aGI4ybv4M8h0HrWoFMGxhOtUCvK3vSrBRY96F5F1RuhjnW5CboNQYqX1p/JRERKZ0UbqTUyclzMG7BDr7deBSAW9vWYOKdra+sf01eDkR+CSsnQsZpc6xWB/MOqDpXF0HVIiJSWijcSKlyOi2bx76NYtOhJGw2eOG6pjzarT62y12A0jBgx8+w9DU4c8gcq9TQ7FXT9GYtbCki4oQUbqTU2HUihSFfRxB3NhM/Tzc+uLctPZtVvfwnPLTKvAPqeLS57VsFuo+C0EHgWkS3j4uISKmjcCOlwl8xJ3hmzlYycuzUreTD9EHhNKrqf3lPFr/DXK173yJz28PPvPvp6sfBswib/YmISKmkcCOWcjgMPly2j8lLzKZ5XRoGM6V/O4J8LqO3TPIxWP4mbPkOMMDFzexT0+1F8KtctIWLiEippXAjlsnIyePZOVv5M+YkAA92rsvLNzbDzfUSOwFnnoE178PGzyAvyxxrfpvZWbhSg6ItWkRESj2FG7HEsTMZDJ0Zya4TKbi72njjtlb0ax9yaU+SmwWbp8OqSZB11hyr08W8A6pWWJHXLCIiZYPCjZS4TYeSeOybSE6n5xDs58GnA8IIr1ux8E/gcMD2ObDsdUiONccqN4Pe46BRH90BJSJSzincSIn6ftNRXpkXQ57DoEWNAKYNCqdmkHfhn2D/Ulg8BuK3m9v+NeDal6Btf3C5gj44IiLiNBRupETk2h28/ttOvl5/BICbWldn0l1t8PYoZCA5vgWWjIGDK8xtzwDo8jRc9Sh4+BRLzSIiUjYp3EixO5Oew/Bvo1h/0OwM/Fyfxjx+bcPCNeY7c9g8/bT9R3Pb1QPaD4VrngOfSziVJSIi5YbCjRSrPSdTGTJzM7FJmfh6uPL+PW3p06LaxXfMSIJV78DmGWDPMcda9YMe/4EKdYq3aBERKdMUbqTYLNpxkqd/2EJ6jp2Qit7MGNSeJtUu0pgvJwM2fgJrJkN2ijlW/1rzYuHqbYq9ZhERKfsUbqTIGYbB1OX7mbRoLwBX16/Ex/eHUsH3Ao35HHbY8i0snwCpx82xaq2g1zho2LMEqhYREWehcCNFKjPHzvNzt/LbthMADLq6Dq/c3Bz38zXmMwzYu9C8WPjUbnMssLZ5+qnV3eByiQ39RESk3FO4kSJz/Gwmw2ZFEBOXgpuLjfG3tqT/VbXPv8OxCHNhyyNrzW2vILjmeWg/BNy9SqRmERFxPgo3UiQijyTxyKxIEtNyqOjrwSf3h3JV/Urnnnz6ACwdBzt/NbfdvMxburs8Dd5BJVaziIg4J4UbuWJzNsfy8rzt5NoNmlbzZ8bgcGpVOEfvmbQEWDkRIr8CRx5gg7b3w7WjIbBWSZctIiJOSuFGLlue3cEbf+ziy7WHAbihZTUm3d0GX8//+bHKToP1U2Hdh5CTZo41ug56jYWqzUu0ZhERcX4KN3JZzmbkMOK7aNbsTwTgqV6NGNmjES4u/2jMZ8+FqK9hxURITzDHaoSaC1vW62pB1SIiUh4o3Mgl25+QypCvIzh8OgNvd1fev6cN17es/v8TDAN2LTCvqzm93xyrUA96vgotbtfCliIiUqwUbuSSLNsdz8jvt5CWnUfNIG+mDwqneY2A/59wZL15B9SxTea2TzB0exHCHgC3C/S5ERERKSIKN1IohmHw6cqDvL1wN4YBHepV5JP7Q6nk52lOOLUHloyFPX+Y2+4+cPUI6PQEeAWc93lFRESKmsKNXFRWrp0Xf9rGr1vMzsH9r6rN2L4t8HBzgZQTsOJNiP4GDAfYXCF0IHQfDf6FWENKRESkiCncyAWdTM5i2KwIth1Lxs3FxphbWjCwYx3ISoGVH5h3QeVlmpOb3gw9x0DlxtYWLSIi5ZrCjZxX9NEzDJsVyanUbCr4uDP1/lA61QmADZ/Cqrch47Q5MeQq8w6o2h2tLVhERASFGzmPnyKPMfqX7eTkOWhS1Z/pA0OpfeIvmPoanDlsTqrUyOxV0/Qm3QElIiKlhsKNFGB3GLz15y6mrz4EQJ/mVfngqhS8f7oJTmwxJ/lVNa+paTcQXPUjJCIipYs+mSRfcmYuI7+PZuXeUwCMv8pgYNoEbN8vMSd4+EHnp+Dq4eDha12hIiIiF6BwIwAcOJXG0K8jOJiYTj33JGbWW0zI1vmAAS5uEP4QXPMC+FW2ulQREZELKjXhxuFw4OLiUuz7yL+t2JPAE99HY8s6y+u+f9CfP3E5mm0+2OJ26PEKVGpgbZEiIiKFZHm4mTBhApMnTyYxMZHmzZvzwQcf0KNHjyLfp7zKsztIysghKT2HpLQcTqeb/386PYfTadmcSs1m1a5YBrosYqT3fPzt/13Ysm5X6D0OaoZZ+w2IiIhcIkvDzaeffsqbb77JL7/8QseOHXnnnXe4+eab2bFjB/Xq1SuyfZxJTp7jv+Ek2wws6TmcTsvJH/v7/5PTMshOT8aRnYI/mfiRiZ8t0/x/WyZ+ZFDNlklDMnnVI5JatkQwgCrNodc4aNRbd0CJiEiZZDMMw7DqxRs3bsyNN97I5MmTAbPFf506dbjvvvuYOHFike3zv1JSUggMDCQ5OZmAgKJbGsAwDM5m5FLBt/BrKGXl2s2jKWlmODmbkkZaShJpKWfJSjtDTnoyuZkpOLJSICsV97w0/G0ZBcNKfmDJxP+///W25Vxa7QE1sV37MrS5F1xcL/VbFxERKXaF/fy27MjN6dOn2bdvH926dcsfs9lsdOvWjfXr1xfZPiUlO8/O9zM/Yd+xU1zfsiqerjYMwwEOO7mZaeRlpuDITIbsVFxyU3HLTcfDno6PYQaV6rZMGpOJpy33/C9iA9wvrS7DzQe8/LF5+kP+V0DB/wbVxta6H7h7X9F7ICIiUhpYFm7i4+MBqFy54N03VapUYdOmTUW2D0B2djbZ2dn52ykpKZdV84Vk5ti5IfZ9HjASYVshd7L99+scsl18yHXzxe7uh+Hhj83LH1fvQNx9AvDwDcKWH1D+N7D898srADz8sakPjYiIlDOWf/I5HI5/bdsucq3Hpe4zYcIExo0bd/lFFkKQjwepDbuw59gRch1g2GyAC9hs2N18/hs4AnHzDsDdJxBPvyB8/ILwDayAj98/wopXAHj44eniimexViwiIuKcLAs31atXByAhIaHAeEJCAtWqnXs16cvZB2D06NE888wz+dspKSmEhIRcVt0X4n//1zQp8mcVERGRS2FZk5gKFSrQvHlzli9fnj/mcDhYvnw5nTt3zh/Ly8sjJyfnkvb5X56engQEBBT4EhEREedkaQe8F198kS+++IKffvqJ48eP88wzz5CWlsZjjz2WP+fRRx8lNDT0kvYRERGR8svSa24GDRpEWloao0ePJj4+nlatWrF48WJq1aqVP8fd3R1PT89L2kdERETKL0v73FiluPrciIiISPEp7Oe3FmYSERERp6JwIyIiIk5F4UZEREScisKNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3IiIiIhTUbgRERERp2Lp8gtW+bspc0pKisWViIiISGH9/bl9scUVymW4SU1NBSAkJMTiSkRERORSpaamEhgYeN7Hy+XaUg6Hg+PHj+Pv74/NZiuy501JSSEkJITY2FitWVWM9D6XDL3PJUfvdcnQ+1wyivN9NgyD1NRUatSogYvL+a+sKZdHblxcXIp1FfGAgAD9xSkBep9Lht7nkqP3umTofS4ZxfU+X+iIzd90QbGIiIg4FYUbERERcSoKN0XI09OTMWPG4OnpaXUpTk3vc8nQ+1xy9F6XDL3PJaM0vM/l8oJiERERcV46ciMiIiJOReFGREREnIrCjYiIiDgVhZsiYhgGO3bsYOvWreTl5VldTplw6tQptmzZwtmzZ887JyMjg8jISA4cOFDsc5zd3r17WbNmDRkZGf96LC8vj61bt7Jjx47ztjUvqjnOLCMjg+joaOLj4887Z8+ePURFRZGTk1Psc5yRw+Hg4MGDREZGcurUqfPOO3r0KBERERdcZqeo5jiL7du3s3HjxvM+7nA42L59O9u2bcNut1s+54IMuWJ79uwxmjZtalSpUsUICQkxatasaaxbt87qskqtdevWGV26dDGqVKlitG3b1vD29jaGDBli5ObmFpg3e/ZsIyAgwGjUqJHh7+9vdOvWzUhKSiqWOc5uz549RkBAgAEY27dvL/DYxo0bjVq1ahkhISFG1apVjcaNGxu7du0qljnObMKECYafn5/RsmVLo379+sbQoUONvLy8/MePHTtmtGvXzqhYsaJRr149Izg42Fi4cGGB5yiqOc4qKirKaNKkiVGtWjUjNDTU8PHxMe666y4jMzMzf05GRoZx6623Gj4+PkbTpk0Nb29vY+rUqQWep6jmOIsvvvjCaNu2rVGhQgWjUqVK55yzbds2o0GDBkb16tWNmjVrGnXq1DGioqIsm3MxCjdFoF27dkbfvn3zf5E98sgjRo0aNQr8hZP/9/XXXxtr1qzJ396zZ49RoUIF44033sgfO3jwoOHh4WF8/PHHhmEYRnJystG8eXNj4MCBRT7H2WVlZRnt2rUzXnjhhX+Fm6ysLKNWrVrGsGHDDMMwDLvdbtxyyy1G69ati3yOM5s8ebLh6+trrF27Nn/s888/NzIyMvK3e/XqZXTt2tXIysoyDMMwXn75ZSMwMNA4ffp0kc9xVh06dDBuuumm/H8IHTp0yPD39zfef//9/DnPPfecUbt2bePkyZOGYRjGjz/+aNhsNiMiIqLI5ziLUaNGGZGRkcb7779/znBjt9uNpk2bGvfcc4/hcDgMwzCMAQMGGPXr18//syjJOYWhcHOFoqKiDMDYsGFD/lhsbKxhs9mMX375xbrCypi77rrLuOGGG/K3x48fb1SpUsWw2+35Y59++qnh6elppKWlFekcZ/fEE08YDzzwgLF58+Z/hZv58+cbgBEbG5s/tmHDBgMwNm/eXKRznFV2drZRqVIl46WXXjrvnKNHjxqA8dtvv+WPJScnG56ensb06dOLdI4zq1evnjF27NgCY02aNMl/7x0Oh1GpUiXj9ddfLzCnWbNmxuOPP16kc5zR+cLNqlWrDMCIiYnJH9uzZ48BGIsXLy7xOYWha26uUHR0NAChoaH5Y7Vq1aJ69er5j8mF5eXlsWXLFho2bJg/Fh0dTbt27QosjNahQweys7PZuXNnkc5xZgsWLOCPP/7gww8/POfj0dHRVK1atcBaa+Hh4dhstvyf36Ka46y2bt3K6dOn6du3LwkJCURFRXHmzJkCc/5+D8LCwvLHAgICaNKkSYH3sCjmOLPXXnuN6dOn88UXX7BkyRKeffZZ8vLyePTRRwGIjY3l9OnTBd4fgPbt2+e/P0U1pzyJjo7G09OTFi1a5I81btyYgICAAj+bJTWnMBRurlBSUhIBAQG4u7sXGK9UqRJJSUkWVVW2/Oc//yE+Pp6nnnoqfywpKYlKlSoVmPf39t/va1HNcVZxcXEMHTqUb775Bn9//3POOdf74+rqSlBQ0AXfw8uZ46yOHz8OwOzZs2ndujUPPfQQNWrU4JFHHsHhcAD//7N2rp/Ff76HRTHHmfXs2ZPw8HBGjx7NCy+8wOeff84jjzySH6r1PhePc/39hn+/ZyU1pzDK5argRcnd3Z2srKx/jWdmZuLh4WFBRWXLBx98wOTJk5k3bx7169fPHz/X+5qZmQmQ/74W1Rxn9dhjj9GpUyfy8vJYs2YNe/bsAf7/X0aNGjU6789vVlbWBd/Dy5njrP7+h82uXbs4fPgwXl5exMTEcNVVV9G6dWsef/zx/DlZWVkF/iH0z98TRTXHWRmGwXXXXUfjxo05duwY7u7uHDlyhA4dOmC32xk1alSB9+efzvceXsmc8qQwn3MlOacwdOTmCtWpU4ecnBwSExPzx+x2O/Hx8dSuXdvCykq/KVOm8OKLL/LTTz9x/fXXF3isTp06xMXFFRj7e/vv97Wo5jirSpUqkZCQwKhRoxg1ahQfffQRAO+//z4//vgjYL4/8fHxBW61TEpKIjMzs8B7WBRznFXdunUBeOCBB/Dy8gKgZcuWdOnShdWrVwPm+wOc82fxn+9hUcxxVkePHmXbtm0MGzYsP3zUqVOHm2++mfnz5wPm32mbzXbB96eo5pQnderU4cyZMwXaSGRnZ3P69OkCP5slNadQCn11jpzT6dOnDQ8PD+Pzzz/PH1u0aJEBGDt27LCwstJtypQphqenp7FgwYJzPj579mzD1dXVOH78eP7YyJEjjXr16hX5nPLiXBcU79q1ywAK3Er8xRdfGO7u7sapU6eKdI6zcjgcRu3atY133nmnwHiLFi2MESNGGIZh3k0WGBhoTJw4Mf/xv29GWLlyZZHOcVZpaWmGzWYzvvjiiwLjvXv3Nm655Zb87Y4dOxr33Xdf/nZKSorh6+trfPDBB0U+x9mc74LiuLg4w9XV1fjhhx/yx37++WfDZrMZhw4dKvE5haFwUwReeeUVIygoyJg+fbrx7bffGrVq1TIGDRpkdVml1ldffWXYbDZj1KhRxurVq/O/oqOj8+fk5eUZ7du3N9q3b2/8/PPPxoQJEww3N7cCP/BFNae8OFe4MQzDePDBB41atWoZ33zzjTFjxgwjKCjoX3f+FNUcZzV79mwjKCjImDp1qvHXX38ZDz30kOHr61ugz88HH3xgeHt7Gx999JExZ84co0mTJsaNN95Y4HmKao6zevjhh43KlSsbn376qbFw4ULj6aefNmw2W4FQvXTpUsPNzc146aWXjHnz5hk9evQwGjVqVODuyKKa4yx27NhhrF692hg5cqQRGBiY/zs5PT09f87TTz9tBAcHG19++aUxc+ZMo2rVqsbw4cMLPE9JzrkYrQpeBAzD4KuvvuKnn34iLy+P6667jhEjRvzrImMxjR07liVLlvxrvFGjRnz55Zf528nJybz99tts3LiRoKAgHn74YW644YYC+xTVnPJgz549PPzww8yaNYt69erlj+fl5TFlyhT++usv3NzcuO2223j44Yex2WxFPseZLVq0iM8//5wzZ87QpEkTnnrqKRo0aFBgzg8//MD3339PRkYG3bp145lnnsHb27tY5jgju93OV199xaJFizhz5gx16tRh6NChdOjQocC81atX8/HHH5OQkECbNm0YNWoUVapUKZY5zuDFF19k7dq1/xr/5+8Kh8PBtGnTmD9/PoZhcNNNN/HYY4/h6uqaP78k51yMwo2IiIg4FV1QLCIiIk5F4UZEREScisKNiIiIOBWFGxEREXEqCjciIiLiVBRuRERExKko3IiIiIhTUbgRkSKxZ88eFi5caHUZ2O12Vq9ezZw5c9i7d6/V5YiIBbQquIgU2vbt2zl8+DBVq1alTZs2eHp65j+2YMECvvnmG6677jrL6jMMg169ehEfH0/r1q3x9/encePGltUjItZQuBGRi0pISOCWW27h0KFDtG/fnjNnznD8+HFeeeUVHnroIQCaNm36r9XdS9revXtZsWIFx48fp3r16pbWIiLWUbgRkYt64YUXyMzM5PDhw/lrGCUmJhZYI6xRo0YF1lObPXv2v57HxcWFfv365W/v37+fmJgYqlatSmhoaIEjQecTGRnJkSNHCAkJoX379vnje/fuzX/NJUuW4O7uzm233YaXl1eB/Y8cOcL69esB8PX1pXnz5v9aAyomJob4+Hi6dOnCunXrSExM5O6772bZsmVUrlyZGjVqsHHjRnx8fOjevTubN2/mwIEDAAQHB9OmTRsqV66c/3zbtm3j5MmT9OnTp8DrbNmyhVOnTtG7d++Lft8iUngKNyJyUTExMVx99dUFFmcMDg7m3nvvzd/+39NS8+bNK/AcUVFRHDlyhH79+pGXl8eQIUP4448/uOqqqzh27Bjp6en8+uuvNGvW7Jw1ZGRkcMstt7Bt2zbCw8OJioqiadOmLFiwAH9/fw4cOMDq1avza3FxceGGG274V7iJjY3Nry01NZXVq1czePBgPvroo/w5c+fOZdasWfj6+lK5cmWqVavG3Xffzfjx48nLyyMuLo4WLVpw9dVX0717d6Kjo1m2bBkAJ0+eJDIykk8++YQBAwYA5pGvvn37EhcXR3BwcP7rPPjgg/Tp00fhRqSoXdIa4iJSLj3++ONGUFCQ8eWXXxrx8fHnnPPOO+8Ybdq0Oedj27dvN/z8/Iy3337bMAzDePPNN422bdsaKSkp+XOeeuopo3PnzuetYezYsUbt2rXzX//UqVNG3bp1jdGjR+fPWb16tQEYmZmZhf7ejhw5YgQGBhorVqzIHxszZowBGAsWLCgwt1u3bkZQUJARGxt7wef89ddfjYCAgPzvz+FwGPXr1zfef//9/DnR0dEGYOzevbvQtYpI4ehuKRG5qLfeeouBAwfyzDPPULVqVerXr8+IESM4efLkRfdNSkri1ltv5dZbb+X5558H4Msvv6RNmzYsXLiQH3/8kTlz5lCpUiXWr19PVlbWOZ9n9uzZDBkyhCpVqgDmkaNHH330nKe/LiYrK4u1a9cyd+5c1q1bR40aNdi0aVOBOfXq1ePmm2/+17633347tWrV+td4YmIiy5YtY86cOaSlpZGWlsbu3bsBsNlsPPTQQ3z55Zf58z///HM6d+5MkyZNLrl+EbkwnZYSkYvy8/Pjww8/5P3332f79u2sWrWKSZMm8fvvv7N9+3b8/PzOuV9eXh79+vWjYsWKzJgxI3/88OHDBAcHM3fu3ALz7777bjIyMv51KgnMa2Xq169fYKxBgwYcPXoUwzCw2WyF+l7Wrl3LHXfcQXBwMA0aNMDHx4czZ86QkJBQYN75Lkg+1/hHH33E6NGjad26NdWrV8+/9uifz/nggw8yZswYIiIiaNWqFd999x3vvPNOoWoWkUujcCMihebq6krbtm1p27YtV111FR07dmTdunX/ulD2b88++yw7duwgIiKiQGAJCAjgtttu44UXXij0awcHB5OUlFRgLCkpiUqVKhU62AA8//zzDBgwgHfffTd/LDw8HMMwCsw733P+73hGRgZPP/00v/zyC3379gUgLS2NH374ocBz1qhRgxtvvJEvvviCbt26kZOTU+DiahEpOjotJSIXdejQoX+N/X36KCgo6Jz7fPnll3z22Wf88ssv1KxZs8Bj119/PV988QU5OTkFxuPi4s5bQ5cuXfj5558LjM2dO5cuXboU5lvId/LkyQKngvbt28e2bdsu6Tn+KTExEbvdXuA5//eI1N+GDBnC999/zyeffEK/fv3Oe8RLRK6MjtyIyEW9+OKLJCQk0LNnT2rXrs2RI0f45JNPuP766wkLC/vX/BMnTvDYY49x4403cvjwYQ4fPgz8/63gEydOpGvXrlx11VUMHjwYNzc31qxZQ2ZmJr/++us5a3jttddo3749d955J9dffz2LFy9m48aNbNy48ZK+l9tuu41x48aRnZ1Nbm4u77//Pj4+Ppf8nvwtJCSE0NBQBg8ezJAhQ9i/fz+ff/45Li7//rfjTTfdhI+PDytXruSNN9647NcUkQtTuBGRi5ozZw5r165l0aJFLF++nODgYD7++GNuueUWXF1dgYJN/AzD4LbbbgMK3hLu6upKv379qFmzJlu3bmXmzJlERkbi7+/PnXfeyZ133nneGho0aMCWLVuYPn06q1evplGjRkycOJF69erlz6lcuTL33HNPfk3n8vbbb9OkSRM2btyIr68vs2bNYsOGDYSEhOTPadmy5Tn37dGjB02bNi0wZrPZWLx4MVOmTGHlypXUrFmTdevWMX78+H8dsXJ1deXmm29m5cqVdO7c+bw1isiVsRn/e6JZRESKhcPhoEGDBjz++OM899xzVpcj4rR05EZEpATMmzeP33//nYyMDIYNG2Z1OSJOTRcUi4iUgL/++gtXV1cWLVpEQECA1eWIODWdlhIRERGnoiM3IiIi4lQUbkRERMSpKNyIiIiIU1G4EREREaeicCMiIiJOReFGREREnIrCjYiIiDgVhRsRERFxKgo3IiIi4lT+D+oJQ/K5AQJDAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -223,6 +223,14 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Caution - The rust version differs from the python version by max 1\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": { @@ -342,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -408,12 +416,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -452,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -524,7 +532,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -561,7 +569,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -615,12 +623,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGxCAYAAACKvAkXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAX2lJREFUeJzt3Xd8VFX+//HXpJKQBiSEAIFQQwshQZFmQQUFCx016NrAVREbWFgrNlRQV4p+XRf5qTQRUUAFFAWkCyQEQq8htIQQSK8z9/dH1tFIm4QkN8m8n49HHru5c86dzx2HmXfOufdci2EYBiIiIiJOxMXsAkREREQqmwKQiIiIOB0FIBEREXE6CkAiIiLidBSARERExOkoAImIiIjTUQASERERp6MAJCIiIk7HzewCqiqbzcbx48fx9fXFYrGYXY6IiIg4wDAMMjMzadiwIS4uFx7nUQC6gOPHjxMaGmp2GSIiIlIGSUlJNG7c+IKPKwBdgK+vL1D8Avr5+ZlcjYiIiDgiIyOD0NBQ+/f4hSgAXcAf015+fn4KQCIiItXMpU5f0UnQIiIi4nQUgERERMTpKACJiIiI09E5QJfBZrNRUFBgdhlOyd3dHVdXV7PLEBGRakoBqIwKCgo4dOgQNpvN7FKcVkBAAA0aNNA6TSIiUmoKQGVgGAYnTpzA1dWV0NDQiy60JOXPMAxycnJISUkBICQkxOSKRESkulEAKoOioiJycnJo2LAh3t7eZpfjlLy8vABISUmhfv36mg4TEZFS0dBFGVitVgA8PDxMrsS5/RE+CwsLTa5ERESqGwWgy6BzT8yl119ERMpKAUguy/vvv8+CBQvMLkNERKRUdA6QE5kxYwZr164Fii8jDw0NZeDAgbRt29ah/lOmTKF+/frccccd9m0//vgjV1xxBYMGDaqQmkVERCqCRoCcyKpVq1i9ejVdu3alY8eOJCQkEBERwbfffutQ/2XLlrF+/foKrlJERKTiVYkRoKSkJJKTk2ndurXDNx51pI/VamXXrl14e3vTvHnz8iy52goJCWHEiBEAPPLII2RlZfHaa6/h7e3NqlWreOutt0q0nzVrFseOHSMoKIht27Zx+PBhe/833njD3m7lypUsX74cq9XK0KFDiY6OLrGfhIQEvvrqK9LS0ujYsSP/+Mc/7FdyQfFUWlhYGHXr1r3ofkREpPqLTzrLjuMZxFzVxLQaTB0BysvLY/DgwYSHh3PPPffQoEEDpkyZUi59FixYQOPGjenfvz/9+/end+/epKamVtShVFsdOnQgKSmJ5s2bM2HCBBISEuyP2Ww2xo0bh5ubGy1atKBOnTqEhITQtWtXunbtag8wM2fO5NVXX6VevXqcPn2arl27Ehsba9/PkiVLiI6O5sSJE4SFhTF16lR69uxZYhXtH3/8kccff/yi+xERkerNMAxmrD3EkP9bx0sLE9h8OM20WkwdARo/fjy///47Bw4cICQkhO+++46BAwfSpUsXrrrqqjL3+e233xg6dCiffvopDzzwAFA8QpGcnExgYGC5H4dhGOQWWst9v47wcnct89VQVquVX375hQ4dOtCqVSuuueYaPvvsM95//30Afv75Z06ePMk999xDUFAQoaGhtGzZ0j4C9Ie6devyyy+/2Nfi2b9/P59//jnR0dEYhsHjjz/O448/zqRJkwAYOXIkzZo14z//+Q+PPfaYQ/sREZHqLSOvkOfmb2NJwkkAbm7fgNYNfE2rx9QANGPGDB555BH7Sr4DBgygQ4cOzJgx44IByJE+r776KjfeeKM9/ABcd911FXYcuYVW2r28rML2fzE7X7sJbw/H/zPu2bOHESNGUFRUxIYNG0hPT+eHH34AioPJ008/zTvvvIO7uzufffYZt956K0FBQRfdZ69evUosRBgeHs7Ro0cBOHbsGPv37+euu+6yPx4QEMAtt9zCqlWrSgSgi+1HRESqr4Rj6Tw6K5YjaTm4u1r4V7+23Nc9zNTlTEybAjt+/DjJycl07ty5xPYuXboQFxdX5j75+fmsWbOG2267jczMTLZs2cKJEycuWU9+fj4ZGRklfmoiPz8/unbtSq9evZg2bRoHDx60j7AMGTKEwsJCFi9eTFpaGgsXLiwRIi/kr+fyALi6utoXi/zjdhV/H3kLDAwkOTnZ4f2IiEj1YxgGX64/zKCP1nEkLYdGAV58/XB37u/RzPS13EwbAUpLK573q1evXont9erVsz9Wlj6pqakUFhaybds2wsPDadCgAfv376dbt27Mnj37nL5/mDBhAuPHjy/TsXi5u7LztZvK1PdyebmX7hYQfz0J+u9q1arF3XffzWeffcaxY8eoW7cuffv2tT9eljdraGgoAImJiTRt2tS+PTExkSZNzDv5TUREKlZmXiHjFmzn+23FgxA3tg3mvaGR+Hu7m1xZMdMCkLt78QuQl5dXYntubu4FbzHhSJ8/2vz8889s3bqV+vXrc/r0abp168bYsWOZMWPGefc9btw4nn76afvvGRkZ9i/vS7FYLKWahqrKRo4cSXR0NHv27OHee+8tMSVVt27dC4bTCwkKCuKaa67hww8/pGfPnri4uLBr1y5+/PFH5s6dW97li4hIFbDzeAajZsdyKDUbNxcLz/dtw4M9zR/1+SvTvrX/uIv6sWPHSmw/duzYBUcGHOkTGBhI7dq1GTRoEPXr1weKR4iGDh3KV199dcF6PD098fT0vJxDqhE6duxIVFQUmzdv5v777y/xWP/+/bn77rspKCjAx8enxGXwF/PRRx/Rp08foqOjadmyJcuXLycmJoaBAwdWxCGIiIhJDMNg7qYkXlm0g4IiGw39azElJprOTeuYXdo5TAtA3t7edO/enUWLFnH33XcDkJ2dzfLly3n11Vft7fbv309mZiZRUVEO9XFxcaF3797nhKSjR49e8mTemu6BBx4gMzPzku2ioqKoVasWrVu3LrF90KBBbN68mfj4eLKzs/Hy8mLMmDHnnN8zfPhwsrOz7b+3b9+effv28euvv3LmzBleeuklIiMjS/RxZD8iIlJ1ZecX8cK32/lu63EAeoUH8f6wTtSpXTVvHG4xDMMw68lXrVpF7969GTNmDN26dWPKlCkcOnSIrVu34uPjA8CIESPYsGGDfX0aR/ps376dHj168NRTT9GjRw82btzIa6+9xrx58xwedcjIyMDf35/09PRzFlrMy8vj0KFDNGvWjFq1apXjK2K+jIwMmjZtyrRp04iJiTG7nIuqyf8dRESqkz0nM3l01hYOnMrG1cXCMzeF89DVzXFxqfwpr4t9f/+VqQshXnvttaxYsYLExEQ+/PBD2rdvz5o1a+xBBqBVq1Yl1oFxpE9ERATr1q3j6NGjvPvuuxw6dIhVq1ZpyuUSnnnmGa655hqaN2/OsGHDzC5HRESqgXmbk+g/bQ0HTmXTwK8Wcx/qysPXtjAl/JSGqSNAVZkzjgDNmTMHNzc3+vbtWyJQVlU19b+DiEh1kFNQxEvf7eCb2OL12q5pHcQHwyKp52Pu+bSOjgDVjEuXpFz8dbFCERGRC9mfkskjM2PZl5KFiwWe7t2aR69rWeVHff5KAUhEREQctiD2KC98m0BuoZUgX08m3xlFtxbnX2OvKlMAEhERkUvKK7TyysIdfLU5CYAeLevx7zuiCPKtnkvIKACJiIjIRR04lcWoWbHsPpmJxQJP3NCK0de3wrUaTXn9nQKQiIiIXNDCrcf414LtZBdYCfTx4MM7o+jRMvDSHas4BSARERE5R16hlde/38msjUcA6Nq8LpPvjKK+X8246lYBSEREREo4nJrNo7Ni2XkiA4sFHuvVkiduaIWbq6nLB5YrBSAnsnnzZg4fPgwU3zS2cePGdOzY0X4D2fJw7NgxtmzZwu23315u+xQRkcrz4/YTPDt/G1n5RdSt7cEHd3Ti2tY171ZSCkBOZOrUqfzwww9ce+21FBUVERcXh5ubG4sWLaJ9+/bl8hzr169nxIgRnD17tlz2JyIilSO/yMpbP+zi8/WJAFwZVofJd0UR4u9lcmUVQwHIybRv35758+cDUFBQQPfu3XniiSdYvnw5UHzz2UOHDtG7d297n+TkZNauXcugQYPs2zIyMoiNjQUgOjoaPz8/Tp06xYYNGygsLLQ/R5s2bejQoUNlHZ6IiJRBUloOo2bHsu1oOgAPX9uCsX1a16gpr79TAHJiHh4e9OnTh08//dS+7fvvv+e///2v/eazAHFxcQwbNoyioiIAVqxYweDBgwkPD8fHx4cDBw4wefJkmjVrxtq1ayksLGTu3LkADBw4UAFIRKQKW5pwkmfmx5OZV0SAtzvvD4vk+jbBZpdV4RSAyoNhQGGOOc/t7g2Wsq/DcPDgQQIDS3c544QJE3jwwQeZOHEiAOnp6WzcuJH27dszZswYRowYYR8BEhGRqqmgyMbbS3bz2dpDAEQ3CWBKTDSNAmrmlNffKQCVh8IceKuhOc/9r+PgUdvh5qdOnWL+/PkUFRWxceNGFixYwJdfflmqp/T09CQxMZHc3Fy8vLzw9/enT58+pa1cRERMcvRMDo/NjmNr0lkARl7djGdvboN7DZ7y+jsFICeTkpLC3Llzyc/PZ926dfTt25eBAweWah/vvvsuDzzwAEFBQfTo0YNbb72VkSNH6o7sIiLVwPKdyYz5Op703EL8arnx3rBO9G5X86e8/k4BqDy4exePxJj13KXw15Ogk5OTueKKK3j++ed5//33AXBxccFms5Xok5eXV+L3tm3bsn79ek6cOMGvv/7Km2++ybJly/j+++8v40BERKQiFVptTFq2h09+OwhAZGgAU++KIrRu6b5HagoFoPJgsZRqGqqqCA4O5r333iMmJoaRI0fStm1bGjVqxLFjx8jPz8fTs/gGd6tWrSrR78SJE4SEhBASEsLw4cOx2Ww88cQTAPj4+JCfn1/pxyIiIhd2/Gwuo+fEsSXxDAD39whjXN+2eLg5z5TX3ykAOblhw4YxadIkxo0bx3fffUfv3r2pVasWd955JwMHDmTz5s3MmzevRJ+7776b0NBQevTogdVq5YMPPmDw4MEAREREYLVaeemll4iMjNRl8CIiJluxJ4Wnv9rKmZxCfD3deHdIR/pGhJhdlumcN/o5oSuvvJJrr732nO3//ve/cXd358SJE/j5+bFx40ZatmzJypUrCQ8PZ9GiRfaAA7Bs2TKuv/56fv/9d+Li4njppZf4+OOPAWjUqBFLliwhNTWVr776ivj4+Eo7PhER+VOR1ca7S3dz/4xNnMkppEMjP75/vKfCz/9YDMMwzC6iKsrIyMDf35/09HT8/PxKPJaXl8ehQ4do1qyZTvw1kf47iIicX3JGHqPnxPH7oTQA7unalBduaUstd1eTK6t4F/v+/itNgYmIiNQgq/ed4sm5WzmdXYCPpxsTBkVwW6RJS7VUYQpAIiIiNYDVZvDh8r1MWbEfw4C2IX58NDyaZoHV7yKdyqAAJCIiUs2lZObxxJytrD94GoC7ujThldvaOcWUV1kpAImIiFRj6/an8vjcraRm5ePt4cqEQRH079TI7LKqPAUgERGRashqM5i2Yj//Xr4XmwHhwb5MGx5Ny/o+ZpdWLSgAXQZdQGcuvf4i4qxSs/J56qutrN6XCsCwKxoz/vYOeHloystRCkBl4Opa/AYrKCjAy8s57ppbFeXk5ADg7u5uciUiIpVn48HTjJ4TR0pmPrXcXXhjQARDOjc2u6xqRwGoDNzc3PD29ubUqVO4u7vj4qL1JCuTYRjk5OSQkpJCQECAPZCKiNRkNpvBx6sO8N5Pe7AZ0LK+Dx8Nj6Z1sK/ZpVVLCkBlYLFYCAkJ4dChQyQmJppdjtMKCAigQYMGZpchIlLh0rILeOqrrazaewqAQVGNeGNgB7w99DVeVnrlysjDw4NWrVpRUFBgdilOyd3dXSM/IuIUNh9OY/ScOE6k5+Hp5sJr/dsz7IpQLBaL2aVVawpAl8HFxUW3YBARkQphsxl8uvog7y7bg9Vm0DywNtOGR9M25MK3dxDHKQCJiIhUMWdzChgzL55fdqcAcHtkQ94aFIGPp762y4teSRERkSok9sgZRs+O49jZXDzcXHjltnbEdGmiKa9ypgAkIiJSBRiGwfQ1h3h7yW6KbAZh9byZGhNNh0b+ZpdWIykAiYiImCw9p5Bn5sfz085kAG6JCOHtwRH41tI6ZxVFAUhERMRE246e5dFZsRw9k4uHqwsv3tqWe7o21ZRXBVMAEhERMYFhGHy+7jBv/riLQqtBaF0vpsVE07FxgNmlOQUFIBERkUqWkVfI899s48ftJwG4qX0w7w6JxN9LU16VRQFIRESkEiUcS2fU7FgST+fg7mphXN+23N8jTFNelUwBSEREpBIYhsGsjUd4bfFOCqw2GgV4MW14NJ1CA8wuzSkpAImIiFSwrPwixi3YzuL44wDc2LY+k4ZGEuDtYXJlzksBSEREpALtOpHBqFmxHEzNxtXFwnM3hzPy6uaa8jKZApCIiEgFMAyDrzYl8cqiHeQX2Qjxr8XUmCg6N61rdmmCApCIiEi5y84v4sXvEvg27hgA14UH8f6wTtStrSmvqkIBSEREpBztTc7kkZlbOHCqeMprTJ/WPHxNC1xcNOVVlZgegI4cOcLnn39OcnIyERER3HfffXh6el5Wn5kzZ7Jy5coSfRo1asT48eMr4hBEREQA+HpzEi8tTCCv0EawnydT7oqmSzNNeVVFLmY++c6dO4mMjCQ2NpbQ0FAmT57M9ddfT2Fh4WX1WbNmDVu3bqVr1672n8jIyMo4JBERcUK5BVbGfh3PM/O3kVdo4+pWgfzw+NUKP1WYxTAMw6wnv+2228jJyWH58uVYLBZOnDhBs2bN+Oijj3jggQfK3Ofhhx8mNTWV+fPnl7m2jIwM/P39SU9Px8/Pr8z7ERGRmm1/ShajZsWyJzkTFws8dWNrRvVqqSkvkzj6/W3aCFBBQQHLli3jzjvvtF8KGBISQq9evVi8ePFl99mzZw+PP/44L730Ej/99FPFHoyIiDil7+KOcfvUNexJziTQx5OZI65i9A2tFH6qAdMC0JEjRygsLCQsLKzE9mbNmrF///7L6mOxWGjevDlhYWHk5OQwePBg7rvvvovWk5+fT0ZGRokfERGR88krtDJuwTae/GorOQVWujWvx49P9KR7i0CzSxMHmXYSdG5uLgC+vr4ltvv6+tofK2ufl19+mZCQEPvvgwcPpmfPntx5553cfPPN5933hAkTdJK0iIhc0sFTWYyaHceuExlYLDD6+lY8cUMrXDXqU62YNgL0x7zcmTNnSmxPS0u74Jydo33+Gn4AunfvTmhoKOvWrbtgPePGjSM9Pd3+k5SU5PjBiIiIU1gcf5zbpqxh14kM6tX24IsHuvB079YKP9WQaQEoNDQUPz8/du7cWWL7jh076NChQ7n1+UNubi4XO9/b09MTPz+/Ej8iIiJQPOX14nfbGT0njuwCK12a1eXHJ67m6lZBZpcmZWRaAHJxceGOO+7gs88+Izs7G4BNmzaxYcMG7rrrLnu7zz//nFdeecXhPkVFRfzwww8lnuvTTz/l1KlT9O3btzIOTUREapDE09kM/ngdMzccAWBUrxbMHnEVwX61TK5MLoepl8GnpqZyww03kJ2dTceOHfnll1+4++67mTZtmr3NiBEj2LBhAwkJCQ71sVqtDB06lAMHDtCuXTuOHDlCfHw8b7zxBk8++aTDtekyeBERWbL9BM/O30ZmfhF1vN354I5OXBde3+yy5CIc/f42NQABFBYWsmLFCvuqzp06dSrx+Jo1a0hJSWHQoEEO94Hiy+C3bt1KnTp1iI6OJjCwdGfmKwCJiDiv/CIrE37czf9bdxiAK5rWYUpMFCH+XuYWJpdUbQJQVaUAJCLinJLScnhsdizxR9MB+Oe1zRnbJxx3V1NvniAOcvT72/R7gYmIiFQVP+04ydiv48nIK8Lfy533h0VyQ9tgs8uSCqAAJCIiTq/QauOdJbv575pDAEQ1CWBqTDSNAjTlVVMpAImIiFM7djaXx2bHEnfkLAAjejbj2Zvb4OGmKa+aTAFIRESc1q+7k3l6XjxncwrxreXGpKGR3NS+gdllSSVQABIREadTaLUx6ac9fLLqIAAdG/szLSaa0LreJlcmlUUBSEREnMqJ9FxGz45jc2LxbZXu6x7GuH5t8HRzNbkyqUwKQCIi4jRW7knh6XnxpGUX4OvpxjtDOtIvIuTSHaXGUQASEZEar8hq44Ple5m24gAA7Rv6MS0mmrDA2iZXJmZRABIRkRotOSOPx+fEsfFQGgB3d23Ci7e0o5a7prycmQKQiIjUWGv2pfLkV3GkZhVQ28OVCYM7cntkQ7PLkipAAUhERGocq81g8i/7mPzrPgwD2jTw5aPh0TQP8jG7NKkiFIBERKRGScnM48m5W1l34DQAd3UJ5ZXb2mvKS0pQABIRkRpj3YFUnpi7lVOZ+Xi5u/LWoA4MjGpsdllSBSkAiYhItWezGUxbsZ8Plu/FZkDrYB8+Gh5Ny/q+ZpcmVZQCkIiIVGuns/J58qutrN6XCsCQzo15rX97vD30FScXpneHiIhUW78fSmP0nFiSM/Kp5e7C6/07MPSKULPLkmpAAUhERKodm83g/347wHs/7cVqM2gRVJuPhncmvIGmvMQxCkAiIlKtnMku4Ol5W1mx5xQAA6Ma8caADtT21FeaOE7vFhERqTa2JKbx2Ow4TqTn4enmwvjb23PHlaFYLBazS5NqRgFIRESqPMMw+HT1Qd5duocim0GzwNp8NDyatiF+Zpcm1ZQCkIiIVGlncwoY+3U8y3elAHBbZEMmDIrAR1Nechn07hERkSor7sgZHpsdx7GzuXi4uvDybe0YflUTTXnJZVMAEhGRKscwDD5be5i3l+yi0GrQpK43Hw2PpkMjf7NLkxpCAUhERKqU9NxCnp0fz7IdyQD07dCAd4Z0xK+Wu8mVSU2iACQiIlXG9qPpPDp7C0lpubi7WnihX1vu7R6mKS8pdwpAIiJiOsMw+HJDIm98v4sCq43GdbyYFhNNZGiA2aVJDaUAJCIipsrMK+T5b7bzw/YTAPRuF8ykIZH4e2vKSyqOApCIiJhmx/F0Rs2K5fDpHNxcLDzftw0P9mymKS+pcApAIiJS6QzDYPbvRxi/eCcFRTYaBXgxJSaK6CZ1zC5NnIQCkIiIVKqs/CL+tWA7i+KPA3BDm/q8NyySAG8PkysTZ6IAJCIilWb3yQwenRnLwdRsXF0sPHtTOCOvbo6Li6a8pHIpAImISIUzDIOvNx/lpYUJ5BfZaOBXi6kxUVwRVtfs0sRJKQCJiEiFyiko4sXvElgQewyAa1sH8f6wSOr5eJpcmTgzBSAREakw+5IzeXRWLPtSsnCxwJg+4TxybQtNeYnpFIBERKRCfLPlKC9+l0BuoZX6vp5MviuKrs3rmV2WCKAAJCIi5Sy3wMorixKYt/koAD1bBvLvOzsRqCkvqUIUgEREpNzsT8li1KxY9iRnYrHAkze05rHrW+KqKS+pYhSARESkXCzceoxxC7aTU2Al0MeTyXd2onvLQLPLEjkvBSAREbkseYVWxi/eyZzfjwDQtXldJt8VRX3fWiZXJnJhCkAiIlJmh1KzeXRWLLtOZGCxwOheLXnixtaa8pIqTwFIRETK5Pttx3n+m+1k5RdRr7YHH9zRiWtaB5ldlohDFIBERKRU8ousvPnDLr5YnwhAl7DiKa8G/prykupDAUhERBx25HQOj87eQsKxDAAeva4FT/dujZuri8mViZSOApCIiDhkacIJnpm/jcy8Iup4u/P+HZ3oFV7f7LJEysT0yD5lyhRatGiBj48P3bp1Y/369eXa51//+hdubm6MGTOmPMsWEXEaBUU2xi/ewcMzY8nMK6Jz0zr88PjVCj9SrZkagGbMmMFzzz3He++9x4EDB+jevTt9+vQhKSmpXPosX76cBQsW0Lx5c6xWa0UeiohIjZSUlsPQT9YzY+1hAB66pjlzH+pKwwAvcwsTuUymBqCJEyfywAMPMGDAAIKDg5k0aRJ+fn58/PHHl90nJSWFBx54gC+//BJvb++KPhQRkRrn553J3DJ5NfFJZ/H3cue//7iCf/Vri7vO95EawLR38ZkzZ9i1axe9evWyb7NYLPTq1Yt169ZdVh/DMPjHP/7BP//5T6688sqKOwgRkRqo0GrjzR92MvKLzWTkFREZGsAPj/fkxnbBZpcmUm5MOwn6xIkTANSvX3IOOSgoiM2bN19Wn4kTJ5Kdnc3zzz/vcD35+fnk5+fbf8/IyHC4r4hITXH8bC6PzY4l9shZAB7o0Yzn+7bBw02jPlKzVLmrwFxcXDAMo8x9tmzZwsSJE9m0aROurq4O72PChAmMHz++VM8rIlKTrNidwlPztnI2pxDfWm5MHBLJzR0amF2WSIUwLdI3aFD8j+rUqVMltqekpBAcfP5hVkf6rF+/ntOnT9OyZUvc3Nxwc3MjPj6eyZMn4+bmdsGToceNG0d6err952InYouI1CRFVhtvL9nN/f9vE2dzColo5M8Po69W+JEazbQAVLduXVq3bs2qVavs2wzDYOXKlXTv3r3MfUaNGkVBQQF5eXn2n8jISEaPHk1eXt4FR4U8PT3x8/Mr8SMiUtOdTM/jrk838H+rDgBwb7emzH+kG03q6eIRqdlMndQdM2YM06dPZ9myZaSnp/Piiy+SlpbGww8/bG/zz3/+k06dOjncx2Kx2Ed+/vj563YRESm2au8p+k1ezabDZ/DxdGNaTDTj+3fA083x0wdEqitTE8FDDz3E2bNnuf/++0lJSaFDhw78+OOPhIWF2dtYrVaKiopK1UdERC7MajP49/K9TF2xH8OAdiF+TBseTbPA2maXJlJpLEZpzziuZDabDcMwSnVC899ZrVYsFgsuLo4PeGVkZODv7096erqmw0SkxkjJyOPxuXFsOJgGQMxVTXj51nbUcteoj9QMjn5/V/k5odKElgu5nPAkIlJTrN2fyhNz40jNKqC2hytvDYqgf6dGZpclYooqH4BEROTyWG0GU37dx4e/7MMwoE0DX6YNj6ZFkI/ZpYmYRgFIRKQGO5WZz1NfbWXN/lQA7rgilFdvb4+Xh0bGxbkpAImI1FAbDp5m9Jw4TmXm4+XuypsDOzAourHZZYlUCQpAIiI1jM1m8NHK/bz/815sBrSq78NHw6NpFexrdmkiVYYCkIhIDXI6K5+n5sXz297iFfMHRzfm9QHt8fbQx73IX+lfhIhIDbHpcBqjZ8dxMiMPTzcXXh/QgWFXhJpdlkiVpAAkIlLN2WwGn/x2kEk/7cFqM2geVJuPhkfTpoHWMBO5EAUgEZFq7Ex2AWO+jufX3SkA9O/UkLcGRlDbUx/vIhejfyEiItXUlsQzjJ4dy/H0PDzcXHj1tvbc1SUUi8VidmkiVZ4CkIhINWMYBtPXHOLtJbspshmE1fNm2vBo2jf0N7s0kWpDAUhEpBpJzylk7Px4ft6ZDMAtHUN4e1AEvrXcTa5MpHpRABIRqSbik84yanYsR8/k4uHqwku3tuXurk015SVSBgpAIiJVnGEY/L91h3nrx10UWg2a1PVmWkw0EY015SVSVgpAIiJVWEZeIc/N38aShJMA3Ny+Ae8M6Yi/l6a8RC6HApCISBWVcCydR2fFciQtB3dXC//q15b7uodpykukHCgAiYhUMYZhMHNDIq9/v4sCq41GAV5MGx5Np9AAs0sTqTEUgEREqpDMvELGLdjO99tOAHBj22DeGxqJv7emvETKkwKQiEgVsfN4BqNmx3IoNRs3FwvP923Dgz2bacpLpAIoAImImMwwDOZuSuKVRTsoKLLR0L8WU2Ki6dy0jtmlidRYCkAiIibKzi/ihW+3893W4wD0Cg/i/WGdqFPbw+TKRGq2Ugegw4cPM2/ePH777TeOHj0KQGhoKNdccw3Dhg2jadOm5V6kiEhNtOdkJo/O2sKBU9m4ulgY2yecf17THBcXTXmJVDQXRxsePHiQIUOG0KpVK2bOnElwcDD9+vWjX79+1K9fny+++IKWLVsydOhQDh48WJE1i4hUe/M2J9F/2hoOnMom2M+TuQ915ZHrWij8iFQSh0eAunXrxkMPPcSkSZMICws7b5vDhw8zffp0unXrRnJycnnVKCJSY+QUFPHSdzv4JrZ4BP2a1kF8MCySej6eJlcm4lwshmEYjjQ8ffo09erVc2inpWlbVWVkZODv7096ejp+fn5mlyMiNcC+5EwenRXLvpQsXCzwdO/WPHpdS436iJQjR7+/HR4BuligMQyDAwcO0KBBA3x8fKp9+BERKW8LYo/ywrcJ5BZaCfL1ZPKdUXRroc9KEbM4fA7QX23atIlRo0bZf4+JiaFVq1Y0aNCA1atXl1txIiLVXV6hlefmb+PpefHkFlrp0bIePz5+tcKPiMnKdBn82LFjeeuttwDYtm0bS5YsYfPmzSxbtowXXniB3377rVyLFBGpjg6cymLUrFh2n8zEYoEnbmjF6Otb4aopLxHTlSkAbdmyhejoaAB+/vlnBg0aROfOnQkPD+ftt98u1wJFRKqjhVuP8a8F28kusBLo48GHd0bRo2Wg2WWJyP+UaQrMz8/Pfqn74sWL6dWrFwBnz57VCcMi4tTyCq288O12npi7lewCK1c1q8uPj1+t8CNSxZRpBGjYsGHccssttGvXju3bt3PrrbcCsHTpUvr161euBYqIVBeHU7N5dFYsO09kYLHAqOta8uSNrXBzLdPfmiJSgcoUgCZNmkSrVq1ITExkwoQJ1KlTfL+aAwcO8PLLL5drgSIi1cEP207w3DfbyMovom5tDz64oxPXtg4yuywRuQCH1wFyNloHSEQckV9k5a0fdvH5+kQArgyrw+S7ogjx9zK5MhHn5Oj3t8PjskOHDmX37t2XbLdz506GDh3q6G5FRKqtpLQchv7fenv4efjaFswZ2VXhR6QacHgKrGvXrnTt2pWoqChuu+02OnfuTHBwMIZhcPLkSTZt2sSiRYvYvn07L730UkXWLCJiuqUJJ3lmfjyZeUUEeLvz/rBIrm8TbHZZIuKgUk2BnT59mk8++YS5c+eSkJDAH10tFgsRERHcddddjBw5skasBK0pMBE5n4IiG28v2c1naw8BEN0kgCkx0TQK0KiPSFXg6Pd3mc8BSk9P59ixY1gsFho2bIi/v3+Zi62KFIBE5O+OnsnhsdlxbE06C8DIq5vx7M1tcNdVXiJVRrnfC+zv/P39a1zoERG5kOU7kxnzdTzpuYX41XJj0tBI+rRvYHZZIlJGZf6zJTMzk2+++YaJEyfat+3atQtdVCYiNUmh1cZbP+5ixBebSc8tJLKxPz88frXCj0g1V6YpsN27d9O7d29sNhvHjx+3h557772Xm266iZiYmHIvtLJpCkxEjp/NZfScOLYkngHg/h5hjOvbFg83TXmJVFXlfhn8Xz311FPcc889HD16tMT2xx9/nEmTJpVllyIiVcqKPSncMnk1WxLP4OvpxsfDo3nltvYKPyI1RJlGgAICAjh8+DABAQFYLBb7CFB2djZ169YlPz+/3AutbBoBEnFORVYb7/28l49XHgCgQyM/psVE07RebZMrExFHVOhJ0IZh2EOOxWKxbz948KBOjBaRais5I4/Rc+L4/VAaAPd0bcoLt7SllruryZWJSHkr01hunz59ePfdd4E/A1BKSgqPPfYYffv2Lb/qREQqyep9p+j34Wp+P5SGj6cbU+6K4vUBHRR+RGqoMk2BJSUlcd111+Hi4sL+/fvp2bMncXFxNGjQgNWrVxMSEuLwvqxWK+vWrSM5OZmIiAjCw8PLpU9WVhabNm0iKyuLdu3a0aJFi1Ido6bARJyD1Wbw4fK9TFmxH8OAtiF+fDQ8mmaBmvISqY4qdAosNDSUbdu2MXv2bDZv3ozNZiMmJoZ77rkHHx8fh/dz5swZbrrpJk6ePEn79u1Zs2YN//znPy96IrUjff7zn/8wYcIEWrdujZubG6tWrWLQoEHMmDEDV1f9NScixVIy83hizlbWHzwNwF1dmvDKbe006iPiBMq8EGLt2rUZOXIkI0eOLPOTv/DCC2RkZLBjxw58fX1Zt24dPXv25KabbqJ3795l7hMcHExCQgK1axf/Bbdjxw46dOjA4MGD6d+/f5nrFZGaY93+VB6fu5XUrHy8PVx5a2AEA6IamV2WiFSSy7qe02azkZWVdc6PIwzDYM6cOTz44IP4+voC0L17d7p06cKsWbMuq0///v3t4QcgLCwMNzc3cnJyynqoIlJDFE957ePu6RtJzconPNiXRY/1VPgRcTJlGgHas2cPDz/8MOvWraOgoOCcxx05rSgpKYmzZ8/SoUOHEtsjIiKIjY297D4nTpzgl19+ISMjg1mzZnH77bczePDgC9aTn59f4vL9jIyMSx6DiFQvqVn5PDl3K2v2pwIw7IrGjL+9A14emvIScTZlCkD33nsvDRo0YOHChQQEBJTpidPT0wGoU6dOie1169a1P3Y5fU6dOsXSpUtJTU3lwIED9O7dGze3Cx/uhAkTGD9+fKmPQ0Sqh40HTzN6ThwpmfnUcnfhjQERDOnc2OyyRMQkZQpA8fHxLF26tMzhB8DLywvgnCmzzMxM+2OX06djx47MnDkTKB6xuuKKKwgJCeGf//znefc9btw4nn76afvvGRkZhIaGluKIRKQqstkMPl51gPd+2oPNgJb1ffhoeDStg33NLk1ETFSmc4DCwsJISUm5rCcODQ3F3d2dxMTEEtsTExNp3rx5ufUBCA8PJzo6mrVr116wjaenJ35+fiV+RKR6S8su4P7/t4mJy4rDz6CoRix6rIfCj4iULQC99tpr3H///axZs4YTJ05w8uTJEj+O8PT05IYbbmDevHn2badOneLXX3/llltusW/bsGED33//vcN9ioqKSE5OLvFcmZmZ7NmzhyZNmpTlcEWkGtp8OI1bJq9m1d5TeLq58M7gCN4bFom3R5kvfhWRGqRMCyH++uuvDBw48IInCju6y23bttGjRw9uvfVWunXrxmeffYa7uztr167Fw8MDgBEjRrBhwwYSEhIc6pOfn09UVBR9+vShXbt2nD17li+++ILCwkLWrFlDUFCQQ7VpIUSR6slmM/h09UHeXbYHq82geWBtpg2Ppm2I/h2LOANHv7/LFIDatGlDdHQ0jz766HnPA/r7VVoXc+DAAaZPn25f1fmhhx7C29vb/vj06dPZv38/EyZMcLhPTk4OM2fOJC4ujtq1axMVFcWwYcNwd3d3uC4FIJHq52xOAWPmxfPL7uIp+tsjG/LWoAh8PDXqI+IsKjQAeXt7c/LkyRodDBSARKqX2CNnGD07jmNnc/Fwc+GV29oR06VJiRs2i0jNV6G3wmjVqhVHjx6lXbt2ZS5QRKQ8GIbB9DWHeHvJbopsBmH1vJkaE02HRv5mlyYiVViZAtDdd9/N3XffzTvvvEPLli3P+QsrLCysPGoTEbmo9JxCnpkfz087iy98uCUihLcHR+Bby/HpbhFxTmWaArvUkHIZdlnlaApMpGrbdvQsj86K5eiZXDxcXXjx1rbc07WpprxEnFyFToHt27evzIWJiFwOwzD4fN1h3vxxF4VWg9C6XkyLiaZj4wCzSxORaqRMAahly5blXYeIyCVl5BXy/Dfb+HF78XpjN7UP5t0hkfh7acpLRErH4QD0xzo8HTp0sP//CynNZfAiIo5IOJbOqNmxJJ7Owc3Fwrh+bXmgR5imvESkTBwOQBEREUDx8PMf//9CasI5QCJSNRiGwayNR3ht8U4KrDYaBXgxNSaKqCZ1Lt1ZROQCHA5AJ06cOO//FxGpKFn5RYxbsJ3F8ccBuLFtfSYNjSTA28PkykSkunM4ADVo0IARI0bw3//+lwYNGlRkTSIi7DqRwahZsRxMzcbVxcJzN4cz8urmmvISkXJRqsvgLRaL00xv6TJ4EXMYhsFXm5J4ZdEO8otshPjXYmpMFJ2b1jW7NBGpBir0MngRkYqQnV/Ei98l8G3cMQCuCw/i/WGdqFtbU14iUr4UgESkStibnMkjM7dw4FTxlNeYPq15+JoWuLhoyktEyl+pA5Cb26W7FBUVlakYEXFOX29O4qWFCeQV2qjv68mUu6K4qnk9s8sSkRqs1AFo6tSpFVGHiDih3AIrLy1MYP6WowBc3SqQD+7oRKCPp8mViUhNV+oA9PDDD1dEHSLiZPanZPLorFj2JmfhYoGnbmzNqF4tNeUlIpVC5wCJSKX7Nu4oL3ybQE6BlUAfTybf1YnuLQLNLktEnIgCkIhUmrxCK+MX72DO70kAdGtejw/v6kR931omVyYizqZUASg3N7ei6hCRGu7gqSwenRXL7pOZWCww+vpWPHFDK1w15SUiJihVAKpVS3+liUjpLY4/zvPfbCO7wEq92h78+85OXN0qyOyyRMSJaQpMRCpMXqGVN37YycwNRwDo0qwuU+6KIthPf0yJiLkUgESkQiSezubRWbHsOJ4BwKheLXjqxta4ubqYXJmIiAKQiFSAJdtP8Oz8bWTmF1HH250P7ujEdeH1zS5LRMROAUhEyk1+kZUJP+7m/607DMAVTeswJSaKEH8vcwsTEfkbBSARKRdJaTk8NjuW+KPpAPzz2uaM7ROOu6a8RKQKUgASkcv2046TjP06noy8Ivy93Hl/WCQ3tA02uywRkQtSABKRMisosvHO0t1MX3MIgKgmAUyNiaZRgKa8RKRqUwASkTI5djaXUbNi2Zp0FoAHezbjuZvb4OGmKS8RqfoUgESk1H7dnczT8+I5m1OIby03Jg2N5Kb2DcwuS0TEYQpAIuKwQquNST/t4ZNVBwHo2NifaTHRhNb1NrkyEZHSUQASEYecSM9l9Ow4NieeAeC+7mGM69cGTzdXkysTESk9BSARuaSVe1J4el48adkF+Hq68c6QjvSLCDG7LBGRMlMAEpELKrLa+GD5XqatOABA+4Z+TIuJJiywtsmViYhcHgUgETmv5Iw8Hp8Tx8ZDaQDc3bUJL97SjlrumvISkTKyWeF4HOxfDifi4c7ZYLGYUooCkIicY82+VJ6YG8fp7AJqe7gyYXBHbo9saHZZIlIdZSbDgV+KQ8+BXyH3zJ+PpeyC4HamlKUAJCJ2VpvB5F/2MfnXfRgGtGngy0fDo2ke5GN2aSJSXVgLIWljceDZvxxObi/5uKc/tLgOWt4IvuYtn6EAJCIApGTm8eTcraw7cBqAO68M5dXb22vKS0Qu7eyR/wWeX+DgKijILPl4w6jiwNPyRmh0BbiaHz/Mr0BETLfuQCpPzN3Kqcx8vNxdeWtQBwZGNTa7LBGpqgpzIXFtceDZvxxS95Z83DsQWt5QHHia9wKfIHPqvAgFIBEnZrMZTFuxnw+W78VmQOtgHz4aHk3L+r5mlyYiVYlhwOn9f05rHV4DRXl/Pm5xhdAuf4aeBpHgUrVvi6MAJOKkTmfl8+RXW1m9LxWAIZ0b81r/9nh76GNBRID8TDj025+h5+yRko/7Nfoz8DS7FrwCTCmzrPRJJ+KEfj+Uxug5sSRn5FPL3YXX+3dg6BWhZpclImYyDEhO+PNcniPrwVb05+OuHtC0+5/n8gS1Me0S9vKgACTiRGw2g//77QDv/bQXq82gRVBtPhremfAGmvIScUo5aXBwxf/O5fkFsk6WfLxu8z8DT1hP8Kg5i6AqAIk4ibTsAsbM28qKPacAGBjViDcGdKC2pz4GRJzGXxci3L8cjm0Bw/bn4+7e0Oya4sDT4nqo18K8WiuYPvlEnMCWxDQemx3HifQ8PNxceO329txxZSiWajx8LSIOuthChAD12/15Lk+TbuDmaU6dlUwBSKQGMwyDT1cf5N2leyiyGTQLrM20mGjaNfQzuzQRqSilWYiwxQ3g38iUMs1megDavHkzH3/8McnJyURERDB27Fjq1at3WX0yMzP57LPPWLduHW5ubvTs2ZMHH3wQDw+Pij4ckSrjbE4BY7+OZ/muFABui2zIhEER+GjKS6TmqYYLEZrNYhiGYdaTr1u3jl69evHII4/QrVs3PvroI5KTk9myZQu1a5//RKtL9bHZbDRv3pyBAwfSrVs3cnJyeOONNwgLC2PZsmW4ujq2qm1GRgb+/v6kp6fj56e/lqV6iTtyhsdmx3HsbC4eri68dFs77r6qiaa8RGqKGrAQYUVx9Pvb1AB03XXXUbduXRYsWAAUj9w0bNiQN954gyeeeKJMfQzD4OzZs9SpU8feZ8uWLVxxxRVs2LCBq666yqHaFICkOjIMg8/WHubtJbsotBo0qevNR8Oj6dDI3+zSRORy1MCFCCuKo9/fpo2B5ebmsnr1ambMmGHf5uvryw033MBPP/103gDkSB+LxVIi/AD26bHs7OwKOhoR86XnFvLs/HiW7UgGoG+HBrwzpCN+tdxNrkxEyqSGL0RoNtMCUFJSEjabjcaNS95vqHHjxqxYsaLc+gBMnDiRwMDAi47+5Ofnk5+fb/89IyPDkcMQqRK2HT3LqNmxJKXl4u5q4YV+bbm3e5imvESqEydbiNBspgWggoICALy8vEps9/b2tj9WHn2mT5/OJ598wsKFCy94XhHAhAkTGD9+vMP1i1QFhmHw5YZE3vh+FwVWG43reDEtJprI0ACzSxMRRzjxQoRmMy0A/TFNlZaWVmL76dOnz5nCKmufmTNn8sgjj/DFF19wyy23XLSecePG8fTTT9t/z8jIIDRUtwaQqiszr5Dnv9nOD9tPANC7XTCThkTi760pL5EqSwsRVhmmBaBGjRoRFBREbGxsiXASGxvLlVdeedl9Zs+ezYMPPshnn31GTEzMJevx9PTE09M5Fn+S6m/H8XRGzYrl8Okc3FwsPN+3DQ/2bKYpL5GqSAsRVkmmLgRw7733Mn36dP75z39Sv359fvzxR7Zu3crUqVPtbd5//3127drFp59+6nCfuXPncv/99/PZZ58xfPjwSj8ukYpiGAazfz/C+MU7KSiy0SjAiykxUUQ3Of+oqYiYQAsRVgumBqDx48ezY8cOWrVqRYsWLdi1axfvvvsuPXr0sLfZuXMnGzZscLhPeno699xzD/7+/syYMaPEFWNjxoyhb9++lXeAIuUoK7+Ify3YzqL44wDc0KY+7w2LJMBbC3yKmE4LEVY7pq4D9Ie9e/eSnJxM27ZtCQwMLPHYrl27SE9Pp2vXrg71KSwsZNWqVed9nnbt2tGwYUOHatI6QFKV7D6ZwaMzYzmYmo2ri4Vnbwpn5NXNcXHRlJeIKbQQYZVVLRZCrMoUgKQqMAyDeZuTeHnhDvKLbDTwq8XUmCiuCKtrdmkizkULEVYbVX4hRBG5uJyCIl78NoEFcccAuLZ1EO8Pi6Sej06QFKkUWoiwRlMAEqmC9iZn8uisWPanZOFigTF9wnnk2haa8hKpSFqI0KkoAIlUMfO3HOWl7xLILbRS39eTyXdF0bV5PbPLEqmZtBCh01IAEqkicgusvLIogXmbjwLQs2UgH9zRiSBfTXmJlBstRCj/owAkUgXsT8li1KxY9iRnYrHAkze05rHrW+KqKS+Ry6eFCOU8FIBETLZw6zHGLdhOToGVQB9PJt/Zie4tAy/dUUTOTwsRigMUgERMkldoZfzincz5vfjKkq7N6zL5rijq+9YyuTKRakgLEUop6R0gYoJDqdk8OiuWXScysFhgdK+WPHFja015iThKCxHKZVIAEqlk3287zvPfbCcrv4h6tT344I5OXNNaH84iF6WFCKWcKQCJVJL8IitvfL+LLzckAtAlrHjKq4G/prxEzksLEUoFUgASqQRHTufw6OwtJBzLAOCR61owpndr3Fz1F6qInRYilEqkACRSwZYmnOCZ+dvIzCsiwNudD4Z1oleb+maXJVI1aCFCMYkCkEgFKSiyMWHJLmasPQxAdJMApsZE0zDAy9zCRMykhQililAAEqkASWk5PDYnjvikswA8dE1znrkpHHdNeYkz0kKEUgUpAImUs593JjNm3lYy8orw93LnvaGR3Ngu2OyyRCqPFiKUakABSKScFFptvLt0N5+uPgRAZGgA02KiaFzH2+TKRCqBFiKUakbvQJFycPxsLo/NjiX2yFkAHujRjOf7tsHDTVNeUkNpIUKp5hSARC7Tit0pPDVvK2dzCvGt5cbEIZHc3KGB2WWJlC8tRCg1jAKQSBkVWW1M+mkv/7fqAAARjfyZFhNNk3qa8pIaQgsRSg2mACRSBifT8xg9J5ZNh4uvZrm3W1P+dUtbPN1cTa5M5DJoIUJxIgpAIqW0au8pnvpqK2nZBfh4uvHO4I7c0jHE7LJEykYLEYqTUgAScZDVZvDv5XuZumI/hgHtQvyYNjyaZoH6QpBqRAsRigAKQCIOScnI4/G5cWw4mAZAzFVNePnWdtRy15SXVANaiFDkHApAIpewdn8qT8yNIzWrgNoerrw1KIL+nbRwm1RhWohQ5JIUgEQuwGozmPLrPj78ZR+GAW0a+DJteDQtgnzMLk3kXFqIUKRU9C9A5DxOZebz5FdxrN1/GoA7rgjl1dvb4+WhKS+pIrQQochlUQAS+Zv1B07z+Nw4TmXm4+XuyhsDOjC4c2OzyxJnp4UIRcqVApDI/9hsBh+t3M/7P+/FZkCr+j58NDyaVsG+ZpcmzkoLEYpUGAUgEeB0Vj5PzYvnt72nABgU3Yg3BnTA20P/RKQSaSFCkUqjT3dxepsOpzF6dhwnM/LwdHPh9QEdGHZFqNllibPQQoQiplAAEqdlsxl88ttBJv20B6vNoHlQbT4aHk2bBn5mlyY1mRYiFKkSFIDEKZ3JLmDM1/H8ujsFgP6dGvLWwAhqe+qfhFQALUQoUuXo016czpbEM4yeHcvx9Dw83Fx49bb23NUlFIvOpZDyooUIRao8BSBxGoZh8N/Vh3hn6W6KbAZh9byZNjya9g39zS5NagItRChSrehfoDiF9JxCxnwdz/JdyQDc0jGEtwdF4FvL3eTKpNrSQoQi1ZoCkNR48UlnGTU7lqNncvFwdeGlW9tyd9emmvKS0tFChCI1igKQ1FiGYfD/1h3mrR93UWg1aFLXm2kx0UQ01pSXOEgLEYrUWApAUiNl5BXy3PxtLEkoXlPl5vYNeGdIR/y9NOUlF6GFCEWchgKQ1DgJx9J5dFYsR9JycHe18K9+bbmve5imvOT8tBChiFNSAJIawzAMZm5I5PXvd1FgtdEowItpw6PpFBpgdmlSlWghQhFBAUhqiMy8QsYt2M73204AcGPbYN4bGom/t6a8BC1EKCLnUACSam/n8QxGzY7lUGo2bi4Wnru5DSOubqYpL2emhQhF5BIUgKTaMgyDOb8n8eriHRQU2WjoX4spMdF0blrH7NLEDFqIUERKoUp8AhQVFZGVlUVAQEC59ikoKCAtLY26devi4eFx+YVKlZGdX8S/vt3Owq3HAegVHsT7wzpRp7b+OzsNLUQoIpfB1FW6DMPgueeew9/fn5CQEJo0acKiRYsuu09iYiLPP/88TZo0ISQkhHXr1lXkYUgl23Myk9unrmHh1uO4/m/Ka/q9Vyr81HSGAan7YMPHMHMwvBNW/L8bPioOPxbX4vN3rn8RHloJY/fBoP9Ax2EKPyJyDlNHgD744AP+85//sGrVKqKiovjwww8ZMmQI27dvJzw8vMx95s2bh7+/Pz/++COdO3euzEOSCjZvcxIvL0wgr9BGsJ8nU2OiuTKsrtllSUXRQoQiUkEshmEYZj15s2bNGDJkCBMnTrRva968OQMGDOD999+/7D5Hjx4lNDSUFStWcN1115WqtoyMDPz9/UlPT8fPz69UfaX85RQU8dJ3O/gm9igA17QO4oNhkdTz0dU6NYoWIhSRy+To97dpI0CnTp3i8OHD9OzZs8T2q6++mt9//73c+kj1ty85k0dnxbIvJQsXCzzduzWPXtcSFxd98dUIWohQRExgagACCAwMLLE9KCiI9evXl1sfR+Xn55Ofn2//PSMj47L2J+VjQexRXvg2gdxCK0G+nky+M4puLeqZXZZcDi1EKCJVgGkB6I81WoqKikpsLyoqwtXVtdz6OGrChAmMHz/+svYh5Sev0MorC3fw1eYkAHq0rMe/74giyFdTXtWSFiIUkSrGtADUsGFDAJKTk0tsT05Otj9WHn0cNW7cOJ5++mn77xkZGYSGhl7WPqVsDpzKYtSsWHafzMRigSduaMXo61vhqimv6kMLEYpIFWdaAPL39ycyMpKff/6ZYcOGAcUjOb/88gujRo2yt8vIyKCwsJB69eo53KcsPD098fTUX51mW7j1GP9asJ3sAiuBPh78+44oerYKvHRHMZ8WIhSRasTUT6AXX3yRmJgYunbtSrdu3Zg0aRI2m41HHnnE3ubpp59mw4YNJCQkONwnNzeX9PR0+zlDaWlpnDx5Eh8fH3x8fCr3IMUheYVWXv9+J7M2Fl/mfFWzuky5K4r6frVMrkwuSAsRikg1ZmoAGjJkCPn5+Xz44Ye89tprREREsHLlSurXr29v4+/vX+KkZ0f6LFq0iCeeeAKA4OBgHn30UQDGjh3L2LFjK+noxFGHU7N5dFYsO09kYLHAqOta8uSNrXBzNXWdTvk7w4DT+/+c1jq8Bory/nzc4gqhXf4MPQ0iwUX/DUWkajJ1HaCqTOsAVY4ftp3guW+2kZVfRN3aHnxwRyeuba2RgipDCxGKSDVT5dcBEueWX2TlrR928fn6RACuDKvD5LuiCPH3MrkyJ6eFCEXESSgASaU7cjqHx+bEsu1oOgAPX9uCsX1aa8rLLFqIUESckAKQVKqlCSd5Zn48mXlFBHi78/6wSK5vE2x2Wc5FCxGKiCgASeUoKLLx9pLdfLb2EADRTQKYEhNNowBNeVUKLUQoIlKCApBUuKNnchg1O474pLMAjLy6Gc/e3AZ3TXlVHC1EKCJyUQpAUqGW70xmzNfxpOcW4lfLjUlDI+nTvoHZZdVMWohQRMRh+gSUClFotTFx2R7+89tBACIb+zM1JprQut4mV1aDaCFCEZEyUwCScnf8bC6j58SxJbH4PJP7e4Qxrm9bPNw05XVZtBChiEi5UQCScrViTwpPf7WVMzmF+Hq68e6QjvSNCDG7rOpLCxGKiFQIBSApF0VWG+/9vJePVx4AoEMjP6bFRNO0ntaMKRUtRCgiUikUgOSynUzP4/E5cfx+OA2Ae7o25YVb2lLL3dXkyqoJLUQoIlLpFIDksvy29xRPfbWV09kF+Hi6MWFQBLdFNjS7rKpNCxGKiJhOAUjKxGoz+HD5Xqas2I9hQNsQPz4aHk2zQI1OnJcWIhQRqVIUgKTUUjLzeGLOVtYfPA3AXV2a8Mpt7TTl9VdaiFBEpEpTAJJSWbc/lcfnbiU1Kx9vD1feGhjBgCh9eQNaiFBEpBrRJ7A4xGozmPrrfj78ZS82A8KDfZk2PJqW9X3MLs08WohQRKTaUgCSS0rNyufJuVtZsz8VgKGdG/Na/w54eTjZlJcWIhQRqTEUgOSift2dzPPfbCclM59a7i68MSCCIZ0bm11W5dFChCIiNZICkJxXRl4hry/eyddbjgLQsr4PHw2PpnWwr8mVVTAtRCgi4hQUgOQcq/ae4vlvtnEiPQ+LBR7s0YyxN4XX3Ku8tBChiIjTUQASu8y8Qt76cRdzfk8CoGk9byYNjeTKsLomV1bOtBChiIjTUwASANbuT+XZ+ds4djYXgPu6h/HszeF4e9SQt4gWIhQRkb+oId9uUlbZ+UVMWLKLmRuKT+4NrevFu4Mj6dainsmVXSYtRCgiIhehAOTE1h84zbPfxJOUVjzqc0/Xpjzftw21Pavp20ILEYqIiIP0DeCEcgqKeHfpHv7fusMANArw4t0hHenRMtDcwkpLCxGKiEgZKQA5mU2H0xj7dTyJp3OA4vt4/atfG3xruZtcmQO0EKGIiJQTBSAnkVdoZeKyPXy29hCGASH+tXh7cEeubV3FR0W0EKGIiFQABSAnsCXxDM98Hc/B1GwAhl3RmBdvbYdfVRz10UKEIiJSCRSAarC8Qisf/LyXT1cfxGZAsJ8nbw/qSK829c0urSQtRCgiIpVMAaiG2pp0lrFfx7M/JQuAQdGNeOXW9vh7V4FRHy1EKCIiJlMAqmHyi6x8uHwf/7fqADYDAn08mTAogt7tgs0tTAsRiohIFaIAVINsP5rO2K/j2ZNcvP5N/04NefW29tSp7VH5xWghQhERqcIUgGqAgiIbU3/dx7SVB7DaDOrV9uDNgR24uUNI5RaihQhFRKSa0DdQNbfzeAZjvo5n14kMAG6JCOG1/u2p51MJU0haiFBERKopBaBqqtBq4+OVB5j8yz6KbAZ1vN15fUAHbu3YsOKeVAsRiohIDaEAVNmyTxdf8h0xpMy72HMykzFfbyXhWPGoz03tg3ljQARBvhUw6pOXDodW/3kCsxYiFBGRGkABqDLlZcC/O0BhDjToCEGtS9W9yGrjk98O8u/leym0Gvh7ufNa//bcHtkQS3ktBmgthKObi0PagRX/u0Td+ufjWohQRERqAAWgylTLr3h9m71LIX423Piqw133JWcy9ut44o+mA3Bj2/q8NTCC+n61Lq8mwyg+d+fAiuLQc3gNFGSVbFOvZfE5PK16ayFCERGpERSAKlunmP8FoLlw/Uvg4nrR5labwX9XH+S9n/dSUGTDt5Ybr97WnkHRjco+6pOVAgdX/i/0rITM4yUf965XPJ3Vohc0vw4CmpTteURERKooBaDK1roveNWFzBPFAaTVjRdseuBUFmO/jifuyFkAeoUHMWFQRxr4l3LUpyAHEtcVj/AcXFl8r62/cvWEpt2KR3la9ILgCJ28LCIiNZoCUGVz84CIofD7J7B15nkDkNVmMGPtISYu20N+kQ1fTzdeuq0dQzs3dmzUx2aFE/F/nseTtBGsBSXbNOj45whPk27g7lU+xyciIlINKACZIWp4cQDa/UPxLSG86tgfOpyazTPz49l0uPhWEVe3CuSdwR1pGHCJgHLm8J/n8Rz67dxbTfiHFoedP35qB5bnEYmIiFQrCkBmaNARgjsUT0Vtnw9dRmKzGXyx/jBvL91NXqGN2h6uvHhrO+68MvT8oz65Z4qDzh+h58zhko97+kHY1f8b5elVfENRXa0lIiICKACZw2IpPhl62b9g62yOtBjOM/Pj2XgoDYDuLerx7pCONK7j/WefonxI+v3Paa0TW0veQd3FDRpf+ed5PA2jdasJERGRCzD9GzIrK4vFixeTnJxMREQEN9xwQ7n0Kct+K1XEMIyfX8ZyPJbHPpzFtoKGeHu4Mq5fW4Z3aYKLBUje8efVWolri9cP+qvA8D/P4wnrCZ6+JhyIiIhI9WNqADp27BhXX301derUITo6mrfffpvrrruOOXPmXPBkX0f6lGW/lW3lMQN3l870sG3kFtsKvJqN5v2bg2l0Zh1892Zx8MlKLtmpdtD/zuH5X+jRHdRFRETKxNQA9Pzzz1OnTh3Wr1+Ph4cHO3fupGPHjgwbNoxBgwaVuU9Z9ltZDpzK4s0fdvHr7hR6u/Sgh8dG7qv1Gw8VHcAyY3fJxm5exasu/3EeT3B7nccjIiJSDkxb7MVqtfLtt99y77334uHhAUC7du3o2bMnX3/9dZn7lGW/leV0Vj79PlzNr7tTcHOx0KzrQGzegXgWZWI5tRuwQMMo6Pk03LsYnk+EexZA99HQoIPCj4iISDkxbQToyJEjZGdnEx4eXmJ7eHg4GzduLHOfsuwXID8/n/z8fPvvGRkZpToeR9Tz8WTYFaEcP5vLC7e0pXmQD3SYDnt/gtAri1df9q5b7s8rIiIiJZkWgLKyiu835e/vX2J7QECA/bGy9CnLfgEmTJjA+PHjS3EEZfPybe1wd/3LwNsf6/KIiIhIpTFtCqx27eIbav59pCU9Pd3+WFn6lGW/AOPGjSM9Pd3+k5SUVIqjcVyJ8CMiIiKmMO3buEmTJtSqVYv9+/eX2L5//35at25d5j5l2S+Ap6cnfn5+JX5ERESkZjItALm5uXHrrbcyc+ZMrFYrAAcPHmTVqlUlrtRasmQJ06dPd7iPo/sVERER52UxDMMw68kPHTpE9+7dCQ8Pp0uXLsybN4927drx/fff4/K/u5GPGDGCDRs2kJCQ4HAfR9pcSkZGBv7+/qSnp2s0SEREpJpw9Pvb1AAEcPr0ab766iv7is2DBg0qEVIWLFjAkSNHePLJJx3u42ibi1EAEhERqX6qTQCqqhSAREREqh9Hv791SZKIiIg4HQUgERERcToKQCIiIuJ0FIBERETE6SgAiYiIiNNRABIRERGnowAkIiIiTse0u8FXdX8sj/T3m6qKiIhI1fXH9/alljlUALqAzMxMAEJDQ02uREREREorMzMTf3//Cz6ulaAvwGazcfz4cXx9fbFYLOW234yMDEJDQ0lKStIK0xVIr3Pl0OtcefRaVw69zpWjIl9nwzDIzMykYcOGF70FlkaALsDFxYXGjRtX2P79/Pz0j6sS6HWuHHqdK49e68qh17lyVNTrfLGRnz/oJGgRERFxOgpAIiIi4nQUgCqZp6cnr7zyCp6enmaXUqPpda4cep0rj17ryqHXuXJUhddZJ0GLiIiI09EIkIiIiDgdBSARERFxOgpAIiIi4nQUgCpReno6mzdvJikpyexSqq2MjAzi4uJISUm5YJuioiLi4+PZsWPHBZdCd6SNQHJyMmvWrOHEiRPnfXz//v1s2bKF3NzcC+7DkTbObs+ePezateuC78WUlBQ2bdrEqVOnLrgPR9o4s7S0NGJjY9m3bx9Wq/W8bbKzs9myZQsHDx684H4caeNM0tPTWbt27QU/IwBOnTrFpk2bLvq5XV5tSsWQSjF58mTDy8vLaNu2reHl5WUMGjTIyMvLM7usamPfvn3GwIEDjYCAACMqKsrw8fEx+vXrZ5w+fbpEu3Xr1hmNGjUyQkNDjfr16xtt2rQx9uzZU+o2Yhi5ublGZGSkYbFYjClTppR47NSpU0b37t0Nf39/o2XLloa/v7+xYMGCUrdxdmvWrDFatWplNGzY0IiKijI6d+5s7Nu3z/64zWYzRo8ebXh6ehrt2rUzPD09jTFjxpTYhyNtnFlRUZHxwAMPGF5eXkZUVJTRqFEjIywszPjtt99KtJs1a5bh6+trtG7d2vD19TV69eplnD17ttRtnMWhQ4eMkSNHGg0aNDBcXV3P+Yz4w9ixY0u8N0ePHm3YbLYKaVNaCkCVYMOGDYbFYjEWLVpkGIZhHDt2zGjYsKExbtw4kyurPpYuXWosWLDA/oZPTU012rVrZ9x11132Njk5OUbDhg2NRx991DCM4g++fv36GdHR0aVqI8UeeeQRY9SoUUbt2rXP+XAbMmSIER0dbWRlZRmGYRgTJ040vLy8jKNHj5aqjTPbv3+/Ubt2beOFF16wv6+3b99urFq1yt7mv//9r+Hj42Ns27bNMAzD2LRpk+Hp6WnMmjWrVG2c2RdffGG4u7sbO3bsMAzDMKxWqzF8+HCjRYsW9jb79u0z3N3djf/85z+GYRjGmTNnjPDwcOP+++8vVRtnsnTpUuOTTz4xMjMzDX9///MGoJkzZxpeXl7Gli1bDMMwjPj4eMPb29uYPn16ubcpCwWgSvDQQw8ZnTp1KrHtxRdfNIKDg02qqGZ49dVXjdDQUPvvCxYsMCwWi3H8+HH7tjVr1hiAERcX53AbKX6d2rZta+Tk5JwTgNLS0gxXV1dj5syZ9m35+fmGv7+/MXHiRIfbOLuRI0carVq1MqxW6wXbdO/e3bj77rtLbBswYIBxww03lKqNM3vvvfeMwMDAEtumTJli+Pn52X9/+eWXjZCQkBIjClOnTjVq1apl5OTkONzGWV0oAF1//fXGkCFDSmy78847jR49epR7m7LQOUCVIC4ujs6dO5fY1qVLF5KTky86byoXt2nTJlq2bGn/PS4ujoYNGxISEmLf1qVLF/tjjrZxdkeOHOGRRx5h1qxZeHl5nfP49u3bsVqtJd7THh4eREZG2l9DR9o4u19++YV+/fpRWFjIli1bSExMPOccoAt9dvz1NXSkjTP7xz/+QXBwMA8//DA///wzX375Je+99x5vv/22vU1cXBzR0dElbnzdpUsX8vLy2L17t8NtpKTyev9W1HtcN0OtBGlpadSrV6/Etj9+T0tLK/FlLI6ZOXMmS5Ys4aeffrJvO9/r7O7ujq+vL2lpaQ63cWZWq5WYmBjGjh1LVFTUedv88Tqd7z3919f5Um2c3fHjx0lJSaFNmzYEBASQlJREWFgYc+fOpWXLluTl5ZGbm3ve1/DMmTMYhkF+fv4l2/z1C9sZBQYG8thjj/HCCy+wYcMGTp06Rbt27ejXr5+9TVpaGi1atCjR76+f0Y62kT8ZhsHZs2fP+97MyckhPz8fDw+PcmlT1tWkNQJUCdzd3cnLyyux7Y8rYjw8PMwoqVpbsmQJDz74IP/+97+54YYb7NvP9zoD5OXl2V9nR9o4sw8//JATJ05w1VVXsWbNGtasWYPNZuPgwYNs3rwZKH4NgfO+p//6Ol+qjbNzd3fn+++/Z+nSpcTFxXHkyBF8fX25//777Y/D+V9DNzc3LBaLQ22c3SeffMKzzz7L6tWr2bp1K0eOHKFZs2Zcf/31FBQUAI59RutzvHQsFgtubm4XfM3c3d3LrU1ZKQBVgqZNm3Ls2LES244dO4aLiwuNGzc2qarqaenSpQwaNIi3336b0aNHl3isadOmnDx5EpvNZt+WkpJCYWEhTZo0cbiNM3NzcyMkJIRx48bx/PPP8/zzz5Ofn8/ChQt55513gOLXEDjve/qvr/Ol2ji7sLAwevXqRXh4OADe3t784x//YMOGDRQWFuLq6kqjRo3O+xr+8fo60sbZff/99/Tq1Yt27doBxa/ZI488wsGDB0lISAAu/BkNlHhPX6qNlNSkSZPzvmaNGzfGxcWlXNuUhQJQJejduzfLly8nJyfHvm3hwoX06NHjvOdYyPn99NNPDBw4kDfffJOnnnrqnMd79+5NRkYGK1eutG9buHAhHh4eXHPNNQ63cWaPP/64feTnjx8vLy+eeuopvv76awDatWtHw4YNWbRokb3fwYMH2b59O71793a4jbO76aabzvlQP3r0KAEBAfa/anv37s3ixYvt5wbZbDYWL15c4jV0pI0zCwoK4ujRoyW2/bEWW1BQEFD8Gm7cuLHE+jILFy6kVatW9iDpSBspqXfv3nz//ff296ZhGCxatOic9295tCmTyzqFWhySkZFhNG/e3OjTp4+xcOFC47nnnjPc3NxKXO4qF7dmzRrDy8vLGDZsmLF69Wr7z5o1a0q0u+eee4wmTZoYs2bNMj799FPD39/fePnll0vdRv50vsvgP//8c8Pd3d2YNGmS8c033xidOnUyevbsWeKKJkfaOLOTJ08aISEhxsMPP2wsW7bM+PDDDw1fX98SV8nt3bvX8PPzM+677z5j0aJFRkxMjFGnTh3j8OHDpWrjzH7//XfDzc3NGDFihLFkyRJjxowZRmhoqNG/f397m8LCQiM6Otro2rWrsWDBAuPNN980XF1djfnz55eqjTPJzMy0fw77+PgYTz31lLF69Wpj165d9jaHDh0y6tSpYwwfPtxYtGiRce+99xp+fn4l1roqrzZlobvBV5KTJ0/y9ttvs337doKDgxk1ahQ9evQwu6xq44svvuA///nPOdvd3NxKjOYUFhYydepUli1bhpubG4MHD+a+++4rcS6EI23kT3369OHhhx9m0KBBJbYvWrSIzz//nIyMDLp168YzzzyDr69vqds4s6SkJN5991127txJgwYNuOOOO7j99ttLtNm5cyfvvfcehw4dokWLFjzzzDO0bt261G2c2fbt2/n44485cOAAfn5+XHvttTz00EMlzt05e/Ys77zzDps2baJOnTqMGDGCm266qcR+HGnjLPbs2cODDz54zvZevXrx+uuv23/fu3cvEydO5MCBAzRr1oyxY8fStm3bEn3Kq01pKQCJiIiI09E5QCIiIuJ0FIBERETE6SgAiYiIiNNRABIRERGnowAkIiIiTkcBSERERJyOApCIiIg4HQUgEak0e/bsYdmyZWaXgdVqZfXq1cybN4+9e/eaXY6ImMDN7AJEpGbZvn07hw8fJjg4mMjISDw9Pe2PLV68mJkzZ5q6eq5hGNx4440kJyfTsWNHfH19tWqyiBNSABKRcpGSksLtt9/OoUOHuPLKKzlz5gzHjx/npZde4oEHHgCgTZs23HzzzabWuXfvXlauXMnx48cJCQkxtRYRMY8CkIiUi2effZbc3FwOHz6Ml5cXAKmpqSxfvtzeplWrVvY7nQPMnTv3nP24uLgwbNgw++/79+8nISGB4OBgoqOjS4woXciWLVtITEwkNDSUK6+80r5979699udcvnw57u7uDBgwgFq1apXon5iYyPr16wGoXbs27dq1o0WLFiXaJCQkkJycTM+ePVm3bh2pqakMHTqUX3/9laCgIBo2bMjGjRvx9vbmuuuuY9OmTRw4cACAwMBAIiMj7XcjB9i2bRsnT56kT58+JZ5n69atnDp1Snd3FylnCkAiUi4SEhLo1q2bPfxA8Rf9nXfeaf/971Ng3333XYl9xMbGkpiYyLBhwygqKmLEiBH8+OOPXHXVVRw9epTs7GwWLlx4wZsg5uTkcPvtt7Nt2zauuOIKYmNjadOmDYsXL8bX15cDBw6wevVqey0uLi707dv3nACUlJRkry0zM5PVq1dz7733MmXKFHub+fPn8+WXX1K7dm2CgoJo0KABQ4cO5bXXXqOoqIhjx47Rvn17unXrxnXXXUdcXBy//vorUHxz5C1btvDxxx9z9913A8UjaLfddhvHjh0jMDDQ/jz3338/ffr0UQASKW+XdS95EZH/GTVqlBEQEGDMmDHDSE5OPm+biRMnGpGRked9bPv27YaPj4/x7rvvGoZhGG+99ZbRqVMnIyMjw97mySefNHr06HHBGl599VWjSZMm9uc/deqUERYWZowbN87eZvXq1QZg5ObmOnxsiYmJhr+/v7Fy5Ur7tldeecUAjMWLF5doe+211xoBAQFGUlLSRfe5cOFCw8/Pz358NpvNaN68ufHBBx/Y28TFxRmAsXv3bodrFRHH6CowESkXb7/9Nvfccw9PP/00wcHBNG/enMcee4yTJ09esm9aWhr9+/enf//+PPPMMwDMmDGDyMhIli1bxtdff828efOoV68e69evJy8v77z7mTt3LiNGjKB+/fpA8QjUww8/fN6ptkvJy8tj7dq1zJ8/n3Xr1tGwYUN+//33Em2aNWvGrbfeek7fgQMH0rhx43O2p6am8uuvvzJv3jyysrLIyspi9+7dAFgsFh544AFmzJhhbz99+nR69OhBeHh4qesXkYvTFJiIlAsfHx8mT57MBx98wPbt2/ntt9+YNGkSP/zwA9u3b8fHx+e8/YqKihg2bBh169blv//9r3374cOHCQwMZP78+SXaDx06lJycnHOmraD43J3mzZuX2NaiRQuOHDmCYRhYLBaHjmXt2rUMGjSIwMBAWrRogbe3N2fOnCElJaVEuwudRH2+7VOmTGHcuHF07NiRkJAQ+7lQf93n/fffzyuvvMLmzZuJiIhg9uzZTJw40aGaRaR0FIBEpFy5urrSqVMnOnXqxFVXXUXXrl1Zt27dOSf3/mHMmDHs2LGDzZs3lwg1fn5+DBgwgGeffdbh5w4MDCQtLa3EtrS0NOrVq+dw+AF45plnuPvuu3nvvffs26644goMwyjR7kL7/Pv2nJwcnnrqKb799ltuu+02ALKysvjqq69K7LNhw4b069ePzz77jGuvvZaCgoISJ4SLSPnRFJiIlItDhw6ds+2PqaqAgIDz9pkxYwaffPIJ3377LY0aNSrx2M0338xnn31GQUFBie3Hjh27YA09e/ZkwYIFJbbNnz+fnj17OnIIdidPniwx7bRv3z62bdtWqn38VWpqKlartcQ+/z6y9YcRI0YwZ84cPv74Y4YNG3bBkTMRuTwaARKRcvHcc8+RkpLCDTfcQJMmTUhMTOTjjz/m5ptvpnPnzue0P3HiBI888gj9+vXj8OHDHD58GPjzMvh33nmHq6++mquuuop7770XNzc31qxZQ25uLgsXLjxvDa+//jpXXnklgwcP5uabb+bnn39m48aNbNy4sVTHMmDAAMaPH09+fj6FhYV88MEHeHt7l/o1+UNoaCjR0dHce++9jBgxgv379zN9+nRcXM79G/SWW27B29ubVatW8eabb5b5OUXk4hSARKRczJs3j7Vr1/LTTz+xYsUKAgMD+eijj7j99ttxdXUFSi6EaBgGAwYMAEpeDu/q6sqwYcNo1KgR8fHxfPHFF2zZsgVfX18GDx7M4MGDL1hDixYt2Lp1K59++imrV6+mVatWvPPOOzRr1szeJigoiDvuuMNe0/m8++67hIeHs3HjRmrXrs2XX37Jhg0bCA0Ntbfp0KHDeftef/31tGnTpsQ2i8XCzz//zNSpU1m1ahWNGjVi3bp1vPbaa+eMfLm6unLrrbeyatUqevToccEaReTyWIy/T2qLiIhpbDYbLVq0YNSoUYwdO9bsckRqLI0AiYhUEd999x0//PADOTk5PPTQQ2aXI1Kj6SRoEZEqYunSpbi6uvLTTz/h5+dndjkiNZqmwERERMTpaARIREREnI4CkIiIiDgdBSARERFxOgpAIiIi4nQUgERERMTpKACJiIiI01EAEhEREaejACQiIiJORwFIREREnM7/B4YzQ+zKTxFXAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -651,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -690,20 +698,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[10, 100, 1000, 10000]\n", - "[[np.float64(0.0008447170257568359), np.float64(0.0008098840713500977)], [np.float64(0.0008617401123046875), np.float64(0.0008214950561523437)], [np.float64(0.002380967140197754), np.float64(0.0024411678314208984)], [np.float64(0.007615566253662109), np.float64(0.006029939651489258)]]\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -716,8 +716,6 @@ "import matplotlib.pyplot as plt\n", "\n", "plt.plot(sizeofarray, timings)\n", - "print(sizeofarray)\n", - "print(timings)\n", "plt.xlabel(\"Size of dictionary\")\n", "plt.ylabel(\"Time(s)\")\n", "plt.legend([\"Python\", \"Rust\"])\n", @@ -734,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -755,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -779,7 +777,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -814,12 +812,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -848,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -884,7 +882,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -898,7 +896,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -918,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1016,7 +1014,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1054,13 +1052,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "91bd3ce8dd744f93aff71e9e64e7f5ef", + "model_id": "4affad18c9c449bb8824593dd2e7458b", "version_major": 2, "version_minor": 0 }, @@ -1074,7 +1072,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c25ed7377bcd4581adbb1dae89f379a6", + "model_id": "2323b765e2ac40ed990f9242565f4a99", "version_major": 2, "version_minor": 0 }, @@ -1088,7 +1086,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c6a7d77d6c4843879bc92f8e88620c43", + "model_id": "741c1a5290b24cd0bb49543d15bb65d1", "version_major": 2, "version_minor": 0 }, @@ -1102,7 +1100,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "df454582b2b24afc86d6116800808257", + "model_id": "fe07bc47ec8340968c186aea4dadfcc4", "version_major": 2, "version_minor": 0 }, @@ -1116,7 +1114,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cdf7681087a14f208e54ed47c96b2ff3", + "model_id": "82aadc231baa4e4fa95eaf49bf1405ac", "version_major": 2, "version_minor": 0 }, @@ -1130,7 +1128,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3f8b1c51b42f4c5f858b82de339382a3", + "model_id": "eb4cb11a38eb4fffa1a34d1bf0199401", "version_major": 2, "version_minor": 0 }, @@ -1144,7 +1142,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9341a9539fea479789791a8834d9e0fe", + "model_id": "58ed3cef012c44bb980b690b76734191", "version_major": 2, "version_minor": 0 }, @@ -1158,7 +1156,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b32c2fefc3fe413692f877048b49f8d3", + "model_id": "a858239c22914fe7928ac9f58ffa9320", "version_major": 2, "version_minor": 0 }, @@ -1172,7 +1170,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e9f4c245539043fd9d940112ed0f18e0", + "model_id": "ea8416fb51ae4b3d86e2b726ba42bd67", "version_major": 2, "version_minor": 0 }, @@ -1186,7 +1184,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2680fa5e1d5940e6bf45c2f76874e094", + "model_id": "1016275f03ac4f889e09dd8e90cffe28", "version_major": 2, "version_minor": 0 }, @@ -1200,7 +1198,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0055f8f93d5745bb84c5f69e72a3d843", + "model_id": "e4d6b286bdd24b2ebe91714766713ae1", "version_major": 2, "version_minor": 0 }, @@ -1214,7 +1212,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "28a526d221a24008bce9a59230abbbd0", + "model_id": "eb970949aafb4ab3a09021a327ee24a6", "version_major": 2, "version_minor": 0 }, @@ -1228,7 +1226,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ac6a5fd275884dc19b7e49b265771596", + "model_id": "42d32b2b072d453d93f2c0fdc9b00c06", "version_major": 2, "version_minor": 0 }, @@ -1242,7 +1240,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "00505849fa82430ca3e9a366d15466ce", + "model_id": "1db9cc8dfaf64f1a9ff13823e881f78d", "version_major": 2, "version_minor": 0 }, @@ -1256,7 +1254,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a56eac4174814b15ba447a6c1149b47b", + "model_id": "6aa04ac12f7e4eb4a4fe0a5d4d03b3a9", "version_major": 2, "version_minor": 0 }, @@ -1270,7 +1268,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e53329fd254a431b9e8e7f26a7a55114", + "model_id": "726925c5f5814d26af9da3837fdd5ced", "version_major": 2, "version_minor": 0 }, @@ -1284,7 +1282,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "53462eb4c77949358b0a048bf363f904", + "model_id": "a1848430c21e4233bf4d9b7787bdf7be", "version_major": 2, "version_minor": 0 }, @@ -1298,7 +1296,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5111eb1ed74f4a84be3de8c81b6d1310", + "model_id": "6b4d22e9278044e187a8d03bf3431e45", "version_major": 2, "version_minor": 0 }, @@ -1312,7 +1310,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7b352e98d952406fac9954fe2a3f2f6e", + "model_id": "648b76acf2764bf1a2204b6494b5001c", "version_major": 2, "version_minor": 0 }, @@ -1326,7 +1324,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6353e083c1da448a9a9600367ee69a78", + "model_id": "ec610afb83574fc9b0b5536fef16faee", "version_major": 2, "version_minor": 0 }, @@ -1340,7 +1338,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "65d81377d54344b0bba7169586c8d22d", + "model_id": "88f6f52998f34936a8967181338d90b2", "version_major": 2, "version_minor": 0 }, @@ -1354,7 +1352,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "beea9d305e314447ac7e0774f9761224", + "model_id": "e3310cddd9f44790b1f5883f6cfc29e1", "version_major": 2, "version_minor": 0 }, @@ -1368,7 +1366,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "911302eac0b1468da5c25b22e97564dd", + "model_id": "1c7cd46cac94485296c4e3317b98d99f", "version_major": 2, "version_minor": 0 }, @@ -1382,7 +1380,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ad0d81fe90f94298a341a360418785ed", + "model_id": "6883e012b7c546648c12cb208471c26b", "version_major": 2, "version_minor": 0 }, @@ -1396,7 +1394,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eeb51fb3d4614688b575d371a888f569", + "model_id": "7e9ea39470934ebab491ea716a07d941", "version_major": 2, "version_minor": 0 }, @@ -1410,7 +1408,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c2f312a760ee42e9a6cd04f09ce62bf9", + "model_id": "ac76b5d33bbc45a594cfd4e3e1dc25ca", "version_major": 2, "version_minor": 0 }, @@ -1424,7 +1422,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2102253f044b420fad59fdf6fb355b7d", + "model_id": "aff4a46a58214963b16d24eda0701819", "version_major": 2, "version_minor": 0 }, @@ -1438,7 +1436,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8127cbfd1d174a1ebf74445bc705bbfb", + "model_id": "863fdfc236c14174ac0a8d23a3244e27", "version_major": 2, "version_minor": 0 }, @@ -1452,7 +1450,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "030ed57f77854d76a61e652a142f5346", + "model_id": "1ee6fbb579524d6f80b371c5cc24f4ed", "version_major": 2, "version_minor": 0 }, @@ -1466,7 +1464,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "42d51766d0184b37bafbf5dc2d17e854", + "model_id": "906a3bbe26fc4e2887ef267012632502", "version_major": 2, "version_minor": 0 }, @@ -1566,19 +1564,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 25, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[np.float64(0.03665416240692139), np.float64(0.03360826969146728)], [np.float64(0.3465502977371216), np.float64(0.30228404998779296)], [np.float64(3.503210759162903), np.float64(2.9717938184738157)]]\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1590,7 +1581,6 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "print(timings)\n", "plt.plot(sizeofarray, timings)\n", "plt.xlabel(\"Size of array\")\n", "plt.ylabel(\"Time(s)\")\n", diff --git a/tests/test_utils.py b/tests/test_utils.py index f27115de5..230d1fa0b 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -916,6 +916,30 @@ def test_contrast_enhancer() -> None: # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) + input_array = np.array( + [ + [37, 244, 193, 106, 235, 128, 71, 140, 47], + [103, 184, 72, 20, 188, 238, 126, 7, 0], + [137, 195, 204, 32, 203, 170, 101, 77, 133], + ], + dtype=np.uint8, + ) + + # expected output of the contrast_enhancer + result_array = np.array( + [ + [35, 255, 203, 110, 248, 133, 72, 146, 46], + [106, 193, 73, 17, 198, 251, 131, 3, 0], + [143, 205, 215, 30, 214, 178, 104, 78, 139], + ], + dtype=np.uint8, + ) + + # Calculating the contrast enhanced version of input_array + output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) + # The out_put array should be equal to expected result_array + assert np.all(result_array == output_array) + def test_load_stain_matrix(track_tmp_path: Path) -> None: """Test to load stain matrix.""" From 60bf98e212b5b722b705b26e38952b84578c0f83 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 17:49:54 +0100 Subject: [PATCH 023/112] Updated test_utils to include a new test for contrast enhancer --- tests/test_utils.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test_utils.py b/tests/test_utils.py index 230d1fa0b..6e2adea07 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -915,6 +915,10 @@ def test_contrast_enhancer() -> None: output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) + # Calculating the contrast enhanced version of input_array + output_array = utils.misc.contrast_enhancer(input_array, low_p=98, high_p=2) + # The out_put array should be equal to expected result_array + assert np.all(result_array == output_array) input_array = np.array( [ From 8d4529ce65d18e9d99d794c4464affe4a843a3a8 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 18:17:39 +0100 Subject: [PATCH 024/112] Updated test_utils to include a new test for contrast enhancer --- tests/test_utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_utils.py b/tests/test_utils.py index 6e2adea07..d523aeaa9 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -916,6 +916,8 @@ def test_contrast_enhancer() -> None: # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) # Calculating the contrast enhanced version of input_array + input_array = np.array([0, 255]) + result_array = np.array([0, 255]) output_array = utils.misc.contrast_enhancer(input_array, low_p=98, high_p=2) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) From f058b4d336435ca564de661253b0d48dcb851fb2 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 18:38:11 +0100 Subject: [PATCH 025/112] Updated test_utils to include a new test for contrast enhancer --- tests/test_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_utils.py b/tests/test_utils.py index d523aeaa9..89e62392f 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -916,8 +916,8 @@ def test_contrast_enhancer() -> None: # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) # Calculating the contrast enhanced version of input_array - input_array = np.array([0, 255]) - result_array = np.array([0, 255]) + input_array = np.array([0, 255], dtype=np.uint8) + result_array = np.array([0, 255], dtype=np.uint8) output_array = utils.misc.contrast_enhancer(input_array, low_p=98, high_p=2) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) From 16909514f74698d95819c6d5d12e09105ae02f50 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 22:08:38 +0100 Subject: [PATCH 026/112] Updated test_utils to include a new test for contrast enhancer --- .github/workflows/rust.yml | 0 tests/test_utils.py | 5 +++++ tiatoolbox/rust-library/tests/test_misc.rs | 8 ++++++++ 3 files changed, 13 insertions(+) create mode 100644 .github/workflows/rust.yml create mode 100644 tiatoolbox/rust-library/tests/test_misc.rs diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml new file mode 100644 index 000000000..e69de29bb diff --git a/tests/test_utils.py b/tests/test_utils.py index 89e62392f..efa71b4ed 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -921,6 +921,11 @@ def test_contrast_enhancer() -> None: output_array = utils.misc.contrast_enhancer(input_array, low_p=98, high_p=2) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) + input_array = np.array([0, 0], dtype=np.uint8) + result_array = np.array([0, 0], dtype=np.uint8) + output_array = utils.misc.contrast_enhancer(input_array, low_p=98, high_p=2) + # The out_put array should be equal to expected result_array + assert np.all(result_array == output_array) input_array = np.array( [ diff --git a/tiatoolbox/rust-library/tests/test_misc.rs b/tiatoolbox/rust-library/tests/test_misc.rs new file mode 100644 index 000000000..a56827e79 --- /dev/null +++ b/tiatoolbox/rust-library/tests/test_misc.rs @@ -0,0 +1,8 @@ +use rmisc::add; + +#[test] +fn test_add() { + let result = add(2, 3); + + assert_eq!(result, 5); +} From 075657783be892d6b659693f2214e07b0d85be35 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 24 Aug 2026 22:13:41 +0100 Subject: [PATCH 027/112] Removed github workflows --- .github/workflows/rust.yml | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .github/workflows/rust.yml diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml deleted file mode 100644 index e69de29bb..000000000 From ea28f76a426c5c6595751caf49af32183bcc9ed6 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 10:28:20 +0100 Subject: [PATCH 028/112] Added in workflow for test --- .github/workflows/rust.yml | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 .github/workflows/rust.yml diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml new file mode 100644 index 000000000..8f9b05f33 --- /dev/null +++ b/.github/workflows/rust.yml @@ -0,0 +1,36 @@ +name: Rust + +on: + push: + branches: + - develop + - main + - master + + pull_request: + branches: + - develop + - main + - master + +jobs: + rust: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + with: + components: rustfmt, clippy + + - name: Check formatting + run: cargo fmt --all -- --check + + - name: Run Clippy + run: cargo clippy --all-targets --all-features -- -D warnings + + - name: Run Rust tests + run: cargo test --all From 615caf8bb483bd9e2c6d9add89d272bb579366ab Mon Sep 17 00:00:00 2001 From: hannah275 Date: Tue, 25 Aug 2026 10:40:09 +0100 Subject: [PATCH 029/112] Updated rust-library/lib.rs to have proper formatting --- tiatoolbox/rust-library/lib.rs | 144 ++++++++++++++++++--------------- 1 file changed, 81 insertions(+), 63 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index e9703516e..f7075b6fd 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -1,16 +1,16 @@ -use pyo3::prelude::*; -use ndarray::{Array1, Array3}; -use numpy::{IntoPyArray, PyArray3, PyReadonlyArray2, PyReadonlyArray3}; -use numpy::PyUntypedArrayMethods; use ndarray::Axis; +use ndarray::{Array1, Array3}; use numpy::PyReadonlyArrayDyn; -use pyo3::types::{PyList, PyDict}; -use std::collections::HashMap; -use pythonize::depythonize; -use serde_json::Value; +use numpy::PyUntypedArrayMethods; +use numpy::{IntoPyArray, PyArray3, PyReadonlyArray2, PyReadonlyArray3}; use ordered_float::OrderedFloat; use pyo3::FromPyObject; +use pyo3::prelude::*; use pyo3::pyclass::CompareOp; +use pyo3::types::{PyDict, PyList}; +use pythonize::depythonize; +use serde_json::Value; +use std::collections::HashMap; #[derive(FromPyObject)] enum StringOrFloat { @@ -38,14 +38,15 @@ fn string_to_tuple(in_str: String) -> Vec { } #[pyfunction] -fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, +fn semantic_segmentations_as_qupath_json<'py>( + py: Python<'_>, layer_list: &Bound<'_, PyList>, preds: &Bound<'_, PyAny>, scale_factor: (f64, f64), class_dict: &Bound<'_, PyDict>, class_colours: &Bound<'_, PyDict>, cv2: &Bound<'_, PyAny>, - poly_geo_fun: &Bound<'_, PyAny> + poly_geo_fun: &Bound<'_, PyAny>, ) -> PyResult> { /*Helper function to save semantic segmentation as QuPath json.*/ let class_colours: HashMap, Vec> = class_colours @@ -62,11 +63,12 @@ fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, let chain_approx_none = cv2.getattr("CHAIN_APPROX_NONE")?; let find_contours = cv2.getattr("findContours")?; for type_class in layer_list.iter() { - let class_id: i64 = type_class.extract()?; let class_label = class_dict.get_item(class_id)?; + let class_id: i64 = type_class.extract()?; + let class_label = class_dict.get_item(class_id)?; let layer = preds - .rich_compare(class_id, CompareOp::Eq)? - .call_method1("astype", ("uint8",))? - .call_method0("compute")?; + .rich_compare(class_id, CompareOp::Eq)? + .call_method1("astype", ("uint8",))? + .call_method0("compute")?; let result = find_contours.call1((layer, retr_ccomp.clone(), chain_approx_none.clone()))?; let result = result.cast::()?; @@ -79,14 +81,10 @@ fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, //let array = py_array.to_owned(); if py_array.shape()[0] >= 3 { let cnt_array: PyReadonlyArrayDyn<'_, i32> = cnt.extract()?; - let cnt_scaled = cnt_array.as_array() - .index_axis_move(Axis(1), 0); + let cnt_scaled = cnt_array.as_array().index_axis_move(Axis(1), 0); let exterior: Vec<(f64, f64)> = cnt_scaled .outer_iter() - .map(|p| ( - p[0] as f64 * scale_factor.0, - p[1] as f64 * scale_factor.1, - )) + .map(|p| (p[0] as f64 * scale_factor.0, p[1] as f64 * scale_factor.1)) .collect(); let coordinates = vec![exterior]; let poly_geo = poly_geo_fun.call1((coordinates,))?; @@ -96,7 +94,10 @@ fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, feature.set_item("id", format!("class_{}_{}", class_id, features.len()))?; let classification = PyDict::new(py); classification.set_item("name", &class_label)?; - classification.set_item("color", class_colours[&OrderedFloat(class_id as f64)].clone())?; + classification.set_item( + "color", + class_colours[&OrderedFloat(class_id as f64)].clone(), + )?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; @@ -106,7 +107,6 @@ fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, features.append(feature)?; } } - } Ok(features.unbind()) } @@ -115,8 +115,8 @@ fn semantic_segmentations_as_qupath_json<'py>(py: Python<'_>, fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResult<()> { //Equilivent to json.dump(obj, save_path) //Caution: if obj is a dictionary and has a key of an integer it will throw an error - let value: Value = depythonize(obj) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + let value: Value = + depythonize(obj).map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; let file = std::fs::File::create(&save_path) .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))?; @@ -134,18 +134,18 @@ fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResul #[pyfunction] fn patch_predictions_as_annotations<'py>( - py: Python<'_>, - annotation_class: &Bound<'_, PyAny>, - polygon_class: &Bound<'_, PyAny>, - preds: Vec, - keys_contains_labels: bool, - keys_contains_probabilities: bool, - class_dict: &Bound<'_, PyDict>, - py_class_probs: PyReadonlyArray2<'py, f64>, - py_patch_coords: PyReadonlyArray2<'py, f64>, - classes_predicted: Vec, - labels: Vec - ) -> PyResult>>{ + py: Python<'_>, + annotation_class: &Bound<'_, PyAny>, + polygon_class: &Bound<'_, PyAny>, + preds: Vec, + keys_contains_labels: bool, + keys_contains_probabilities: bool, + class_dict: &Bound<'_, PyDict>, + py_class_probs: PyReadonlyArray2<'py, f64>, + py_patch_coords: PyReadonlyArray2<'py, f64>, + classes_predicted: Vec, + labels: Vec, +) -> PyResult>> { /*Helper function to generate annotation per patch predictions.*/ let class_dict: HashMap, StringOrFloat> = class_dict .iter() @@ -157,7 +157,7 @@ fn patch_predictions_as_annotations<'py>( .collect::>()?; let class_probs = py_class_probs.as_array(); let patch_coords = py_patch_coords.as_array(); - let mut annotations: Vec> = Vec::with_capacity(patch_coords.nrows()); + let mut annotations: Vec> = Vec::with_capacity(patch_coords.nrows()); let preds_len = preds.len(); for i in 0..patch_coords.nrows() { let props = PyDict::new(py); @@ -168,7 +168,10 @@ fn patch_predictions_as_annotations<'py>( StringOrFloat::String(s) => s.clone(), StringOrFloat::Float(i) => i.to_string(), }; - props.set_item(format!("prob_{}", probability), class_probs[[i, *j as usize]])?; + props.set_item( + format!("prob_{}", probability), + class_probs[[i, *j as usize]], + )?; } } if keys_contains_labels { @@ -193,25 +196,34 @@ fn patch_predictions_as_annotations<'py>( } } } - annotations.push(annotation_class.call1(( - polygon_class.call_method1("from_bounds", ( - patch_coords[[i, 0]], - patch_coords[[i, 1]], - patch_coords[[i, 2]], - patch_coords[[i, 3]] - ))?, - props))?.unbind()); + annotations.push( + annotation_class + .call1(( + polygon_class.call_method1( + "from_bounds", + ( + patch_coords[[i, 0]], + patch_coords[[i, 1]], + patch_coords[[i, 2]], + patch_coords[[i, 3]], + ), + )?, + props, + ))? + .unbind(), + ); } Ok(annotations) } #[pyfunction] -fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, - class_colours: &Bound<'_, PyDict>, - preds: Vec, - class_dict: &Bound<'_, PyDict>, - py_patch_coords: PyReadonlyArray2<'py, f64>) - -> PyResult> { +fn patch_predictions_as_qupath_json<'py>( + py: Python<'_>, + class_colours: &Bound<'_, PyDict>, + preds: Vec, + class_dict: &Bound<'_, PyDict>, + py_patch_coords: PyReadonlyArray2<'py, f64>, +) -> PyResult> { /*Helper function to generate QuPath JSON per patch predictions.*/ let class_colours: HashMap, Vec> = class_colours .iter() @@ -271,15 +283,14 @@ fn patch_predictions_as_qupath_json<'py>(py: Python<'_>, Ok(features.unbind()) } - -fn rescale_intensity(x: f32, in_range_low: f32, in_range_high: f32, range: f32) -> u8{ +fn rescale_intensity(x: f32, in_range_low: f32, in_range_high: f32, range: f32) -> u8 { //asssumes out_min = 0 and out_max = 255 if x <= in_range_low { 0 } else if x >= in_range_high { 255 } else { - (255.0 * ((x-in_range_low)/range)) as u8 + (255.0 * ((x - in_range_low) / range)) as u8 } } @@ -299,7 +310,7 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 */ let img_out = img.to_owned(); let len = img.len(); - let mut flat_img_out: Array1 = img_out.into_shape_with_order(len, ).unwrap(); + let mut flat_img_out: Array1 = img_out.into_shape_with_order(len).unwrap(); if let Some(slice) = flat_img_out.as_slice_mut() { slice.sort_unstable(); @@ -309,13 +320,15 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 let p_low_index: f32 = (lenf32 - 1.0) * low_p as f32 / 100.0; let p_low_index_difference = p_low_index - p_low_index.floor(); - let mut p_low = (1.0 - p_low_index_difference) * flat_img_out[p_low_index.floor() as usize] as f32 - + p_low_index_difference * flat_img_out[p_low_index.ceil() as usize] as f32; + let mut p_low = (1.0 - p_low_index_difference) + * flat_img_out[p_low_index.floor() as usize] as f32 + + p_low_index_difference * flat_img_out[p_low_index.ceil() as usize] as f32; let p_high_index: f32 = (lenf32 - 1.0) * high_p as f32 / 100.0; let p_high_index_difference = p_high_index - p_high_index.floor(); - let mut p_high = (1.0 - p_high_index_difference) * flat_img_out[p_high_index.floor() as usize] as f32 - + p_high_index_difference * flat_img_out[p_high_index.ceil() as usize] as f32; + let mut p_high = (1.0 - p_high_index_difference) + * flat_img_out[p_high_index.floor() as usize] as f32 + + p_high_index_difference * flat_img_out[p_high_index.ceil() as usize] as f32; if p_low >= p_high { p_low = flat_img_out[0].into(); @@ -323,15 +336,20 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 } if p_high > p_low { - let range = p_high - p_low ; + let range = p_high - p_low; return img.mapv(|x| rescale_intensity(x.into(), p_low, p_high, range)); } - return img + return img; } #[pyfunction] -fn contrast_enhancer<'py>(py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p: u8, high_p: u8) -> Bound<'py, PyArray3> { +fn contrast_enhancer<'py>( + py: Python<'py>, + img: PyReadonlyArray3<'py, u8>, + low_p: u8, + high_p: u8, +) -> Bound<'py, PyArray3> { let data = img.as_array().to_owned(); rust_contrast_enhancer(data, low_p, high_p).into_pyarray(py) } From c60d41fe0fb8249709d6d45b1aaf914ed1cd459a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 10:51:24 +0100 Subject: [PATCH 030/112] Edited rust-library/lib.rs to have better formatting --- tiatoolbox/rust-library/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index f7075b6fd..5933d07f7 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -38,7 +38,7 @@ fn string_to_tuple(in_str: String) -> Vec { } #[pyfunction] -fn semantic_segmentations_as_qupath_json<'py>( +fn semantic_segmentations_as_qupath_json( py: Python<'_>, layer_list: &Bound<'_, PyList>, preds: &Bound<'_, PyAny>, @@ -163,7 +163,7 @@ fn patch_predictions_as_annotations<'py>( let props = PyDict::new(py); if keys_contains_probabilities { for j in &classes_predicted { - let y = &class_dict[&OrderedFloat(*j as f64)]; + let y = &class_dict[&OrderedFloat(*j)]; let probability = match y { StringOrFloat::String(s) => s.clone(), StringOrFloat::Float(i) => i.to_string(), @@ -340,7 +340,7 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 return img.mapv(|x| rescale_intensity(x.into(), p_low, p_high, range)); } - return img; + img } #[pyfunction] From 13cd226a71a8fac80e9f031e6ad73e4209e688c0 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 10:56:15 +0100 Subject: [PATCH 031/112] Edited to ignore too many arguments --- .github/workflows/rust.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 8f9b05f33..5d495e6c4 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -30,7 +30,7 @@ jobs: run: cargo fmt --all -- --check - name: Run Clippy - run: cargo clippy --all-targets --all-features -- -D warnings + run: cargo clippy --all-targets --all-features -- -D warnings -A clippy::too_many_arguments - name: Run Rust tests run: cargo test --all From 8ff5bba054846b4875e7ef3828280fb8a05339ea Mon Sep 17 00:00:00 2001 From: hannah275 Date: Tue, 25 Aug 2026 11:09:52 +0100 Subject: [PATCH 032/112] Moved location of test_misc.rs --- {tiatoolbox/rust-library/tests => tests}/test_misc.rs | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {tiatoolbox/rust-library/tests => tests}/test_misc.rs (100%) diff --git a/tiatoolbox/rust-library/tests/test_misc.rs b/tests/test_misc.rs similarity index 100% rename from tiatoolbox/rust-library/tests/test_misc.rs rename to tests/test_misc.rs From c3ee9a3fb2dc898d613314593d1f06032693e1c8 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 11:18:28 +0100 Subject: [PATCH 033/112] Corrected import error --- Cargo.toml | 2 +- tiatoolbox/rust-library/lib.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6e7fd940b..2bafb17ab 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ autolib = false [lib] path = "tiatoolbox/rust-library/lib.rs" name = "rmisc" -crate-type = ["cdylib"] +crate-type = ["cdylib", "rlib"] [dependencies] ndarray = "0.17.2" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 5933d07f7..19b7662ca 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -18,7 +18,7 @@ enum StringOrFloat { Float(f64), } #[pyfunction] -fn add(a: i32, b: i32) -> i32 { +pub fn add(a: i32, b: i32) -> i32 { a + b } From 94449e1afd51a1609f59f664ce0234c5c787e176 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 11:22:07 +0100 Subject: [PATCH 034/112] Added codecov to cover rust code too --- .github/workflows/rust.yml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 5d495e6c4..51ae47381 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -34,3 +34,17 @@ jobs: - name: Run Rust tests run: cargo test --all + + - name: Install cargo-llvm-cov + uses: taiki-e/install-action@cargo-llvm-cov + + - name: Run Rust tests with coverage + run: cargo llvm-cov --all-features --lcov --output-path rust-lcov.info + + - name: Upload Rust coverage to Codecov + uses: codecov/codecov-action@v5 + with: + files: rust-lcov.info + flags: rust + token: ${{ secrets.CODECOV_TOKEN }} + fail_ci_if_error: true From f7e09a4672d57d94592b6a2e0ba6fea1ff53882a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 11:41:36 +0100 Subject: [PATCH 035/112] Updated to include a codecov workflow so that it waits till both the python and rust tests have finished and then complie the report together --- .github/workflows/codecov.yml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 .github/workflows/codecov.yml diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml new file mode 100644 index 000000000..6e92b686c --- /dev/null +++ b/.github/workflows/codecov.yml @@ -0,0 +1,6 @@ +codecov: + notify: + after_n_builds: 2 + +comment: + after_n_builds: 2 From 11a8fb818cd3acb716f26e9d3f7e08ca5b09dc8b Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 12:14:23 +0100 Subject: [PATCH 036/112] Updated workflows --- .github/workflows/codecov.yml | 6 -- .github/workflows/python-package.yml | 105 +++++++++++++++------------ .github/workflows/rust.yml | 14 ---- 3 files changed, 59 insertions(+), 66 deletions(-) delete mode 100644 .github/workflows/codecov.yml diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml deleted file mode 100644 index 6e92b686c..000000000 --- a/.github/workflows/codecov.yml +++ /dev/null @@ -1,6 +0,0 @@ -codecov: - notify: - after_n_builds: 2 - -comment: - after_n_builds: 2 diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 8eb763862..561073881 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -24,10 +24,15 @@ jobs: steps: - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} + + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + - name: Install dependencies run: | sudo apt update @@ -36,12 +41,34 @@ jobs: python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu + + # Only collect Rust coverage once, using Python 3.12. + - name: Install cargo-llvm-cov + if: matrix.python-version == '3.12' + uses: taiki-e/install-action@cargo-llvm-cov + + - name: Set Rust coverage environment + if: matrix.python-version == '3.12' + run: | + cargo llvm-cov show-env --sh > llvm-cov-env.sh + + # This replaces "uv pip install --system -e ." from the dependency step. + # On Python 3.12 the Rust extension is built with coverage instrumentation. + - name: Install TIAToolbox + run: | + if [ "${{ matrix.python-version }}" = "3.12" ]; then + source llvm-cov-env.sh + cargo llvm-cov clean --workspace + fi + uv pip install --system -e . + - name: Cache tiatoolbox static assets uses: actions/cache@v4 with: key: tiatoolbox-home-static path: ~/.tiatoolbox + - name: Print Version Information run: | echo "---SQlite---" @@ -54,23 +81,48 @@ jobs: python -c "import sqlite3; print('SQLite %s' % sqlite3.sqlite_version)" python -c "import numpy; print('Numpy %s' % numpy.__version__)" python -c "import openslide; print('OpenSlide %s' % openslide.__version__)" + - name: Lint with ruff run: | - # stop the build if there are Python syntax errors or undefined names ruff check . + - name: Test with pytest run: | + if [ "${{ matrix.python-version }}" = "3.12" ]; then + source llvm-cov-env.sh + fi + pytest --basetemp={envtmpdir} \ --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ --capture=sys \ --durations=10 --durations-min=1.0 \ --maxfail=1 - - name: Report test coverage to Codecov - uses: codecov/codecov-action@v4 - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + + # Python tests have now exercised the instrumented Rust library. + - name: Generate Rust coverage report + if: matrix.python-version == '3.12' + run: | + source llvm-cov-env.sh + cargo llvm-cov report --lcov --output-path rust-lcov.info + + - name: Report Python test coverage to Codecov + uses: codecov/codecov-action@v5 with: files: coverage.xml + disable_search: true + flags: python + token: ${{ secrets.CODECOV_TOKEN }} + fail_ci_if_error: false + verbose: true + + - name: Report Rust coverage to Codecov + if: matrix.python-version == '3.12' + uses: codecov/codecov-action@v5 + with: + files: rust-lcov.info + disable_search: true + flags: rust + token: ${{ secrets.CODECOV_TOKEN }} fail_ci_if_error: false verbose: true @@ -81,8 +133,10 @@ jobs: coverage-file: coverage.xml dsn: ${{ secrets.DEEPSOURCE_DSN }} fail-ci-on-error: false + - name: List tiatoolbox contents run: ls -lahR ~/.tiatoolbox + - name: Delete Hugging Face cache for large models run: | find ~/.tiatoolbox/models -type f -size +250M -exec bash -c ' @@ -92,44 +146,3 @@ jobs: rm -vf "$cache_dir/${model_name}.lock" "$cache_dir/${model_name}.metadata" done ' bash {} + - - release: - runs-on: ubuntu-24.04 - timeout-minutes: 15 - needs: build - if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/pre-release' || startsWith(github.ref, 'refs/tags/v') - - steps: - - uses: actions/checkout@v4 - - - name: Set up Python 3.12 - uses: actions/setup-python@v4 - with: - python-version: '3.12' - cache: 'pip' - - - name: Install dependencies - run: | - sudo apt-get install -y libopenslide-dev libopenjp2-7 - python -m pip install --upgrade pip - pip install uv - uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu - uv pip install --system -e . - uv pip install --system build - - name: Build package - run: python -m build - - - name: Publish package to Test PyPI - uses: pypa/gh-action-pypi-publish@release/v1 - with: - user: __token__ - password: ${{ secrets.TEST_PYPI_API_TOKEN }} - repository_url: https://test.pypi.org/legacy/ - skip_existing: true # Ignore errors if the current version exists already - - - name: Publish package to PyPI - if: startsWith(github.ref, 'refs/tags/v') # Only run on tags starting with v - uses: pypa/gh-action-pypi-publish@release/v1 - with: - user: __token__ - password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 51ae47381..5d495e6c4 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -34,17 +34,3 @@ jobs: - name: Run Rust tests run: cargo test --all - - - name: Install cargo-llvm-cov - uses: taiki-e/install-action@cargo-llvm-cov - - - name: Run Rust tests with coverage - run: cargo llvm-cov --all-features --lcov --output-path rust-lcov.info - - - name: Upload Rust coverage to Codecov - uses: codecov/codecov-action@v5 - with: - files: rust-lcov.info - flags: rust - token: ${{ secrets.CODECOV_TOKEN }} - fail_ci_if_error: true From 6cf54698bc3c6eb055fdfa46474099d6bfb2c495 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 12:39:30 +0100 Subject: [PATCH 037/112] Updated workflows --- .github/workflows/python-package.yml | 120 ++++++++++++++------------- 1 file changed, 61 insertions(+), 59 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 561073881..56022ba55 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -23,16 +23,26 @@ jobs: python-version: ["3.12", "3.13", "3.14"] steps: - - uses: actions/checkout@v4 + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + with: + components: llvm-tools-preview + - name: Install cargo-llvm-cov + if: matrix.python-version == '3.12' + uses: taiki-e/install-action@cargo-llvm-cov + + - name: Set Rust coverage environment + if: matrix.python-version == '3.12' + run: | + cargo llvm-cov show-env --sh > llvm-cov-env.sh + source llvm-cov-env.sh + cargo llvm-cov clean --workspace + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - - - name: Install Rust - uses: dtolnay/rust-toolchain@stable - - name: Install dependencies run: | sudo apt update @@ -41,34 +51,12 @@ jobs: python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu - - # Only collect Rust coverage once, using Python 3.12. - - name: Install cargo-llvm-cov - if: matrix.python-version == '3.12' - uses: taiki-e/install-action@cargo-llvm-cov - - - name: Set Rust coverage environment - if: matrix.python-version == '3.12' - run: | - cargo llvm-cov show-env --sh > llvm-cov-env.sh - - # This replaces "uv pip install --system -e ." from the dependency step. - # On Python 3.12 the Rust extension is built with coverage instrumentation. - - name: Install TIAToolbox - run: | - if [ "${{ matrix.python-version }}" = "3.12" ]; then - source llvm-cov-env.sh - cargo llvm-cov clean --workspace - fi - uv pip install --system -e . - - name: Cache tiatoolbox static assets uses: actions/cache@v4 with: key: tiatoolbox-home-static path: ~/.tiatoolbox - - name: Print Version Information run: | echo "---SQlite---" @@ -81,48 +69,23 @@ jobs: python -c "import sqlite3; print('SQLite %s' % sqlite3.sqlite_version)" python -c "import numpy; print('Numpy %s' % numpy.__version__)" python -c "import openslide; print('OpenSlide %s' % openslide.__version__)" - - name: Lint with ruff run: | + # stop the build if there are Python syntax errors or undefined names ruff check . - - name: Test with pytest run: | - if [ "${{ matrix.python-version }}" = "3.12" ]; then - source llvm-cov-env.sh - fi - pytest --basetemp={envtmpdir} \ --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ --capture=sys \ --durations=10 --durations-min=1.0 \ --maxfail=1 - - # Python tests have now exercised the instrumented Rust library. - - name: Generate Rust coverage report - if: matrix.python-version == '3.12' - run: | - source llvm-cov-env.sh - cargo llvm-cov report --lcov --output-path rust-lcov.info - - - name: Report Python test coverage to Codecov - uses: codecov/codecov-action@v5 + - name: Report test coverage to Codecov + uses: codecov/codecov-action@v4 + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} with: files: coverage.xml - disable_search: true - flags: python - token: ${{ secrets.CODECOV_TOKEN }} - fail_ci_if_error: false - verbose: true - - - name: Report Rust coverage to Codecov - if: matrix.python-version == '3.12' - uses: codecov/codecov-action@v5 - with: - files: rust-lcov.info - disable_search: true - flags: rust - token: ${{ secrets.CODECOV_TOKEN }} fail_ci_if_error: false verbose: true @@ -133,10 +96,8 @@ jobs: coverage-file: coverage.xml dsn: ${{ secrets.DEEPSOURCE_DSN }} fail-ci-on-error: false - - name: List tiatoolbox contents run: ls -lahR ~/.tiatoolbox - - name: Delete Hugging Face cache for large models run: | find ~/.tiatoolbox/models -type f -size +250M -exec bash -c ' @@ -146,3 +107,44 @@ jobs: rm -vf "$cache_dir/${model_name}.lock" "$cache_dir/${model_name}.metadata" done ' bash {} + + + release: + runs-on: ubuntu-24.04 + timeout-minutes: 15 + needs: build + if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/pre-release' || startsWith(github.ref, 'refs/tags/v') + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python 3.12 + uses: actions/setup-python@v4 + with: + python-version: '3.12' + cache: 'pip' + + - name: Install dependencies + run: | + sudo apt-get install -y libopenslide-dev libopenjp2-7 + python -m pip install --upgrade pip + pip install uv + uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu + uv pip install --system -e . + uv pip install --system build + - name: Build package + run: python -m build + + - name: Publish package to Test PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.TEST_PYPI_API_TOKEN }} + repository_url: https://test.pypi.org/legacy/ + skip_existing: true # Ignore errors if the current version exists already + + - name: Publish package to PyPI + if: startsWith(github.ref, 'refs/tags/v') # Only run on tags starting with v + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} From 7d1d62727ba51643b8f840f229449c19c26c4a48 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:02:31 +0100 Subject: [PATCH 038/112] Updated workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 56022ba55..e87021a25 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -35,7 +35,7 @@ jobs: - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | - cargo llvm-cov show-env --sh > llvm-cov-env.sh + cargo llvm-cov --manifest-path ../Cargo.toml show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - uses: actions/checkout@v4 From d2513a3f28af138ecfa46fab4d1d1cee5b9ea17b Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:07:45 +0100 Subject: [PATCH 039/112] Updated workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index e87021a25..c757d1816 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -35,7 +35,7 @@ jobs: - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | - cargo llvm-cov --manifest-path ../Cargo.toml show-env --sh > llvm-cov-env.sh + cargo llvm-cov --manifest-path tiatoolbox/Cargo.toml show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - uses: actions/checkout@v4 From 7484198f233ed904ad56218eb770e297d1c79a00 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:10:44 +0100 Subject: [PATCH 040/112] Updated workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index c757d1816..f9ad240ed 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -35,7 +35,7 @@ jobs: - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | - cargo llvm-cov --manifest-path tiatoolbox/Cargo.toml show-env --sh > llvm-cov-env.sh + cargo llvm-cov --manifest-path Cargo.toml show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - uses: actions/checkout@v4 From e0a0a8c4f261fdd0fc75062a6360d785b2357569 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:14:38 +0100 Subject: [PATCH 041/112] Updated workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index f9ad240ed..b76d07423 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -35,7 +35,7 @@ jobs: - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | - cargo llvm-cov --manifest-path Cargo.toml show-env --sh > llvm-cov-env.sh + cargo llvm-cov --manifest-path ./Cargo.toml show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - uses: actions/checkout@v4 From 5212cab9b3aa1f714b7c92a5ba007895546b7d4a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:28:58 +0100 Subject: [PATCH 042/112] Updated workflows --- .github/workflows/python-package.yml | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index b76d07423..dd0f40045 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -35,10 +35,27 @@ jobs: - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | - cargo llvm-cov --manifest-path ./Cargo.toml show-env --sh > llvm-cov-env.sh + cargo llvm-cov show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - uses: actions/checkout@v4 + - name: Debug checkout + run: | + echo "Current directory:" + pwd + + echo "Current commit:" + git rev-parse HEAD + git log -1 --oneline + + echo "Root files:" + ls -la + + echo "Cargo manifests:" + find . -name Cargo.toml -print + + echo "Is Cargo.toml tracked in this commit?" + git ls-tree -r HEAD --name-only | grep '^Cargo.toml$' || true - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From f7490c03544ba9ac6ba35543ea175155c5762a5f Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:33:10 +0100 Subject: [PATCH 043/112] Updated workflows --- .github/workflows/python-package.yml | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index dd0f40045..2cccb1ee6 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -31,14 +31,6 @@ jobs: - name: Install cargo-llvm-cov if: matrix.python-version == '3.12' uses: taiki-e/install-action@cargo-llvm-cov - - - name: Set Rust coverage environment - if: matrix.python-version == '3.12' - run: | - cargo llvm-cov show-env --sh > llvm-cov-env.sh - source llvm-cov-env.sh - cargo llvm-cov clean --workspace - - uses: actions/checkout@v4 - name: Debug checkout run: | echo "Current directory:" @@ -56,6 +48,13 @@ jobs: echo "Is Cargo.toml tracked in this commit?" git ls-tree -r HEAD --name-only | grep '^Cargo.toml$' || true + - name: Set Rust coverage environment + if: matrix.python-version == '3.12' + run: | + cargo llvm-cov show-env --sh > llvm-cov-env.sh + source llvm-cov-env.sh + cargo llvm-cov clean --workspace + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From 65db8e3298c9fb0e984471ec360e8e605ddcb328 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 13:38:43 +0100 Subject: [PATCH 044/112] Updated workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 2cccb1ee6..638a51dce 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -23,6 +23,7 @@ jobs: python-version: ["3.12", "3.13", "3.14"] steps: + - uses: actions/checkout@v4 - name: Install Rust uses: dtolnay/rust-toolchain@stable with: @@ -54,7 +55,6 @@ jobs: cargo llvm-cov show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace - - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From 40b188c0c406a87961fbfb0f312a525f3a179c2e Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 14:01:31 +0100 Subject: [PATCH 045/112] Updated workflows --- .github/workflows/python-package.yml | 31 +++++++++++----------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 638a51dce..1d3d1f22a 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -28,33 +28,16 @@ jobs: uses: dtolnay/rust-toolchain@stable with: components: llvm-tools-preview - - name: Install cargo-llvm-cov if: matrix.python-version == '3.12' uses: taiki-e/install-action@cargo-llvm-cov - - name: Debug checkout - run: | - echo "Current directory:" - pwd - - echo "Current commit:" - git rev-parse HEAD - git log -1 --oneline - - echo "Root files:" - ls -la - - echo "Cargo manifests:" - find . -name Cargo.toml -print - - echo "Is Cargo.toml tracked in this commit?" - git ls-tree -r HEAD --name-only | grep '^Cargo.toml$' || true - name: Set Rust coverage environment if: matrix.python-version == '3.12' run: | cargo llvm-cov show-env --sh > llvm-cov-env.sh source llvm-cov-env.sh cargo llvm-cov clean --workspace + - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: @@ -67,6 +50,9 @@ jobs: python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu + if [ "${{ matrix.python-version }}" = "3.12" ]; then + source llvm-cov-env.sh + fi uv pip install --system -e . - name: Cache tiatoolbox static assets uses: actions/cache@v4 @@ -91,6 +77,9 @@ jobs: ruff check . - name: Test with pytest run: | + if [ "${{ matrix.python-version }}" = "3.12" ]; then + source llvm-cov-env.sh + fi pytest --basetemp={envtmpdir} \ --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ --capture=sys \ @@ -104,7 +93,11 @@ jobs: files: coverage.xml fail_ci_if_error: false verbose: true - + - name: Generate Rust coverage report + if: matrix.python-version == '3.12' + run: | + source llvm-cov-env.sh + cargo llvm-cov report --lcov --output-path rust-lcov.info - name: Report test coverage to DeepSource uses: deepsourcelabs/test-coverage-action@master with: From 8e93c343d193bb4f8a2af25da6b1ed118a3e2909 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 14:24:27 +0100 Subject: [PATCH 046/112] Updated pyproject.toml --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 06edd3b82..75dd6e77c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -304,3 +304,4 @@ python_version = "3.12" python-source = "." include = ["tiatoolbox/**/*"] module-name = "tiatoolbox.rmisc" +editable-profile = "dev" From d51814238518953a4cbbee33f29deae54f831848 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 14:51:07 +0100 Subject: [PATCH 047/112] Edited workflows --- .github/workflows/python-package.yml | 71 +++++++++++++++------------- .github/workflows/rust.yml | 26 +++++----- 2 files changed, 53 insertions(+), 44 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 1d3d1f22a..ced29e273 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -24,24 +24,19 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Install Rust - uses: dtolnay/rust-toolchain@stable - with: - components: llvm-tools-preview - - name: Install cargo-llvm-cov - if: matrix.python-version == '3.12' - uses: taiki-e/install-action@cargo-llvm-cov - - name: Set Rust coverage environment - if: matrix.python-version == '3.12' - run: | - cargo llvm-cov show-env --sh > llvm-cov-env.sh - source llvm-cov-env.sh - cargo llvm-cov clean --workspace - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} + + # 1. Install Rust toolchain & coverage tooling + - name: Set up Rust toolchain + uses: dtolnay/rust-toolchain@stable + + - name: Install cargo-llvm-cov + uses: taiki-e/install-action@cargo-llvm-cov + - name: Install dependencies run: | sudo apt update @@ -50,15 +45,19 @@ jobs: python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu - if [ "${{ matrix.python-version }}" = "3.12" ]; then - source llvm-cov-env.sh - fi - uv pip install --system -e . + + # Clean prior coverage objects + cargo llvm-cov clean --workspace + + # 2. Compile Rust code with coverage instrumentation enabled + RUSTFLAGS="-C instrument-coverage" uv pip install --system -e . + - name: Cache tiatoolbox static assets uses: actions/cache@v4 with: key: tiatoolbox-home-static path: ~/.tiatoolbox + - name: Print Version Information run: | echo "---SQlite---" @@ -71,33 +70,36 @@ jobs: python -c "import sqlite3; print('SQLite %s' % sqlite3.sqlite_version)" python -c "import numpy; print('Numpy %s' % numpy.__version__)" python -c "import openslide; print('OpenSlide %s' % openslide.__version__)" + - name: Lint with ruff run: | # stop the build if there are Python syntax errors or undefined names ruff check . + + # 3. Tell LLVM to output profraw files when Rust code runs inside pytest - name: Test with pytest run: | - if [ "${{ matrix.python-version }}" = "3.12" ]; then - source llvm-cov-env.sh - fi - pytest --basetemp={envtmpdir} \ - --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ - --capture=sys \ - --durations=10 --durations-min=1.0 \ - --maxfail=1 + LLVM_PROFILE_FILE="rust-cov-%p-%m.profraw" pytest --basetemp={envtmpdir} \ + --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ + --capture=sys \ + --durations=10 --durations-min=1.0 \ + --maxfail=1 + + # 4. Generate the LCOV file from the produced .profraw files + - name: Export Rust coverage report to LCOV + run: | + cargo llvm-cov report --lcov --output-path rust-coverage.info + + # 5. Send both python coverage.xml AND rust-coverage.info to Codecov - name: Report test coverage to Codecov uses: codecov/codecov-action@v4 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} with: - files: coverage.xml + files: coverage.xml,rust-coverage.info fail_ci_if_error: false verbose: true - - name: Generate Rust coverage report - if: matrix.python-version == '3.12' - run: | - source llvm-cov-env.sh - cargo llvm-cov report --lcov --output-path rust-lcov.info + - name: Report test coverage to DeepSource uses: deepsourcelabs/test-coverage-action@master with: @@ -105,8 +107,10 @@ jobs: coverage-file: coverage.xml dsn: ${{ secrets.DEEPSOURCE_DSN }} fail-ci-on-error: false + - name: List tiatoolbox contents run: ls -lahR ~/.tiatoolbox + - name: Delete Hugging Face cache for large models run: | find ~/.tiatoolbox/models -type f -size +250M -exec bash -c ' @@ -140,6 +144,7 @@ jobs: uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu uv pip install --system -e . uv pip install --system build + - name: Build package run: python -m build @@ -149,10 +154,10 @@ jobs: user: __token__ password: ${{ secrets.TEST_PYPI_API_TOKEN }} repository_url: https://test.pypi.org/legacy/ - skip_existing: true # Ignore errors if the current version exists already + skip_existing: true - name: Publish package to PyPI - if: startsWith(github.ref, 'refs/tags/v') # Only run on tags starting with v + if: startsWith(github.ref, 'refs/tags/v') uses: pypa/gh-action-pypi-publish@release/v1 with: user: __token__ diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 5d495e6c4..62f11391c 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -2,16 +2,9 @@ name: Rust on: push: - branches: - - develop - - main - - master - + branches: [ develop, main, master ] pull_request: - branches: - - develop - - main - - master + branches: [ develop, main, master ] jobs: rust: @@ -26,11 +19,22 @@ jobs: with: components: rustfmt, clippy + - name: Install cargo-llvm-cov + uses: taiki-e/install-action@cargo-llvm-cov + - name: Check formatting run: cargo fmt --all -- --check - name: Run Clippy run: cargo clippy --all-targets --all-features -- -D warnings -A clippy::too_many_arguments - - name: Run Rust tests - run: cargo test --all + - name: Run Rust tests with coverage + run: cargo llvm-cov --all-features --lcov --output-path lcov.info + + - name: Upload Rust coverage to Codecov + uses: codecov/codecov-action@v4 + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + with: + files: lcov.info + fail_ci_if_error: false From 351269eb759e219a4b4d9428be811fd5c9f687db Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 15:27:08 +0100 Subject: [PATCH 048/112] Edited workflows --- .github/workflows/python-package.yml | 47 ++++++---------------------- 1 file changed, 9 insertions(+), 38 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index ced29e273..8eb763862 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -24,19 +24,10 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - - # 1. Install Rust toolchain & coverage tooling - - name: Set up Rust toolchain - uses: dtolnay/rust-toolchain@stable - - - name: Install cargo-llvm-cov - uses: taiki-e/install-action@cargo-llvm-cov - - name: Install dependencies run: | sudo apt update @@ -45,19 +36,12 @@ jobs: python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu - - # Clean prior coverage objects - cargo llvm-cov clean --workspace - - # 2. Compile Rust code with coverage instrumentation enabled - RUSTFLAGS="-C instrument-coverage" uv pip install --system -e . - + uv pip install --system -e . - name: Cache tiatoolbox static assets uses: actions/cache@v4 with: key: tiatoolbox-home-static path: ~/.tiatoolbox - - name: Print Version Information run: | echo "---SQlite---" @@ -70,33 +54,23 @@ jobs: python -c "import sqlite3; print('SQLite %s' % sqlite3.sqlite_version)" python -c "import numpy; print('Numpy %s' % numpy.__version__)" python -c "import openslide; print('OpenSlide %s' % openslide.__version__)" - - name: Lint with ruff run: | # stop the build if there are Python syntax errors or undefined names ruff check . - - # 3. Tell LLVM to output profraw files when Rust code runs inside pytest - name: Test with pytest run: | - LLVM_PROFILE_FILE="rust-cov-%p-%m.profraw" pytest --basetemp={envtmpdir} \ - --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ - --capture=sys \ - --durations=10 --durations-min=1.0 \ - --maxfail=1 - - # 4. Generate the LCOV file from the produced .profraw files - - name: Export Rust coverage report to LCOV - run: | - cargo llvm-cov report --lcov --output-path rust-coverage.info - - # 5. Send both python coverage.xml AND rust-coverage.info to Codecov + pytest --basetemp={envtmpdir} \ + --cov=tiatoolbox --cov-report=term --cov-report=xml --cov-config=pyproject.toml \ + --capture=sys \ + --durations=10 --durations-min=1.0 \ + --maxfail=1 - name: Report test coverage to Codecov uses: codecov/codecov-action@v4 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} with: - files: coverage.xml,rust-coverage.info + files: coverage.xml fail_ci_if_error: false verbose: true @@ -107,10 +81,8 @@ jobs: coverage-file: coverage.xml dsn: ${{ secrets.DEEPSOURCE_DSN }} fail-ci-on-error: false - - name: List tiatoolbox contents run: ls -lahR ~/.tiatoolbox - - name: Delete Hugging Face cache for large models run: | find ~/.tiatoolbox/models -type f -size +250M -exec bash -c ' @@ -144,7 +116,6 @@ jobs: uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu uv pip install --system -e . uv pip install --system build - - name: Build package run: python -m build @@ -154,10 +125,10 @@ jobs: user: __token__ password: ${{ secrets.TEST_PYPI_API_TOKEN }} repository_url: https://test.pypi.org/legacy/ - skip_existing: true + skip_existing: true # Ignore errors if the current version exists already - name: Publish package to PyPI - if: startsWith(github.ref, 'refs/tags/v') + if: startsWith(github.ref, 'refs/tags/v') # Only run on tags starting with v uses: pypa/gh-action-pypi-publish@release/v1 with: user: __token__ From ec95b40fff5621d6283b0d6b03f3a6402fc4f7f5 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 15:53:58 +0100 Subject: [PATCH 049/112] Edited workflows --- .github/workflows/codecov.yml | 22 +++++++++++++ .github/workflows/rust.yml | 58 +++++++++++++++++++++++++++++------ 2 files changed, 71 insertions(+), 9 deletions(-) create mode 100644 .github/workflows/codecov.yml diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml new file mode 100644 index 000000000..c6b34b034 --- /dev/null +++ b/.github/workflows/codecov.yml @@ -0,0 +1,22 @@ +flags: + python: + paths: + - "**/*.py" + carryforward: false + rust: + paths: + - "src/" + carryforward: false + rust-via-python: + paths: + - "src/" + carryforward: false + +coverage: + status: + project: + default: + target: auto + patch: + default: + target: auto diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 62f11391c..3f20594a1 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -1,40 +1,80 @@ name: Rust - on: push: branches: [ develop, main, master ] pull_request: branches: [ develop, main, master ] - jobs: rust: runs-on: ubuntu-latest - steps: - name: Checkout repository uses: actions/checkout@v4 - - name: Install Rust uses: dtolnay/rust-toolchain@stable with: components: rustfmt, clippy - - name: Install cargo-llvm-cov uses: taiki-e/install-action@cargo-llvm-cov - - name: Check formatting run: cargo fmt --all -- --check - - name: Run Clippy run: cargo clippy --all-targets --all-features -- -D warnings -A clippy::too_many_arguments - - name: Run Rust tests with coverage run: cargo llvm-cov --all-features --lcov --output-path lcov.info - - name: Upload Rust coverage to Codecov uses: codecov/codecov-action@v4 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} with: files: lcov.info + flags: rust + fail_ci_if_error: false + + rust-via-python: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + with: + components: llvm-tools-preview + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: "3.12" + - name: Install grcov + uses: taiki-e/install-action@grcov + - name: Install Python + build deps + run: | + python -m pip install --upgrade pip + pip install maturin pytest pytest-cov + - name: Build instrumented extension + env: + RUSTFLAGS: "-C instrument-coverage" + LLVM_PROFILE_FILE: "target/coverage/prof-%p-%m.profraw" + run: maturin develop + - name: Run Python tests (exercises Rust via extension) + env: + RUSTFLAGS: "-C instrument-coverage" + LLVM_PROFILE_FILE: "target/coverage/prof-%p-%m.profraw" + run: pytest --maxfail=1 + - name: Generate Rust lcov from Python-driven execution + run: | + grcov target/coverage/ \ + --binary-path ./target/debug/ \ + -s . \ + -t lcov \ + --branch \ + --ignore-not-existing \ + --ignore "*/target/*" \ + -o rust-via-python.lcov + - name: Upload Rust-via-Python coverage to Codecov + uses: codecov/codecov-action@v4 + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + with: + files: rust-via-python.lcov + flags: rust-via-python fail_ci_if_error: false From e79221955611c15681af0d823446a8aa247d3daf Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 16:03:53 +0100 Subject: [PATCH 050/112] Edited workflows --- .github/workflows/rust.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 3f20594a1..f2185a580 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -46,9 +46,13 @@ jobs: python-version: "3.12" - name: Install grcov uses: taiki-e/install-action@grcov + - name: Create virtualenv and add to PATH + run: | + python -m venv .venv + echo "$PWD/.venv/bin" >> "$GITHUB_PATH" - name: Install Python + build deps run: | - python -m pip install --upgrade pip + pip install --upgrade pip pip install maturin pytest pytest-cov - name: Build instrumented extension env: From 6b7d1fd835409e9c0dc2278017f8308f83209140 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 16:30:56 +0100 Subject: [PATCH 051/112] Edited tests --- .github/workflows/codecov.yml | 22 -------------- .github/workflows/rust.yml | 52 ---------------------------------- tests/test_misc.rs | 28 +++++++++++++++++- tests/test_rust.py | 32 +++++++++++++++++++++ tiatoolbox/rust-library/lib.rs | 6 ++-- 5 files changed, 62 insertions(+), 78 deletions(-) delete mode 100644 .github/workflows/codecov.yml create mode 100644 tests/test_rust.py diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml deleted file mode 100644 index c6b34b034..000000000 --- a/.github/workflows/codecov.yml +++ /dev/null @@ -1,22 +0,0 @@ -flags: - python: - paths: - - "**/*.py" - carryforward: false - rust: - paths: - - "src/" - carryforward: false - rust-via-python: - paths: - - "src/" - carryforward: false - -coverage: - status: - project: - default: - target: auto - patch: - default: - target: auto diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index f2185a580..0ee767a5f 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -30,55 +30,3 @@ jobs: files: lcov.info flags: rust fail_ci_if_error: false - - rust-via-python: - runs-on: ubuntu-latest - steps: - - name: Checkout repository - uses: actions/checkout@v4 - - name: Install Rust - uses: dtolnay/rust-toolchain@stable - with: - components: llvm-tools-preview - - name: Set up Python - uses: actions/setup-python@v4 - with: - python-version: "3.12" - - name: Install grcov - uses: taiki-e/install-action@grcov - - name: Create virtualenv and add to PATH - run: | - python -m venv .venv - echo "$PWD/.venv/bin" >> "$GITHUB_PATH" - - name: Install Python + build deps - run: | - pip install --upgrade pip - pip install maturin pytest pytest-cov - - name: Build instrumented extension - env: - RUSTFLAGS: "-C instrument-coverage" - LLVM_PROFILE_FILE: "target/coverage/prof-%p-%m.profraw" - run: maturin develop - - name: Run Python tests (exercises Rust via extension) - env: - RUSTFLAGS: "-C instrument-coverage" - LLVM_PROFILE_FILE: "target/coverage/prof-%p-%m.profraw" - run: pytest --maxfail=1 - - name: Generate Rust lcov from Python-driven execution - run: | - grcov target/coverage/ \ - --binary-path ./target/debug/ \ - -s . \ - -t lcov \ - --branch \ - --ignore-not-existing \ - --ignore "*/target/*" \ - -o rust-via-python.lcov - - name: Upload Rust-via-Python coverage to Codecov - uses: codecov/codecov-action@v4 - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - with: - files: rust-via-python.lcov - flags: rust-via-python - fail_ci_if_error: false diff --git a/tests/test_misc.rs b/tests/test_misc.rs index a56827e79..a182ea2c4 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -1,4 +1,5 @@ -use rmisc::add; +use rmisc::{add, string_to_tuple}; +use std::process::{Command, Stdio}; #[test] fn test_add() { @@ -6,3 +7,28 @@ fn test_add() { assert_eq!(result, 5); } + +#[test] +fn test_string_to_tuple() { + let in_str = "a, b, c".to_string(); + let result = string_to_tuple(in_str); + + assert_eq!(result, vec!["a", "b", "c"]) +} + +#[test] +fn test_misc() { + let status = Command::new("python3") + .args(["-m", "pytest", "tests/test_rust.py", "-v"]) + .stdout(Stdio::inherit()) + .stderr(Stdio::inherit()) + .status() + .expect("Failed to run pytest"); + + if status.success() { + println!("Tests passed!"); + } else { + eprintln!("Tests failed!"); + std::process::exit(1); + } +} diff --git a/tests/test_rust.py b/tests/test_rust.py new file mode 100644 index 000000000..e63ec3cbe --- /dev/null +++ b/tests/test_rust.py @@ -0,0 +1,32 @@ +"""Test for rust functionality.""" + +import numpy as np + +from tiatoolbox import utils + + +def test_contrast_enhancer() -> None: + """Test contrast enhancement functionality.""" + input_array = np.array( + [ + [37, 244, 193, 106, 235, 128, 71, 140, 47], + [103, 184, 72, 20, 188, 238, 126, 7, 0], + [137, 195, 204, 32, 203, 170, 101, 77, 133], + ], + dtype=np.uint8, + ) + + # expected output of the contrast_enhancer + result_array = np.array( + [ + [35, 255, 203, 110, 248, 133, 72, 146, 46], + [106, 193, 73, 17, 198, 251, 131, 3, 0], + [143, 205, 215, 30, 214, 178, 104, 78, 139], + ], + dtype=np.uint8, + ) + + # Calculating the contrast enhanced version of input_array + output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) + # The out_put array should be equal to expected result_array + assert np.all(result_array == output_array) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 19b7662ca..a0b648b41 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -23,7 +23,7 @@ pub fn add(a: i32, b: i32) -> i32 { } #[pyfunction] -fn string_to_tuple(in_str: String) -> Vec { +pub fn string_to_tuple(in_str: String) -> Vec { /*Splits input string to tuple at ','. Args: @@ -38,7 +38,7 @@ fn string_to_tuple(in_str: String) -> Vec { } #[pyfunction] -fn semantic_segmentations_as_qupath_json( +pub fn semantic_segmentations_as_qupath_json( py: Python<'_>, layer_list: &Bound<'_, PyList>, preds: &Bound<'_, PyAny>, @@ -344,7 +344,7 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 } #[pyfunction] -fn contrast_enhancer<'py>( +pub fn contrast_enhancer<'py>( py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p: u8, From da75c91d89cd08c580b902c67e3754c58357a4ea Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 16:39:28 +0100 Subject: [PATCH 052/112] Edited workflow --- .github/workflows/rust.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 0ee767a5f..978ad6162 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -8,6 +8,12 @@ jobs: rust: runs-on: ubuntu-latest steps: + - name: Install dependencies + run: | + sudo apt update + sudo apt-get install -y libopenjp2-7 libopenjp2-tools + python -m pip install --upgrade pip + python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner - name: Checkout repository uses: actions/checkout@v4 - name: Install Rust From 6f69197379c8937fdcc2658c535222a446729f50 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 16:46:55 +0100 Subject: [PATCH 053/112] Edited workflow --- .github/workflows/rust.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 978ad6162..db02558a3 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -14,6 +14,9 @@ jobs: sudo apt-get install -y libopenjp2-7 libopenjp2-tools python -m pip install --upgrade pip python -m pip install ruff==0.16.1 pytest pytest-cov pytest-runner + pip install uv + uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu + uv pip install --system -e . - name: Checkout repository uses: actions/checkout@v4 - name: Install Rust From 51496744135e10e7661c6f6eba00b38664b3276c Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 16:54:37 +0100 Subject: [PATCH 054/112] Edited workflow --- .github/workflows/rust.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index db02558a3..274133b21 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -8,6 +8,12 @@ jobs: rust: runs-on: ubuntu-latest steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v7 + with: + python-version: "3.12" - name: Install dependencies run: | sudo apt update From 1eb945956c6cfdf33f0489f87f0099a1c176efe1 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 17:05:31 +0100 Subject: [PATCH 055/112] Edited workflow --- .github/workflows/rust.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 274133b21..4522c7b42 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -23,8 +23,6 @@ jobs: pip install uv uv pip install --system torch torchvision --index-url https://download.pytorch.org/whl/cpu uv pip install --system -e . - - name: Checkout repository - uses: actions/checkout@v4 - name: Install Rust uses: dtolnay/rust-toolchain@stable with: From fd3caf02699daeaff4d129b2842303062cae3c06 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 17:11:16 +0100 Subject: [PATCH 056/112] Edited tests --- tests/test_rust.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index e63ec3cbe..1a8ba0f72 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -9,9 +9,11 @@ def test_contrast_enhancer() -> None: """Test contrast enhancement functionality.""" input_array = np.array( [ - [37, 244, 193, 106, 235, 128, 71, 140, 47], - [103, 184, 72, 20, 188, 238, 126, 7, 0], - [137, 195, 204, 32, 203, 170, 101, 77, 133], + [ + [37, 244, 193, 106, 235, 128, 71, 140, 47], + [103, 184, 72, 20, 188, 238, 126, 7, 0], + [137, 195, 204, 32, 203, 170, 101, 77, 133], + ] ], dtype=np.uint8, ) @@ -19,9 +21,11 @@ def test_contrast_enhancer() -> None: # expected output of the contrast_enhancer result_array = np.array( [ - [35, 255, 203, 110, 248, 133, 72, 146, 46], - [106, 193, 73, 17, 198, 251, 131, 3, 0], - [143, 205, 215, 30, 214, 178, 104, 78, 139], + [ + [35, 255, 203, 110, 248, 133, 72, 146, 46], + [106, 193, 73, 17, 198, 251, 131, 3, 0], + [143, 205, 215, 30, 214, 178, 104, 78, 139], + ] ], dtype=np.uint8, ) From 858b5be5f5a9f3eb8a9d61a8b62f1f99ffc50730 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 17:28:01 +0100 Subject: [PATCH 057/112] Edited workflow --- .github/workflows/rust.yml | 25 +++++++++++++++++++++++-- tests/test_rust.py | 1 + 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 4522c7b42..1494f5bd0 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -33,8 +33,29 @@ jobs: run: cargo fmt --all -- --check - name: Run Clippy run: cargo clippy --all-targets --all-features -- -D warnings -A clippy::too_many_arguments - - name: Run Rust tests with coverage - run: cargo llvm-cov --all-features --lcov --output-path lcov.info + - name: Run Rust coverage + shell: bash + run: | + # Configure Rust builds for LLVM coverage + source <(cargo llvm-cov show-env --sh) + + # Important: clean BEFORE rebuilding the Python extension + cargo llvm-cov clean --workspace + + # Rebuild the PyO3/Maturin extension WITH coverage instrumentation + python -m pip install --force-reinstall --no-deps -e . + + # Verify which native extension Python actually loads + python -c "import tiatoolbox.rust_misc as r; print(r.__file__)" + + # Run Python tests that exercise the Rust extension + python -m pytest tests/test_rust.py -v + + # Run normal native Rust tests too + cargo test --all-features + + # Generate one Rust coverage report + cargo llvm-cov report --lcov --output-path lcov.info - name: Upload Rust coverage to Codecov uses: codecov/codecov-action@v4 env: diff --git a/tests/test_rust.py b/tests/test_rust.py index 1a8ba0f72..bec9b96c8 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -7,6 +7,7 @@ def test_contrast_enhancer() -> None: """Test contrast enhancement functionality.""" + print("Test contrast") input_array = np.array( [ [ From f7bc02d32a2a5a803c38f6aa32302a4482f869a8 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 17:31:16 +0100 Subject: [PATCH 058/112] Edited workflow --- .github/workflows/rust.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 1494f5bd0..4fe1b752b 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -46,7 +46,7 @@ jobs: python -m pip install --force-reinstall --no-deps -e . # Verify which native extension Python actually loads - python -c "import tiatoolbox.rust_misc as r; print(r.__file__)" + python -c "import tiatoolbox.rmisc as r; print(r.__file__)" # Run Python tests that exercise the Rust extension python -m pytest tests/test_rust.py -v From 3695250d533954848410e3e83baf24b426a0c41c Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 17:37:53 +0100 Subject: [PATCH 059/112] Edited tests --- tests/test_misc.rs | 3 ++- tests/test_rust.py | 28 +++++++++++++++++++++++++++- 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/tests/test_misc.rs b/tests/test_misc.rs index a182ea2c4..526008c30 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -15,7 +15,7 @@ fn test_string_to_tuple() { assert_eq!(result, vec!["a", "b", "c"]) } - +''' #[test] fn test_misc() { let status = Command::new("python3") @@ -32,3 +32,4 @@ fn test_misc() { std::process::exit(1); } } +''' diff --git a/tests/test_rust.py b/tests/test_rust.py index bec9b96c8..a77da1a9c 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -7,7 +7,6 @@ def test_contrast_enhancer() -> None: """Test contrast enhancement functionality.""" - print("Test contrast") input_array = np.array( [ [ @@ -35,3 +34,30 @@ def test_contrast_enhancer() -> None: output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) + input_array = np.array( + [ + [ + [0], + [0], + [0], + ] + ], + dtype=np.uint8, + ) + + # expected output of the contrast_enhancer + result_array = np.array( + [ + [ + [0], + [0], + [0], + ] + ], + dtype=np.uint8, + ) + + # Calculating the contrast enhanced version of input_array + output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) + # The out_put array should be equal to expected result_array + assert np.all(result_array == output_array) From 84d61955b18d2bdacc0f30c565fc47bec9d81124 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 18:35:20 +0100 Subject: [PATCH 060/112] Corrected test --- tests/test_misc.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_misc.rs b/tests/test_misc.rs index 526008c30..c81732520 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -15,7 +15,7 @@ fn test_string_to_tuple() { assert_eq!(result, vec!["a", "b", "c"]) } -''' +/* #[test] fn test_misc() { let status = Command::new("python3") @@ -32,4 +32,4 @@ fn test_misc() { std::process::exit(1); } } -''' +*/ From 7850da386a962ef0298b87c0d1cddaa5b18a2462 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 18:38:37 +0100 Subject: [PATCH 061/112] Corrected test --- tests/test_misc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_misc.rs b/tests/test_misc.rs index c81732520..2904c7a0a 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -1,5 +1,5 @@ use rmisc::{add, string_to_tuple}; -use std::process::{Command, Stdio}; +//use std::process::{Command, Stdio}; #[test] fn test_add() { From ef52cb8f74179578bedc026483f211ef85f86d7b Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 18:45:47 +0100 Subject: [PATCH 062/112] Updated workflow to ensure test utils as well --- .github/workflows/rust.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 4fe1b752b..cf8c7975f 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -50,6 +50,7 @@ jobs: # Run Python tests that exercise the Rust extension python -m pytest tests/test_rust.py -v + python -m pytest tests/test_utils.py -v # Run normal native Rust tests too cargo test --all-features From 4e033c1f2baf305540e9190618a78e12401e9982 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 19:13:01 +0100 Subject: [PATCH 063/112] Updated tests --- .github/workflows/rust.yml | 1 - tests/test_rust.py | 87 +++++++++++++++++++++++++++++++++++++- 2 files changed, 86 insertions(+), 2 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index cf8c7975f..4fe1b752b 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -50,7 +50,6 @@ jobs: # Run Python tests that exercise the Rust extension python -m pytest tests/test_rust.py -v - python -m pytest tests/test_utils.py -v # Run normal native Rust tests too cargo test --all-features diff --git a/tests/test_rust.py b/tests/test_rust.py index a77da1a9c..92d64a72d 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -2,7 +2,7 @@ import numpy as np -from tiatoolbox import utils +from tiatoolbox import rmisc, utils def test_contrast_enhancer() -> None: @@ -61,3 +61,88 @@ def test_contrast_enhancer() -> None: output_array = utils.misc.contrast_enhancer(input_array, low_p=2, high_p=98) # The out_put array should be equal to expected result_array assert np.all(result_array == output_array) + + +def test_patch_predictions_as_qupath_json() -> None: + """Tests that the rust code for patch_predictions_as_qupath_json works correctly.""" + class_colours = { + 0.0: [255, 0, 0], + 1.0: [0, 255, 0], + } + + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } + + preds = [0.0, 1.0] + + patch_coords = np.array( + [ + [10.0, 20.0, 30.0, 40.0], + [50.0, 60.0, 70.0, 80.0], + ], + dtype=np.float64, + ) + + result = rmisc.patch_predictions_as_qupath_json( + class_colours, + preds, + class_dict, + patch_coords, + ) + + expected = [ + { + "type": "Feature", + "id": "patch_0", + "geometry": { + "type": "Polygon", + "coordinates": ( + ( + (10.0, 20.0), + (10.0, 40.0), + (30.0, 40.0), + (30.0, 20.0), + (10.0, 20.0), + ), + ), + }, + "properties": { + "classification": { + "name": "Tumour", + "color": [255, 0, 0], + } + }, + "objectType": "annotation", + "name": "Tumour", + "class_value": 0.0, + }, + { + "type": "Feature", + "id": "patch_1", + "geometry": { + "type": "Polygon", + "coordinates": ( + ( + (50.0, 60.0), + (50.0, 80.0), + (70.0, 80.0), + (70.0, 60.0), + (50.0, 60.0), + ), + ), + }, + "properties": { + "classification": { + "name": "Normal", + "color": [0, 255, 0], + } + }, + "objectType": "annotation", + "name": "Normal", + "class_value": 1.0, + }, + ] + + assert result == expected From 49a103667c6f12a2454dbf7a85c0dc0c3e400132 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 19:43:25 +0100 Subject: [PATCH 064/112] Test for patch predictions as annotations --- tests/test_rust.py | 136 +++++++++++++++++++++++++++++++++ tiatoolbox/rust-library/lib.rs | 9 +-- 2 files changed, 139 insertions(+), 6 deletions(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index 92d64a72d..a9f855dd1 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -146,3 +146,139 @@ def test_patch_predictions_as_qupath_json() -> None: ] assert result == expected + + +class DummyPolygon: + """Minimal polygon stub used to test annotation generation.""" + + @classmethod + def from_bounds( + cls, + xmin: float, + ymin: float, + xmax: float, + ymax: float, + ) -> tuple[float, float, float, float]: + """Return polygon bounds as a tuple.""" + return (xmin, ymin, xmax, ymax) + + +class DummyAnnotation: + """Minimal annotation stub storing polygon geometry and properties.""" + + def __init__( + self, + polygon: tuple[float, float, float, float], + properties: dict[str, str | float], + ) -> None: + """Initialize an annotation with geometry and associated properties.""" + self.polygon: tuple[float, float, float, float] = polygon + self.properties: dict[str, str | float] = properties + + +def test_patch_predictions_as_annotations() -> None: + """Tests that the rust code for patch_predictions_as_annotations works correctly.""" + preds = [0.0, 1.0] + + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } + + class_probs = np.array( + [ + [0.8, 0.2], + [0.1, 0.9], + ], + dtype=np.float64, + ) + + patch_coords = np.array( + [ + [10.0, 20.0, 30.0, 40.0], + [50.0, 60.0, 70.0, 80.0], + ], + dtype=np.float64, + ) + + keys_contains_labels = True + keys_contains_probabilities = True + + annotations = rmisc.patch_predictions_as_annotations( + DummyAnnotation, + DummyPolygon, + preds, + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + + assert len(annotations) == 2 + + assert annotations[0].polygon == (10.0, 20.0, 30.0, 40.0) + assert annotations[0].properties == { + "prob_Tumour": 0.8, + "prob_Normal": 0.2, + "label": "Normal", + "type": "Tumour", + } + + assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) + assert annotations[1].properties == { + "prob_Tumour": 0.1, + "prob_Normal": 0.9, + "label": "Tumour", + "type": "Normal", + } + + keys_contains_labels = False + keys_contains_probabilities = False + + annotations = rmisc.patch_predictions_as_annotations( + DummyAnnotation, + DummyPolygon, + preds, + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + + assert len(annotations) == 2 + + assert annotations[0].polygon == (10.0, 20.0, 30.0, 40.0) + assert annotations[0].properties == { + "type": "Tumour", + } + + assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) + assert annotations[1].properties == { + "type": "Normal", + } + annotations = rmisc.patch_predictions_as_annotations( + DummyAnnotation, + DummyPolygon, + [], + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + + assert len(annotations) == 2 + + assert annotations[0].polygon == (10.0, 20.0, 30.0, 40.0) + assert annotations[0].properties == {} + + assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) + assert annotations[1].properties == {} diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index a0b648b41..d309131db 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -96,8 +96,7 @@ pub fn semantic_segmentations_as_qupath_json( classification.set_item("name", &class_label)?; classification.set_item( "color", - class_colours[&OrderedFloat(class_id as f64)].clone(), - )?; + class_colours[&OrderedFloat(class_id as f64)].clone(),)?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; @@ -170,8 +169,7 @@ fn patch_predictions_as_annotations<'py>( }; props.set_item( format!("prob_{}", probability), - class_probs[[i, *j as usize]], - )?; + class_probs[[i, *j as usize]],)?; } } if keys_contains_labels { @@ -262,8 +260,7 @@ fn patch_predictions_as_qupath_json<'py>( (xmax, ymax), (xmax, ymin), (xmin, ymin), - ),), - )?; + ),),)?; let feature = PyDict::new(py); feature.set_item("type", "Feature")?; feature.set_item("id", format!("patch_{}", i))?; From 6d5f94c99006efb609c5b85da009d375c6b99bfa Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 19:52:44 +0100 Subject: [PATCH 065/112] Edited rust library for formatting --- tiatoolbox/rust-library/lib.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index d309131db..cdaa16e37 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -96,7 +96,8 @@ pub fn semantic_segmentations_as_qupath_json( classification.set_item("name", &class_label)?; classification.set_item( "color", - class_colours[&OrderedFloat(class_id as f64)].clone(),)?; + class_colours[&OrderedFloat(class_id as f64)].clone(), + )?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; @@ -169,7 +170,8 @@ fn patch_predictions_as_annotations<'py>( }; props.set_item( format!("prob_{}", probability), - class_probs[[i, *j as usize]],)?; + class_probs[[i, *j as usize]], + )?; } } if keys_contains_labels { @@ -267,7 +269,10 @@ fn patch_predictions_as_qupath_json<'py>( feature.set_item("geometry", polygon_feat)?; let classification = PyDict::new(py); classification.set_item("name", class_name)?; - classification.set_item("color", class_colours[&OrderedFloat(class_idx)].clone())?; + classification.set_item( + "color", + class_colours[&OrderedFloat(class_idx)].clone() + )?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; From 3702dd96b71dbca6f8d1482efb963d09d46bdb75 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 19:56:55 +0100 Subject: [PATCH 066/112] Edited rust library for formatting --- tiatoolbox/rust-library/lib.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index cdaa16e37..a0b648b41 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -262,17 +262,15 @@ fn patch_predictions_as_qupath_json<'py>( (xmax, ymax), (xmax, ymin), (xmin, ymin), - ),),)?; + ),), + )?; let feature = PyDict::new(py); feature.set_item("type", "Feature")?; feature.set_item("id", format!("patch_{}", i))?; feature.set_item("geometry", polygon_feat)?; let classification = PyDict::new(py); classification.set_item("name", class_name)?; - classification.set_item( - "color", - class_colours[&OrderedFloat(class_idx)].clone() - )?; + classification.set_item("color", class_colours[&OrderedFloat(class_idx)].clone())?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; From b579f3f88a6ab0fd13a62322546523abf1c87d38 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Tue, 25 Aug 2026 20:10:06 +0100 Subject: [PATCH 067/112] Edited rust library for formatting --- tests/test_rust.py | 40 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index a9f855dd1..92f967009 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -234,10 +234,48 @@ def test_patch_predictions_as_annotations() -> None: "label": "Tumour", "type": "Normal", } + class_dict = { + 0.0: 1.2, + 1.0: "Normal", + } + + annotations = rmisc.patch_predictions_as_annotations( + DummyAnnotation, + DummyPolygon, + preds, + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + + assert len(annotations) == 2 + + assert annotations[0].polygon == (10.0, 20.0, 30.0, 40.0) + assert annotations[0].properties == { + "prob_1.2": 0.8, + "prob_Normal": 0.2, + "label": "Normal", + "type": 1.2, + } + + assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) + assert annotations[1].properties == { + "prob_1.2": 0.1, + "prob_Normal": 0.9, + "label": 1.2, + "type": "Normal", + } keys_contains_labels = False keys_contains_probabilities = False - + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } annotations = rmisc.patch_predictions_as_annotations( DummyAnnotation, DummyPolygon, From 20a89407c86268222f46939f46194869be3e1077 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 10:12:15 +0100 Subject: [PATCH 068/112] Added two new tests for semantic_segmentations_as_qupath_json and json_dump_python_object --- tests/test_rust.py | 97 +++++++++++++++++++++++++++++++++- tiatoolbox/rust-library/lib.rs | 6 +-- 2 files changed, 98 insertions(+), 5 deletions(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index 92f967009..b9139cf34 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -1,5 +1,11 @@ """Test for rust functionality.""" +import json +import tempfile +from pathlib import Path + +import cv2 +import dask.array as da import numpy as np from tiatoolbox import rmisc, utils @@ -149,7 +155,7 @@ def test_patch_predictions_as_qupath_json() -> None: class DummyPolygon: - """Minimal polygon stub used to test annotation generation.""" + """Minimal polygon class used to test the method from bounds.""" @classmethod def from_bounds( @@ -164,7 +170,7 @@ def from_bounds( class DummyAnnotation: - """Minimal annotation stub storing polygon geometry and properties.""" + """Minimal annotation class storing polygon geometry and properties.""" def __init__( self, @@ -320,3 +326,90 @@ def test_patch_predictions_as_annotations() -> None: assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) assert annotations[1].properties == {} + + +def test_json_dump_python_object() -> None: + """Tests whether json_dump_python_object works.""" + obj = { + "name": "Alice", + "age": 30, + "active": True, + "numbers": [1, 2, 3], + } + + with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tmp: + path = Path(tmp.name) + + try: + rmisc.json_dump_python_object(str(path), obj) + + with path.open() as f: + result = json.load(f) + + assert result == obj + + finally: + path.unlink() + + +def poly_geo_func(_coords: list) -> list: + """Dummy function for testing semantic_segmentations_as_qupath_json.""" + return [] + + +def test_semantic_segmentations_as_qupath_json() -> None: + """Test semantic_segmentations_as_qupath_json. + + Ensure the Rust implementation returns the expected result. + """ + class_colours = { + 0.0: [255, 0, 0], + 1.0: [0, 255, 0], + } + + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } + + preds = da.from_array( + np.array( + [ + [0, 0, 0, 1, 1], + [0, 0, 0, 1, 1], + [0, 0, 0, 1, 1], + [1, 1, 1, 1, 1], + ] + ) + ) + + scale_factor = (0.5, 0.5) + + layer_list = [0.0, 1.0] + + result = rmisc.semantic_segmentations_as_qupath_json( + layer_list, preds, scale_factor, class_dict, class_colours, cv2, poly_geo_func + ) + + expected = [ + { + "type": "Feature", + "geometry": [], + "id": "class_0_0", + "properties": {"classification": {"name": "Tumour", "color": [255, 0, 0]}}, + "objectType": "annotation", + "name": "Tumour", + "class_value": 0.0, + }, + { + "type": "Feature", + "geometry": [], + "id": "class_1_1", + "properties": {"classification": {"name": "Normal", "color": [0, 255, 0]}}, + "objectType": "annotation", + "name": "Normal", + "class_value": 1.0, + }, + ] + + assert result == expected diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index a0b648b41..bfaf2ba1d 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -63,7 +63,7 @@ pub fn semantic_segmentations_as_qupath_json( let chain_approx_none = cv2.getattr("CHAIN_APPROX_NONE")?; let find_contours = cv2.getattr("findContours")?; for type_class in layer_list.iter() { - let class_id: i64 = type_class.extract()?; + let class_id: f64 = type_class.extract()?; let class_label = class_dict.get_item(class_id)?; let layer = preds .rich_compare(class_id, CompareOp::Eq)? @@ -171,7 +171,7 @@ fn patch_predictions_as_annotations<'py>( props.set_item( format!("prob_{}", probability), class_probs[[i, *j as usize]], - )?; + ); } } if keys_contains_labels { @@ -263,7 +263,7 @@ fn patch_predictions_as_qupath_json<'py>( (xmax, ymin), (xmin, ymin), ),), - )?; + ); let feature = PyDict::new(py); feature.set_item("type", "Feature")?; feature.set_item("id", format!("patch_{}", i))?; From a7a1de70b983a9f50992ad4748d76c8234e64ba5 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 10:25:06 +0100 Subject: [PATCH 069/112] Corrected formatting for rust --- tiatoolbox/rust-library/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index bfaf2ba1d..ce562f74a 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -96,7 +96,7 @@ pub fn semantic_segmentations_as_qupath_json( classification.set_item("name", &class_label)?; classification.set_item( "color", - class_colours[&OrderedFloat(class_id as f64)].clone(), + class_colours[&OrderedFloat(class_id)].clone(), )?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; @@ -168,7 +168,7 @@ fn patch_predictions_as_annotations<'py>( StringOrFloat::String(s) => s.clone(), StringOrFloat::Float(i) => i.to_string(), }; - props.set_item( + let _ = props.set_item( format!("prob_{}", probability), class_probs[[i, *j as usize]], ); @@ -254,7 +254,7 @@ fn patch_predictions_as_qupath_json<'py>( let ymax = patch_coords[[i, 3]]; let polygon_feat = PyDict::new(py); polygon_feat.set_item("type", "Polygon")?; - polygon_feat.set_item( + let _ = polygon_feat.set_item( "coordinates", (( (xmin, ymin), From cc6a42b70decb4f49f5be9ba1ae4b3261deedb32 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Wed, 26 Aug 2026 10:27:53 +0100 Subject: [PATCH 070/112] Corrected formatting for rust-library/lib.rs --- tiatoolbox/rust-library/lib.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index ce562f74a..42d391cba 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -94,10 +94,7 @@ pub fn semantic_segmentations_as_qupath_json( feature.set_item("id", format!("class_{}_{}", class_id, features.len()))?; let classification = PyDict::new(py); classification.set_item("name", &class_label)?; - classification.set_item( - "color", - class_colours[&OrderedFloat(class_id)].clone(), - )?; + classification.set_item("color", class_colours[&OrderedFloat(class_id)].clone())?; let properties = PyDict::new(py); properties.set_item("classification", classification)?; feature.set_item("properties", properties)?; From c5a98d2ff0dff71267897ce2b3e385a17dad82f2 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:03:32 +0100 Subject: [PATCH 071/112] Improved formatting --- tests/test_misc.rs | 29 +++-------------------------- tiatoolbox/rmisc.pyi | 15 +++++++++++++-- tiatoolbox/rust-library/lib.rs | 13 ++----------- tiatoolbox/utils/misc.py | 4 +--- 4 files changed, 19 insertions(+), 42 deletions(-) diff --git a/tests/test_misc.rs b/tests/test_misc.rs index 2904c7a0a..43c4f87df 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -1,35 +1,12 @@ -use rmisc::{add, string_to_tuple}; -//use std::process::{Command, Stdio}; +//Tests that functions in rust are working as expected -#[test] -fn test_add() { - let result = add(2, 3); - - assert_eq!(result, 5); -} +use rmisc::{string_to_tuple}; #[test] fn test_string_to_tuple() { + /*Tests function string to tuple*/ let in_str = "a, b, c".to_string(); let result = string_to_tuple(in_str); assert_eq!(result, vec!["a", "b", "c"]) } -/* -#[test] -fn test_misc() { - let status = Command::new("python3") - .args(["-m", "pytest", "tests/test_rust.py", "-v"]) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) - .status() - .expect("Failed to run pytest"); - - if status.success() { - println!("Tests passed!"); - } else { - eprintln!("Tests failed!"); - std::process::exit(1); - } -} -*/ diff --git a/tiatoolbox/rmisc.pyi b/tiatoolbox/rmisc.pyi index 968ffd9af..e6dde435b 100644 --- a/tiatoolbox/rmisc.pyi +++ b/tiatoolbox/rmisc.pyi @@ -1,12 +1,23 @@ +from collections.abc import Callable +from types import ModuleType from typing import Any import numpy as np -from numpy.typing import NDArray +from numpy.typing import NDArray, npt from shapely.geometry import Polygon from tiatoolbox.annotation.storage import Annotation -def add(a: int, b: int) -> int: ... +def string_to_tuple(in_str: str) -> list[str]: ... +def semantic_segmentations_as_qupath_json( + layer_list: list[Any], + preds: npt.NDArray[np.generic], + scale_factor: tuple[float, float], + class_dict: dict[Any, Any], + class_colours: dict[Any, Any], + cv2: ModuleType, + poly_geo_fun: Callable[..., object], +) -> list[Any]: ... def json_dump_python_object( save_path: str, obj: object, diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/lib.rs index 42d391cba..006d695db 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/lib.rs @@ -17,10 +17,6 @@ enum StringOrFloat { String(String), Float(f64), } -#[pyfunction] -pub fn add(a: i32, b: i32) -> i32 { - a + b -} #[pyfunction] pub fn string_to_tuple(in_str: String) -> Vec { @@ -38,7 +34,7 @@ pub fn string_to_tuple(in_str: String) -> Vec { } #[pyfunction] -pub fn semantic_segmentations_as_qupath_json( +fn semantic_segmentations_as_qupath_json( py: Python<'_>, layer_list: &Bound<'_, PyList>, preds: &Bound<'_, PyAny>, @@ -122,10 +118,6 @@ fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResul serde_json::to_writer_pretty(&mut writer, &value) .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; - /* - serde_json::to_writer(&mut writer, &value) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; - */ Ok(()) } @@ -341,7 +333,7 @@ fn rust_contrast_enhancer(img: Array3, low_p: u8, high_p: u8) -> Array3 } #[pyfunction] -pub fn contrast_enhancer<'py>( +fn contrast_enhancer<'py>( py: Python<'py>, img: PyReadonlyArray3<'py, u8>, low_p: u8, @@ -353,7 +345,6 @@ pub fn contrast_enhancer<'py>( #[pymodule] fn rmisc(m: &Bound<'_, PyModule>) -> PyResult<()> { - m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(contrast_enhancer, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_qupath_json, m)?)?; m.add_function(wrap_pyfunction!(patch_predictions_as_annotations, m)?)?; diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 5c9a85f05..f16682a26 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -427,12 +427,10 @@ def contrast_enhancer(img: np.ndarray, low_p: int = 2, high_p: int = 98) -> np.n """ # check if image is not uint8 - # check if image is not uint8 - dimension_for_rust = 3 - if img.dtype != np.uint8: msg = "Image should be uint8." raise AssertionError(msg) + dimension_for_rust = 3 if img.ndim == dimension_for_rust: return rmisc.contrast_enhancer(img, low_p, high_p) img_out = img.copy() From 4c6e23629021c92177a6a762160b54100ff33d2f Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:07:07 +0100 Subject: [PATCH 072/112] Improved formatting --- tests/test_misc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_misc.rs b/tests/test_misc.rs index 43c4f87df..7c021f963 100644 --- a/tests/test_misc.rs +++ b/tests/test_misc.rs @@ -1,6 +1,6 @@ //Tests that functions in rust are working as expected -use rmisc::{string_to_tuple}; +use rmisc::string_to_tuple; #[test] fn test_string_to_tuple() { From e11538f43ea67543f9513702ccf89248be3e9c47 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:15:17 +0100 Subject: [PATCH 073/112] Altered misc.py to include rust code --- tiatoolbox/utils/misc.py | 148 ++++++++++----------------------------- 1 file changed, 37 insertions(+), 111 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index f16682a26..1e584f2fa 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -937,7 +937,7 @@ def string_to_tuple(in_str: str) -> tuple[str, ...]: Return a tuple of strings by splitting in_str at ','. """ - return tuple(substring.strip() for substring in in_str.split(",")) + return tuple(rmisc.string_to_tuple(in_str)) def ppu2mpp(ppu: int, units: str | int) -> float: @@ -1230,43 +1230,35 @@ def patch_predictions_as_annotations( classes_predicted: list, labels: list, *, - verbose: bool = True, + _verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" - annotations = [] - tqdm_loop = tqdm( - patch_coords, - leave=False, - desc="Converting outputs to AnnotationStore.", - disable=not verbose, + if len(class_probs) == 0: + class_probs = np.empty((0, 2)) + if len(patch_coords) == 0: + patch_coords = np.empty((0, 2)) + return rmisc.patch_predictions_as_annotations( + Annotation, + Polygon, + preds, + "labels" in keys, + "probabilities" in keys, + class_dict, + np.array(class_probs).astype("float"), + np.array(patch_coords).astype("float"), + classes_predicted, + labels, ) - for i, _ in enumerate(tqdm_loop): - if "probabilities" in keys: - props = { - f"prob_{class_dict[j]}": class_probs[i][j] for j in classes_predicted - } - else: - props = {} - if "labels" in keys: - props["label"] = class_dict[labels[i]] - if len(preds) > 0: - props["type"] = class_dict[preds[i]] - annotations.append(Annotation(Polygon.from_bounds(*patch_coords[i]), props)) - - return annotations - def patch_predictions_as_qupath_json( preds: list | np.ndarray, class_dict: dict, patch_coords: list | np.ndarray, *, - verbose: bool = True, + _verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" - features = [] - # pick a color for each class based on the class index, using a colormap num_classes = len(class_dict) cmap = plt.colormaps["tab20"].resampled(num_classes) class_colours = { @@ -1278,36 +1270,9 @@ def patch_predictions_as_qupath_json( for class_idx in class_dict } - tqdm_loop = tqdm( - range(np.asarray(patch_coords).shape[0]), - leave=False, - desc="Converting outputs to QuPath JSON.", - disable=not verbose, + features = rmisc.patch_predictions_as_qupath_json( + class_colours, preds, class_dict, np.array(patch_coords).astype("float") ) - - for i in tqdm_loop: - class_idx = int(preds[i]) - class_name = class_dict[class_idx] - polygon_geo = Polygon.from_bounds(*patch_coords[i]) - polygon_feat = mapping(polygon_geo) - - feature = { - "type": "Feature", - "id": f"patch_{i}", - "geometry": polygon_feat, - "properties": { - "classification": { - "name": class_name, - "color": class_colours[class_idx], - } - }, - "objectType": "annotation", - "name": class_name, - "class_value": class_idx, - } - - features.append(feature) - return {"type": "FeatureCollection", "features": features} @@ -1507,6 +1472,20 @@ def dict_to_store_semantic_segmentor( ) +def poly_geo_func(coords: list) -> list: + """Used solely for function semantic_segmentation_as_qupath_json.""" + geom = make_valid_poly( + feature2geometry( + { + "type": "Polygon", + "coordinates": coords, + } + ), + (0, 0), + ) + return mapping(geom) + + def _semantic_segmentations_as_qupath_json( layer_list: list, preds: da.Array, @@ -1514,12 +1493,9 @@ def _semantic_segmentations_as_qupath_json( class_dict: dict, save_path: Path | None = None, *, - verbose: bool = True, + _verbose: bool = True, ) -> dict | Path: """Helper function to save semantic segmentation as QuPath json.""" - features: list = [] - - # color map for classes num_classes = len(class_dict) cmap = plt.colormaps["tab20"].resampled(num_classes) class_colours = { @@ -1531,60 +1507,10 @@ def _semantic_segmentations_as_qupath_json( for class_idx in class_dict } - tqdm_loop = tqdm( - layer_list, - leave=False, - desc="Converting outputs to QuPath JSON.", - disable=not verbose, + features = rmisc.semantic_segmentations_as_qupath_json( + layer_list, preds, scale_factor, class_dict, class_colours, cv2, poly_geo_func ) - for type_class in tqdm_loop: - class_id = int(type_class) - class_label = class_dict[class_id] - - # binary mask for this class - layer = da.where(preds == type_class, 1, 0).astype("uint8").compute() - - contours, _ = cv2.findContours(layer, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE) - - contours = cast("list[np.ndarray]", contours) - - # Convert contours to polygons - for cnt in contours: - if cnt.shape[0] < 3: # noqa: PLR2004 - continue - - # scale coordinates - cnt_scaled: np.ndarray = cnt.squeeze(1).astype(float) - - geom = make_valid_poly( - feature2geometry( - { - "type": "Polygon", - "coordinates": scale_factor * np.array([cnt_scaled]), - } - ), - (0, 0), - ) - poly_geo = mapping(geom) - - feature = { - "type": "Feature", - "geometry": poly_geo, - "id": f"class_{class_id}_{len(features)}", - "properties": { - "classification": { - "name": class_label, - "color": class_colours[class_id], - } - }, - "objectType": "annotation", - "name": class_label, - "class_value": class_id, - } - - features.append(feature) - qupath_json = {"type": "FeatureCollection", "features": features} # if a save directory is provided, then dump JSON into a file From 55c8e30b905596b6ecef99aec86eaaf02d4f56cc Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:25:56 +0100 Subject: [PATCH 074/112] Altered misc.py for type checking --- tiatoolbox/utils/misc.py | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 1e584f2fa..555f090f1 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1229,8 +1229,6 @@ def patch_predictions_as_annotations( patch_coords: list | np.ndarray, classes_predicted: list, labels: list, - *, - _verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" if len(class_probs) == 0: @@ -1240,7 +1238,7 @@ def patch_predictions_as_annotations( return rmisc.patch_predictions_as_annotations( Annotation, Polygon, - preds, + np.array(preds).astype("float"), "labels" in keys, "probabilities" in keys, class_dict, @@ -1255,8 +1253,6 @@ def patch_predictions_as_qupath_json( preds: list | np.ndarray, class_dict: dict, patch_coords: list | np.ndarray, - *, - _verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" num_classes = len(class_dict) @@ -1271,7 +1267,10 @@ def patch_predictions_as_qupath_json( } features = rmisc.patch_predictions_as_qupath_json( - class_colours, preds, class_dict, np.array(patch_coords).astype("float") + class_colours, + np.array(preds).astype("float"), + class_dict, + np.array(patch_coords).astype("float"), ) return {"type": "FeatureCollection", "features": features} @@ -1458,7 +1457,6 @@ def dict_to_store_semantic_segmentor( scale_factor=scale_factor, class_dict=class_dict, save_path=save_path, - verbose=verbose, ) return _semantic_segmentations_as_annotations( @@ -1492,8 +1490,6 @@ def _semantic_segmentations_as_qupath_json( scale_factor: tuple[float, float], class_dict: dict, save_path: Path | None = None, - *, - _verbose: bool = True, ) -> dict | Path: """Helper function to save semantic segmentation as QuPath json.""" num_classes = len(class_dict) @@ -1634,6 +1630,7 @@ def dict_to_store_patch_predictions( for each patch. """ + _ = verbose if "coordinates" not in patch_output: # we cant create annotations without coordinates msg = "Patch output must contain coordinates." @@ -1678,10 +1675,7 @@ def get_value_for_key( if output_type.lower() == "qupath": qupath_json = patch_predictions_as_qupath_json( - preds=preds, - class_dict=class_dict, - patch_coords=patch_coords, - verbose=verbose, + preds=preds, class_dict=class_dict, patch_coords=patch_coords ) if save_path: @@ -1698,7 +1692,6 @@ def get_value_for_key( patch_coords.astype(float), classes_predicted, cast("list", labels), - verbose=verbose, ) store = SQLiteStore() From 9f4b8798fec2870fa37f4d73e1621c2801a56bc6 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:27:20 +0100 Subject: [PATCH 075/112] Altered misc.py for type checking --- tiatoolbox/utils/misc.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 555f090f1..396b68fa9 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -1229,8 +1229,11 @@ def patch_predictions_as_annotations( patch_coords: list | np.ndarray, classes_predicted: list, labels: list, + *, + verbose: bool = True, ) -> list: """Helper function to generate annotation per patch predictions.""" + _ = verbose if len(class_probs) == 0: class_probs = np.empty((0, 2)) if len(patch_coords) == 0: @@ -1253,8 +1256,11 @@ def patch_predictions_as_qupath_json( preds: list | np.ndarray, class_dict: dict, patch_coords: list | np.ndarray, + *, + verbose: bool = True, ) -> dict: """Helper function to generate QuPath JSON per patch predictions.""" + _ = verbose num_classes = len(class_dict) cmap = plt.colormaps["tab20"].resampled(num_classes) class_colours = { @@ -1457,6 +1463,7 @@ def dict_to_store_semantic_segmentor( scale_factor=scale_factor, class_dict=class_dict, save_path=save_path, + verbose=verbose, ) return _semantic_segmentations_as_annotations( @@ -1490,8 +1497,11 @@ def _semantic_segmentations_as_qupath_json( scale_factor: tuple[float, float], class_dict: dict, save_path: Path | None = None, + *, + verbose: bool = True, ) -> dict | Path: """Helper function to save semantic segmentation as QuPath json.""" + _ = verbose num_classes = len(class_dict) cmap = plt.colormaps["tab20"].resampled(num_classes) class_colours = { @@ -1630,7 +1640,6 @@ def dict_to_store_patch_predictions( for each patch. """ - _ = verbose if "coordinates" not in patch_output: # we cant create annotations without coordinates msg = "Patch output must contain coordinates." @@ -1675,7 +1684,10 @@ def get_value_for_key( if output_type.lower() == "qupath": qupath_json = patch_predictions_as_qupath_json( - preds=preds, class_dict=class_dict, patch_coords=patch_coords + preds=preds, + class_dict=class_dict, + patch_coords=patch_coords, + verbose=verbose, ) if save_path: @@ -1692,6 +1704,7 @@ def get_value_for_key( patch_coords.astype(float), classes_predicted, cast("list", labels), + verbose=verbose, ) store = SQLiteStore() From 05f9c192fa7e710dbac67d3e83d541007ef0f80f Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 11:45:14 +0100 Subject: [PATCH 076/112] Corrected to speed up rust code --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 75dd6e77c..06edd3b82 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -304,4 +304,3 @@ python_version = "3.12" python-source = "." include = ["tiatoolbox/**/*"] module-name = "tiatoolbox.rmisc" -editable-profile = "dev" From 015f1575adcd250c5976a1e506c677e616081e45 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:00:05 +0100 Subject: [PATCH 077/112] Corrected to allow for codecov to run --- pyproject.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 06edd3b82..4d6335c91 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -304,3 +304,5 @@ python_version = "3.12" python-source = "." include = ["tiatoolbox/**/*"] module-name = "tiatoolbox.rmisc" +#Delete the following line when releasing, only to be used to run codecov +editable-profile = "dev" From 25035807309b6c237cd02f6b3e3399623e94f4d3 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:04:21 +0100 Subject: [PATCH 078/112] Removed slow rust code from misc --- tiatoolbox/utils/misc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 396b68fa9..10a1b98ba 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -937,7 +937,7 @@ def string_to_tuple(in_str: str) -> tuple[str, ...]: Return a tuple of strings by splitting in_str at ','. """ - return tuple(rmisc.string_to_tuple(in_str)) + return tuple(substring.strip() for substring in in_str.split(",")) def ppu2mpp(ppu: int, units: str | int) -> float: From f72ef17604b3291d4d420e631171fc40ac09cbd0 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:06:28 +0100 Subject: [PATCH 079/112] Updated benchmarking --- ...ring_misc_functions_in_rust_v_python.ipynb | 314 +- benchmarks/example.txt | 10002 ++++++++++++++++ 2 files changed, 10076 insertions(+), 240 deletions(-) create mode 100644 benchmarks/example.txt diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index c53ad5ee7..233cd213d 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -3,8 +3,7 @@ { "cell_type": "markdown", "metadata": { - "id": "aqPkpRk-pT5q", - "jp-MarkdownHeadingCollapsed": true + "id": "aqPkpRk-pT5q" }, "source": [ "# Benchmarking Misc in Rust\n", @@ -19,6 +18,40 @@ "\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rust is a programming language that is proven to be faster than Python, especially for CPU bound operations and processing large amounts of data.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook compares the execution time of several function in two forms.\n", + "One the original python version\n", + "Two the modified function where some or all of the code has been moved to Rust\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It tests how long it runs in Python and in Rust using different sized inputs. Each input size has multiple tests and the average of all the tests is taken to minimise the impact of any outliers. The x axis shows the size of the input and the y axis shows the average time taken of each input of size x.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook will show which functions benefitted being moved into Rust.\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": { @@ -181,7 +214,7 @@ "while i <= maxarraysize:\n", " python_times = np.empty(0)\n", " rust_times = np.empty(0)\n", - " for _j in range(10):\n", + " for _j in range(5):\n", " rng = np.random.default_rng()\n", " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", " start_time = time.time()\n", @@ -192,6 +225,7 @@ " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", + " assert np.allclose(python_result, rust_result, atol=1)\n", " sizeofarray.append(i)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " i *= 10" @@ -204,7 +238,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -329,7 +363,7 @@ " return rmisc.patch_predictions_as_annotations(\n", " Annotation,\n", " Polygon,\n", - " preds,\n", + " np.array(preds).astype(\"float\"),\n", " \"labels\" in keys,\n", " \"probabilities\" in keys,\n", " class_dict,\n", @@ -408,6 +442,7 @@ " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", + " assert python_object == rust_object\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " num_patches *= 10\n", @@ -421,7 +456,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -554,7 +589,10 @@ " }\n", "\n", " features = rmisc.patch_predictions_as_qupath_json(\n", - " class_colours, preds, class_dict, np.array(patch_coords).astype(\"float\")\n", + " class_colours,\n", + " np.array(preds).astype(\"float\"),\n", + " class_dict,\n", + " np.array(patch_coords).astype(\"float\"),\n", " )\n", " return {\"type\": \"FeatureCollection\", \"features\": features}" ] @@ -580,8 +618,8 @@ "sizeofarray = []\n", "timings = []\n", "timings = []\n", - "num_patches = 1\n", - "num_classes = 1\n", + "num_patches = 10\n", + "num_classes = 10\n", "max_patches = 1000\n", "while num_patches <= max_patches:\n", " python_times = np.empty(0)\n", @@ -615,6 +653,7 @@ " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", + " assert python_object == rust_object\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " num_patches *= 10\n", @@ -628,7 +667,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGxCAYAAACKvAkXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZsVJREFUeJzt3XdUFGfbBvCL3osCUgRFARFpgr0kttiwN2zpMVVjotEkJq9JTDNGTWJJb1+KvcQae9TYG0ixI703pdfd5/tjcNe1xAWBAfb6neM5r8/MLPfuS+By7pm59YQQAkREREQ6RF/uAoiIiIjqGwMQERER6RwGICIiItI5DEBERESkcxiAiIiISOcwABEREZHOYQAiIiIincMARERERDrHUO4CGiqlUonU1FRYWVlBT09P7nKIiIhIC0IIFBQUwMXFBfr69z/PwwB0H6mpqXBzc5O7DCIiIqqBpKQkuLq63nc7A9B9WFlZAZA+QGtra5mrISIiIm3k5+fDzc1N9Xv8fhiA7uNW28va2poBiIiIqJF50OUrvAiaiIiIdA4DEBEREekcBiAiIiLSObwG6CEolUqUl5fLXYZOMjIygoGBgdxlEBFRI8UAVEPl5eWIi4uDUqmUuxSdZWtrCycnJz6niYiIqo0BqAaEEEhLS4OBgQHc3Nz+80FLVPuEECguLkZmZiYAwNnZWeaKiIiosWEAqoHKykoUFxfDxcUF5ubmcpejk8zMzAAAmZmZaNGiBdthRERULTx1UQMKhQIAYGxsLHMluu1W+KyoqJC5EiIiamwYgB4Crz2RFz9/IiKqKQYgeihffPEFNm/eLHcZRERE1cJrgHTIr7/+imPHjgGQbiN3c3PDmDFj4OPjo9XxK1asQIsWLTBx4kTV2t9//43OnTtj7NixdVIzERFRXeAZIB1y+PBhHDlyBN27d0dAQACio6Ph7++Pv/76S6vj9+zZgxMnTtRxlURERHWPZ4B0jLOzM6ZNmwYAePnll1FYWIgPP/wQ5ubmOHz4MD799FON/VetWoWUlBQ4ODggMjIS8fHxquM//vhj1X6HDh3C/v37oVAoMGHCBAQHB2u8TnR0NNatW4fc3FwEBATgySefVN3JBUitNHd3dzRv3vw/X4eIiBq/iKSbiE7Nw9RurWWrgWeAdJyfnx+SkpLQtm1bLFy4ENHR0aptSqUS8+bNg6GhITw8PNCsWTM4Ozuje/fu6N69uyrA/Pnnn/jggw9gZ2eHnJwcdO/eHWFhYarX2bVrF4KDg5GWlgZ3d3esXLkSvXv31niK9t9//42ZM2f+5+sQEVHjJoTAL0fjMP6745i/JRpn43Nlq4VngGqBEAIlFQpZvraZkUGN74ZSKBQ4cOAA/Pz84OXlhUcffRS//PILvvjiCwDAvn37kJ6ejieeeAIODg5wc3ODp6en6gzQLc2bN8eBAwdUz+KJiYnBb7/9huDgYAghMHPmTMycORNLliwBADz//PNo06YNfvjhB8yYMUOr1yEiosYtr7gCczdGYO/FDADAUD8neDlayVYPA1AtKKlQoMN7e2T52hc/HAxzY+3/b7xy5QqmTZuGyspKnDx5Enl5edi5cycAKZjMnj0bixYtgpGREX755RcMHz4cDg4O//ma/fr103gQobe3N5KTkwEAKSkpiImJweTJk1XbbW1tMWzYMBw+fFgjAP3X6xARUeMVnngDM1aHI+VmCYwN9PG/4T54ontrWR9nwhaYjrG2tkb37t3Rr18/fP3114iNjVWdYRk/fjwqKiqwfft25ObmYuvWrXj22Wcf+Jq3X8sDAAYGBqqHRd4aV2Fvb6+xj729PTIyMrR+HSIianyEEPjpSCwmfHcCKTdL0Kq5OTa93BNP9nCX/VluPANUC8yMDHDxw8Gyfe3quP0i6DuZmpri8ccfxy+//IKUlBQ0b94cQ4cOVW2vyTerm5sbACAhIQGtW6svdktISECrVq2q/XpERNQ43Cwux5wNkdh/SfrH7jB/Zywc5w9rUyOZK5MwANUCPT29arWhGrLnn38ewcHBuHLlCp566imNllTz5s2Rm1u9C9YcHBzw6KOPYtmyZejduzf09fVx6dIl/P3331i7dm1tl09ERA1AWOINvHpby2v+cB88LnPL605N47c21ZqAgAAEBQXh7NmzeOaZZzS2jRo1Co8//jjKy8thaWmpcRv8f/nmm28waNAgBAcHw9PTE/v378eUKVMwZsyYungLREQkE6nlFYdFuy+jUingbmeOlVOC4dfSRu7S7sIApEOeffZZFBQUPHC/oKAgmJqaol27dhrrY8eOxdmzZxEREYGioiKYmZnhjTfeuOv6nqlTp6KoqEj1d19fX1y7dg3//PMPbty4gfnz5yMwMFDjGG1eh4iIGq4bReWYsyECBy5L134OD3DGwrH+sGogLa876QkhhNxFNET5+fmwsbFBXl4erK2tNbaVlpYiLi4Obdq0gampqUwV1o38/Hy0bt0aX3/9NaZMmSJ3Of+pKf//QETUmJxLyMWrq8ORmlcKY0N9vDe8A6Z2ayVLy+u/fn/fjmeASGXu3LnYt28f2rZti9DQULnLISKiBk6pFPjxSCw+33MFCqVAG3sLrJwSBF+XhtfyuhMDEKkEBweja9euGDp0KAwN+a1BRET3l1tUjjfWn8fBK1kAgJGBLvh0rD8sTRrH74/GUSXVi9sfVkhERHQ/Z+Nz8eqacKRVtbwWjPTFpC5uDeourwdhACIiIiKtKJUC3/17HUv3XoVCKdDW3gIrpwSjg8v9r7VpqBiAiIiI6IFyCsswe30EDl+VWl6jOrrgkzGNp+V1p8ZZNREREdWb03G5mLkmHOn5pTCpanlNbGQtrzsxABEREdE9KZUC3x6+ji/2VbW8HCzw9ZRg+Dg3vpbXnRiAiIiI6C45hWWYtT4C/1a1vMYEtcTHo/1g0UhbXndqGu+CiIiIas2p2BzMXBuOjPwymBrp48ORfpjQ2bVRt7zuxACkQ86ePYv4+HgAgJGREVxdXREQEAAjo9p7THlKSgrOnTuHkSNH1tprEhFR/VAqBb45FIMv9l2FUgAeDhb4ZmoneDtZyV1arWMA0iErV67Ezp070adPH1RWViI8PByGhobYtm0bfH19a+VrnDhxAtOmTcPNmzdr5fWIiKh+ZBeWYda68zhyLRsAMDa4JT4a1XRaXndqmu+K7svX1xcbN24EAJSXl6Nnz5547bXXsH//fgBATEwM4uLiMHDgQNUxGRkZOHbsGMaOHatay8/PR1hYGADpCdLW1tbIysrCyZMnUVFRofoa7du3h5+fX329PSIiqoET13Pw2tpwZBZILa+PRvlhQmc3ucuqUwxAOszY2BiDBg3Cjz/+qFrbsWMHfvrpJ0RHR6vWwsPDERoaisrKSgDAwYMHMW7cOHh7e8PS0hLXr1/H8uXL0aZNGxw7dgwVFRVYu3YtAGDMmDEMQEREDZRCKfD1wRh8tV9qeXm1sMTXU4PRzrHptbzuxABUG4QAKorl+dpG5sBDXJQWGxsLe3v7ah2zcOFCPPfcc1i8eDEAIC8vD6dOnYKvry/eeOMNTJs2TXUGiIiIGqasgjK8vi4cx2JyAAATOrliwShfmBvrRjTQjXdZ1yqKgU9d5Pna76QCxhZa756VlYWNGzeisrISp06dwubNm/HHH39U60uamJggISEBJSUlMDMzg42NDQYNGlTdyomISCbHY7Lx2rrzyCoog5mRAT4a7YfxnVzlLqteMQDpmMzMTKxduxZlZWU4fvw4hg4dijFjxlTrNT7//HM8++yzcHBwQK9evTB8+HA8//zzMDU1raOqiYioNiiUAiv+uYZlB65BCKCdoyW+nhIMLx1oed2pQQSg1NRUZGZmwtPTE5aWlg99TFxcHDIyMjTWzM3NERAQUGs1azAyl87EyMHIvFq7334RdEZGBjp37oy3334bX3zxBQBAX18fSqVS45jS0lKNv/v4+ODEiRNIS0vDP//8g08++QR79uzBjh07HuKNEBFRXcosKMXra8/j+HWp5RXa2RULRvrBzNhA5srkIWsAKisrw5NPPolt27bB1dUVqampWLJkCV5++eWHOmbRokXYsGEDvLy8VGseHh5YtWpV3bwRPb1qtaEaCkdHRyxduhRTpkzB888/Dx8fH7Rs2RIpKSkoKyuDiYkJAODw4cMax6WlpcHZ2RnOzs6YOnUqlEolXnvtNQCApaUlysrK6v29EBHR/R2LycZra88ju7AM5sYG+Hi0H8YG61bL606yBqCPPvoIR48eRUxMDFq2bIlNmzZhwoQJ6Ny5M7p06fJQx/Tr148X4mohNDQUS5Yswbx587BlyxYMHDgQpqammDRpEsaMGYOzZ89i/fr1Gsc8/vjjcHNzQ69evaBQKPDll19i3LhxAAB/f38oFArMnz8fgYGBvA2eiEhGCqXAsgPXsOIfqeXl7WiFr6cGw7OFdt2Wpkxfzi/+888/Y9q0aWjZsiUAYNy4cejQoQN++eWXhz6mvLwckZGRSEhIgBCi7t5EI9KlSxf06dPnrvWvvvoKRkZGSEtLg7W1NU6dOgVPT08cOnQI3t7e2LZtmyrgAMCePXvQv39/nD59GuHh4Zg/fz6+/fZbAEDLli2xa9cuZGdnY926dYiIiKi390dERGqZ+aWY+tNJLK+63mdSFzdsmd6L4aeKbGeAUlNTkZ6efteZnm7duiE8PPyhj/n7778RExODjIwMWFlZ4fvvv8fgwYNr9000MtOnT7/nes+ePdGzZ0/V393d3VW3uN+ybt061f82NDTEk08+iSeffPKerzdgwAAMGDCgFiomIqKaOHItC7PWnUd2YTnMjQ3w6Rh/jA5qKXdZDYpsZ4Byc3MBAM2bN9dYt7OzQ05OzkMdM3DgQCQnJ+PixYvIyMjAuHHjMG7cOMTGxt63nrKyMuTn52v8ISIiakwqFUos3XsFT/5yGtmF5WjvZIXtr/Zm+LkH2QLQrQGcd14wW1JSct/hnNoeM27cODg5OQGQzlYsWrQIhoaG2Lp1633rWbhwIWxsbFR/3Nya9iPAiYioacnIL8XUn05hxT8xEAKY3LUVtkzvBQ8HtrzuRbYA5ObmBn19faSmat4+npqaitatW9faMYAUguzt7ZGSknLffebNm4e8vDzVn6SkpGq8GyIiIvn8ezULIcuO4FRcLiyMDbBsUkcsHOsPUyPdvMVdG7IFIHNzc3Tv3h3bt29XrRUXF2P//v0a14/ExsYiMjJS62OEEHc9tyYmJgbx8fH/OfHcxMQE1tbWGn+IiIgaskqFEov3XMZTv55GTlE5fJytsf3V3hjVkS2vB5H1NviPP/4YgwYNwvz589GjRw8sX74czZs3xwsvvKDa59NPP8XJkydVwzkfdExFRQU6deqEF198Eb6+vkhMTMTHH3+MwMBATJ48WZb3SUREVNvS80oxc004TsdL18dO7dYK84d34FkfLcl6G3y/fv1w4MABXLlyBYsWLYKnpyeOHTumcfbFw8MDgYGBWh9jbGyMPXv2IDk5GZ999hl27dqF119/HSdOnKj1UQ28vV5e/PyJSFcdupKJkOVHcDo+F5YmhlgxOQifjGHLqzr0BH+L3FN+fj5sbGyQl5d3VzusoqICMTExcHFxgY2NjUwVUk5ODjIzM9GuXTsYGPA/eiJq+ioVSizddxXfHroOAPB1scbKKcFoY9/4phHUlf/6/X27BjELrLExNDSEubk5srKyYGRkBH19WU+k6RwhBIqLi5GZmQlbW1uGHyLSCWl5JZi5Jhxn4m8AAJ7o3hrvDvPhWZ8aYgCqAT09PTg7OyMuLg4JCQlyl6OzbG1tVY87ICJqyg5ezsTs9edxo7gCliaGWDQuAMMCnOUuq1FjAKohY2NjeHl5oby8XO5SdJKRkRHP/BBRk1ehUGLJ3iv4/rD0IF+/ltZYOTkY7mx5PTQGoIegr69f6xdWExERAUDqzRK8uiYc5xKkltdTPVrjnWE+MDHkP/5qAwMQERFRA3PgUgbe2BCBm8UVsDIxxKLxAQjxZ8urNjEAERERNRAVCiWW7LmC7/+VWl4BrjZYOTkYrezMZa6s6WEAIiIiagBSbpbg1dVhCEu8CQB4uqc75oW0Z8urjjAAERERyWz/RanllVdSAStTQyweH4Ahfmx51SUGICIiIpmUVyrx+e7L+OloHAAg0NUGK6cEw605W151jQGIiIhIBsk3ijFjdTjOJ90EADzbqw3eHtoexoZ8uG59YAAiIiKqZ3svpGPOhgjkl1bC2tQQiycEYrAvH+xanxiAiIiI6kl5pRKLdl/Gz7daXm62WDk5iC0vGTAAERER1YOk3GLMWBOOiKqW17TebfDmELa85MIAREREVMd2R6dj7sYIFJRWwsbMCEsmBGJgB0e5y9JpDEBERER1pLxSiYW7LuHXY/EAgKBWtlgxOQiuzdjykhsDEBERUR1IzCnGjDVhiEzOAwC88GhbzB3sDSMDtrwaAgYgIiKiWrY7Og1zN0aioLQStuZGWDohEAN82PJqSBiAiIiIaklZpQKf7ryE304kAACCW9lixZRgtLQ1k7kyuhMDEBERUS1IyCnCjNXhiEqRWl4v9mmLOYPY8mqoGICIiIge0t9RaXhrYyQKyqSW1xehgejfni2vhowBiIiIqIZKKxT49O9L+L2q5dW5dTMsnxwEF7a8GjwGICIiohqIzy7C9NVhuJCaDwB4ua8HZg9sx5ZXI8EAREREVE07IlPx9qYoFJZVopm5Eb6Y2BH9vFvIXRZVAwMQERGRlkorFPh450X8eTIRANDFXWp5Oduw5dXYMAARERFpIS67CNNXheFimtTyeqWq5WXIllejxABERET0ANsiUjFvUySKyhVobmGMLyd2RJ92DnKXRQ+BAYiIiOg+SisU+HDHRaw+JbW8urZpjuWTguBkYypzZfSwGICIiIju4XpWIaavCsPl9ALo6QEz+nnitQFebHk1EQxAREREd9h6PgXvbI5CUbkCdlUtr0fZ8mpSGICIiIiqlFYosGD7Baw5nQQA6NamOZZPDoKjNVteTQ0DEBEREYCYzELMWK1ueb3azxMz2fJqshiAiIhI520JT8E7f0WhuFwBe0tjfDUxCL297OUui+oQAxAREemsknIFPth2AevOSi2vHm3tsGxSR7Rgy6vJYwAiIiKdFJNZgOmrwnElQ2p5zezvhZkDvGCgryd3aVQPGICIiEjnbDqXjP9tiUZJhQL2liZYNqkjenmy5aVLGICIiEhnlJQr8N7WaGw4lwwA6OVphy8ndkQLK7a8dA0DEBER6YRrGQWYvjoMVzMKoa8HvP5YO0zv58mWl45iACIioiZv47lkzK9qeTlYSS2vnh5seekyBiAiImqyissrMX/LBWwKk1pevT3t8eXEjnCwMpG5MpIbAxARETVJVzMK8MqqMMRkSi2vWY+1wytseVEVBiAiImpShBDYcC4Z722NRmmFEi2sTLB8chC6t7WTuzRqQBiAiIioySgqq8T8LdHYHJ4CAHjES2p52Vuy5UWaGICIiKhJuJJegFdWncP1rCLo6wFvDPLGy308oM+WF90DAxARETVqQgisP5uE97ZeQFmlEo7WJlg+KQjd2PKi/8AAREREjVZRWSXe/SsKW86nAgAebeeAL0MDYceWFz0AAxARETVKl9LyMX11GGKzimCgr4c3BrXDS4+y5UXaYQAiIqJGRQiBtWeS8ME2qeXlZG2KFVOC0MW9udylUSPCAERERI1GYVXLa2tVy6uftwOWhnZEcwtjmSujxoYBiIiIGoWLqfmYsToMsdlSy2vuYG+88EhbtryoRhiAiIioQRNCYPXpRCzYfhHllUo425hixeQgdGbLix6C7AEoMTERv/32GzIyMuDv74+nn34aJib/ffV+dY45cuQIfvvtNwwcOBATJ06si7dARER1pKC0AvM2R2FHZBoAoH/7Flg6IRDN2PKih6Qv5xe/ePEiAgMDERYWBjc3Nyxfvhz9+/dHRUVFrRyTlZWFJ554Alu2bMGJEyfq8q0QEVEti07Jw4gVR7EjMg2G+np4J6Q9fnqyM8MP1Qo9IYSQ64uPGDECxcXF2L9/P/T09JCWloY2bdrgm2++wbPPPvtQxwghMGzYMPTv3x9//vkn+vbti6+++krr2vLz82FjY4O8vDxYW1s/7FslIiItCSHw56lEfLRDanm52JhixZRgdGrdTO7SqBHQ9ve3bGeAysvLsWfPHkyaNAl6etIFbM7OzujXrx+2b9/+0McsXboUpaWleOONN+r2jRARUa0pKK3AjDXhmL8lGuWVSjzm0wJ/v/YIww/VOtmuAUpMTERFRQXc3d011tu0aYMjR4481DFnzpzBkiVLcPbsWVVQepCysjKUlZWp/p6fn6/dGyEioloRnZKH6avDkJBTDEN9Pbw9tD2e691G65/jRNUh2xmgkpISAICVlZXGupWVlWpbTY7Jz8/H5MmTsWLFCri6umpdz8KFC2FjY6P64+bmpvWxRERUc0II/H4iHmO/OY6EnGK0tDXD+pd6YNojbRl+qM7IdgboVl/uxo0bGuu5ubn37dlpc8zq1auRk5ODPXv2YM+ePQCApKQk7N+/H9OmTcMPP/wAff27c9+8efMwe/Zs1d/z8/MZgoiI6lh+aQXe3hSJv6PSAQCP+ThiyYQA2JrzQmeqW7IFIDc3N1hbW+PixYsYOnSoav3ChQvw8/Or8TGPPvooFi9erHHc3r174ezsjO7du9/3XxMmJiYPvP2eiIhqT1Sy1PJKzC2GkYEe3h7qg2d7ufOsD9ULWe8Ce+GFF3Ds2DGcPn0aFhYWOHPmDLp164adO3eqAs5vv/2G2NhYLFiwQOtj7tSxY0feBUZE1EBILa8EfLLzEsoVSrg2M8PKKcHo6GYrd2nUBDT4u8AA4NNPP4WhoSECAwMxduxYPPbYY3j55Zc1gsyRI0ewadOmah1DREQNU15JBV7+Mwzvb7uAcoUSgzo4YuerjzD8UL2T9QwQAFRUVODgwYOqpzp37NhRY/vRo0eRmZmJsWPHan3Mnf766y9VC0xbPANERFS7IpJuYsaaMCTllsDIQA/vhPjg6Z5seVHt0vb3t+wBqKFiACIiqh1CCPx6LB4Ld11ChULArbkZVk4ORiDP+lAd0Pb3t+yzwIiIqOnKK67A3I0R2HsxAwAwxNcJi8YHwMbMSObKSNcxABERUZ04n3QTM1aHIflGCYwN9PHuMB882aM1W17UIDAAERFRrRJC4OejcVi0+zIqFAKtmpvj6ynB8He1kbs0IhUGICIiqjU3i8sxZ0Mk9l+SWl4h/k74bFwArE3Z8qKGhQGIiIhqRVjiDby6OhwpN6WW1/+G++CJ7mx5UcPEAERERA/lVsvrs12XUakUaG0ntbz8WrLlRQ0XAxAREdWY1PKKwP5LmQCAYQHO+GysP6zY8qIGjgGIiIhq5FzCDby6OgypeaUwNtTHe8M7YGq3Vmx5UaPAAERERNWiVAr8eCQWi/dcQaVSwN3OHCvZ8qJGhgGIiIi0dqOoHG9siMA/l6WW14hAF3w6xo8tL2p0GICIiEgr5xJyMWN1ONKqWl4fjPDF5K5ubHlRo8QARERE/0mpFPihquWlUAq0tbfAyinB6ODCOYnUeDEAERHRfeUWlWP2+vM4dCULADAy0AWfjvWHpQl/fVDjxu9gIiK6pzPxuXh1dTjS80thYqiPD0b6YlIXtryoaWAAIiIiDUqlwHf/XsfSvVellpeDBb6eEgwfZ7a8qOlgACIiIpWcwjLMXh+Bw1ellteYoJb4eLQfLNjyoiaG39FERAQAOB2Xi1fXhCEjvwwmhvr4aJQfJnR2ZcuLmiQGICIiHadUCnx7+DqW7r0CpQA8HCzw9dRgtHdiy4uaLgYgIiIdll1YhlnrzuPItWwAwNiglviILS/SAfwOJyLSUSdjczBzTTgyC8pgaqSPD0f5YUIntrxINzAAERHpGIVS4JuDMfhy/1UoBeDZwhLfTA1GO0cruUsjqjcMQEREOiSrQGp5HY2RWl7jO7niw1G+MDfmrwPSLfyOJyLSEcevZ+O1teeRVVAGMyMDfDTaD+M7ucpdFpEsGICIiJo4hVJg5T8xWHZAanl5VbW8vNjyIh3GAERE1IRlFpTi9bXncfx6DgAgtLMrFoz0g5mxgcyVEcmLAYiIqIk6HpONmWvPI7tQanl9MsYPY4PZ8iICGICIiJochVJg+YFrWP7PNQgBeDta4eupQfBswZYX0S0MQERETUhmQSleW3MeJ2KlltekLm54f4QvW15Ed2AAIiJqIo5ey8br68KRXVgOc2Op5TUmiC0vonthACIiauQUSoFl+69ixcEYCAG0d7LCyinB8GxhKXdpRA0WAxARUSOWkV+KmWvCcSouFwAwuWsrvD+iA0yN2PIi+i8MQEREjdS/V7Mwa9155BSVw8LYAJ+O9ceoji3lLouoUWAAIiJqZCoVSny1/xq+PiS1vHycrfH1lCC0dWDLi0hbDEBERI1IRn4pXl0TjtNVLa8p3VrhveFseRFVFwMQEVEjcbiq5ZVb1fJaOC4AIwNd5C6LqFFiACIiauAqFUp8se8qvjl0HQDQwdkaX08NRht7C5krI2q8GICIiBqwtLwSzFwTjjPxNwAAT3RvjXeH+bDlRfSQGICIiBqog1cyMXvdedworoCliSE+G+eP4QFseRHVBgYgIqIGplKhxNJ9V/FtVcvL18UaX08JhjtbXkS1hgGIiKgBSb0ptbzOJkgtryd7tMY7IWx5EdU2BiAiogbin8sZmL0+AjeLK2BlYohF4wMQ4u8sd1lETRIDEBGRzCoUSizZcwXf/xsLAPBvaYOVU4LQ2o4tL6K6wgBERCSjlJsleHV1GMISbwIAnu7pjnkh7WFiyJYXUV1iACIiksmBSxl4Y0NVy8vUEIvHB2CIH1teRPWh2gEoPj4e69evx7///ovk5GQAgJubGx599FGEhoaidevWtV4kEVFTUqFQ4vPdl/HjkTgAQICrDVZODkYrO3OZKyPSHfra7hgbG4vx48fDy8sLf/75JxwdHRESEoKQkBC0aNECv//+Ozw9PTFhwgTExsbWZc1ERI1W8o1ihH5/QhV+nunljg0v9WD4IapnWp8B6tGjB1544QUsWbIE7u7u99wnPj4eP//8M3r06IGMjIzaqpGIqEnYdzEDczZEIK+kAtamhlg8IRCDfZ3kLotIJ+kJIYQ2O+bk5MDOzk6rF63Ovg1Vfn4+bGxskJeXB2tra7nLIaJGrLxSann9dFQ66xPoZouVk4Pg1pxnfYhqm7a/v7U+A/RfgUYIgevXr8PJyQmWlpaNPvwQEdWWpNxizFgTjoikmwCA53q3wVtD2sPYUOsrEIioDtTov8AzZ85g+vTpqr9PmTIFXl5ecHJywpEjR2qtOCKixmzPhXQMW34EEUk3YW1qiB+e6IT5wzsw/BA1ADX6r3DOnDmYMmUKACAyMhK7du3C2bNn8c477+Ddd9+t1mstXrwYLVu2hJGREYKCgnD48OGHPubatWt48skn4ejoCAsLC3Tt2hXbt2+vVl1ERDVVXqnEgu0X8OIf55BfWomObrb4+7VHMIjX+xA1GDUKQOfOnUNwcDAAYN++fRg7diw6deqEmTNn4vz581q/zg8//IAFCxbg559/RnZ2tuqusvj4+Ic65ptvvsHIkSNx6dIlpKenY9y4cRgzZky1aiMiqomk3GJM+O44fj0WDwB4/pE2WP9iD7g24/U+RA2J1hdB387FxQX79u2Dr68v+vbti+eeew5PPPEEkpOT0b17d9XzgR7E29sbQ4YMwbJlywBI1xK1atUKU6dOxWeffVZrxyiVSpiYmOC7777Dc889p1VtvAiaiKprd3Q65m6MQEFpJWzMjLB0QiAe6+Aod1lEOkXb3981OgMUGhqKYcOGISQkBFFRURg+fDgAYPfu3QgJCdHqNXJzc3H16lX06dNHtaanp4e+ffvi+PHjD32MEAKVlZXIzc3FokWLYG1tjYEDB1b3rRIRPVBZpQIfbLuAl/48h4LSSgS1klpeDD9EDVeNRmEsWbIEXl5eSEhIwMKFC9GsWTMAwPXr1/Hee+9p9Rrp6ekAAAcHB431Fi1a4PTp0w99zL59+xASEgKFQgFbW1usXbsWrVq1um89ZWVlKCsrU/09Pz9fq/dBRLotMacY01eHISolDwDw4qNtMWewN4wMeKEzUUNWowBkaGiocRfYLQsXLnzogpRKJfT09B76mEGDBqGyshI3b97E999/j5EjR+LQoUPo0aPHPV9j4cKFWLBgQY3rJiLdsysqDW9ujERBWSVszY3wRWgg+rfnWR+ixkDrf6JMmDABly9ffuB+Fy9exIQJEx64n7OzNPAvMzNTYz0rKwtOTve+U6Imx9ja2uKtt95CQEAAfv311/vWM2/ePOTl5an+JCUlPfA9EJFuKqtU4P2t0Xh5VRgKyirRqXUz/D3zEYYfokZE6zNA3bt3R/fu3REUFIQRI0agU6dOcHR0hBAC6enpOHPmDLZt24aoqCjMnz//ga/XrFkz+Pj44ODBgxg3bhwA6bqdgwcP4qmnnlLtp1QqIYSAgYGB1sfcS1lZGfT175/3TExMYGJios1HQUQ6LCGnCNNXhyE6RWqTv9THA28MaseWF1FjI6ohOztbfPLJJ8Lf31/o6ekJAAKA0NPTEwEBAWLhwoUiOztb69f75ZdfhJmZmdiyZYvIyMgQs2fPFpaWliIxMVG1z3PPPSd8fX21PqawsFCMHj1anDhxQuTl5YmEhAQxd+5cYWhoKI4dO6Z1bXl5eQKAyMvL0/oYImradkSkCr/3dovWb+0QHRfsEf9cypC7JCK6g7a/v6t1DZCdnR3eeecdvPPOO8jLy0NKSgr09PTg4uICGxubaoevZ555BgUFBZg1axYyMjLg7++PvXv3ws3NTbWPgYEBDA0NtT7GwsICL774It555x2Eh4fDwsJC9bDEnj17VrtGIqLSCgU+2XkJf5xMAAB0bt0MK6YEwdnGTObKiKimavQcIF3A5wAREQDEZRdhxuowXEiVWl6v9PXA7IHtYMiWF1GDVKfPAQKAgoICbNq0CYsXL1atXbp0CcxTRNRUbI9IxYgVR3EhNR/NLYzxf890wZtD2jP8EDUBNToDdPnyZQwcOBBKpRKpqamq0PPUU09h8ODBqjlhjRnPABHprtIKBT7acRGrTiUCALq6N8fyyUFwsjGVuTIiepA6PQM0a9Ys1eiL282cORNLliypyUsSETUIsVmFGPPNcaw6lQg9PWBGP0+sfr4bww9RE1OjM0C2traIj4+Hra0t9PT0VGeAioqK0Lx5c40nKjdWPANEpHu2nk/BO5ujUFSugJ2FMb6c2BGPtnN48IFE1GBo+/u7Rk+CFkKoQs7tT2COjY2t0d1gRERyKq1QYMH2i1hzWmp5dWsjtbwcrXnWh6ipqlELbNCgQfj8888BqANQZmYmZsyYgaFDh9ZedUREdex6ViFGf30Ma05LLa+Z/T2xalo3hh+iJq5GLbCkpCT07dsX+vr6iImJQe/evREeHg4nJyccOXJENbKiMWMLjKjp2xKegnf+ikJxuQL2lsb4amIQenvZy10WET2EOm2Bubm5ITIyEqtXr8bZs2ehVCoxZcoUPPHEE7C0tKxx0URE9aG0QoEPtl3A2jPSzL/ubZtj+aQgtOBZHyKdwQch3gfPABE1TTGZhZixOgyX0wuqWl5emDnACwb6eg8+mIgavDo9A3SLUqlEcXHxXes8C0REDdHmsGT8b0t0VcvLBMsmdUQvT7a8iHRRjQLQlStX8NJLL+H48eMoLy+/aztPKhFRQ1JSrsD726Kx/qz07LKeHnb4alJHtLBiy4tIV9UoAD311FNwcnLC1q1bYWtrW8slERHVnmsZBZi+OgxXMwqhpwe8PqAdZvT3ZMuLSMfVKABFRERg9+7dDD9E1KBtOie1vEoqFHCwklpePT3Y8iKiGgYgd3d3ZGZmMgARUYNUXF6J97ZewMZzUsurt6c9vpzYEQ5WJjJXRkQNRY0C0IcffohnnnkGixYtgoeHh8bToAHAycmpVoojIqquaxkFeGVVGK5lFkJfD3j9sXaY3o8tLyLSVKMAZGdnh+joaDzyyCP33M6LoIlIDhvOJmH+1miUVijRwsoEyyYFoYeHndxlEVEDVKMA9Morr2DYsGF45ZVX2AYjItkVl1fif1uisTksBQDwiJfU8rK3ZMuLiO6tRgEoMTERp0+f5gMCiUh2V9Klu7xiqlpebwzyxst9PKDPlhdRw1VZBmREAy07yVZCjQKQl5cXkpOT0aFDh9quh4hIK0IIbDibjPe2SS0vR2sTLJ8UhG5t2fIiapCUSiDpJBC5DrjwlxSC5lwDTOU5mVKjAPT444/j8ccfx6JFi+Dp6XnXRdDu7u61URsR0T0VlVVi/pZobA6XWl6PtnPAl6GBsGPLi6jhyboihZ7IDUBeonrdyhnIiQFaBstSVo1mgd0ZeO7UFC6C5iwwoobpcno+pq8Kw/WsIhjo62H2wHZseRE1NAXpQNRGIGo9kBahXje2AjqMAgJCAffegL5BrX/pOp0Fdu3atRoXRkRUE0IIrDuThPe3XUBZpRJO1qZYMSUIXdyby10aEQFAWQFwaYd0tifuMCCU0rq+IeA5UAo93kMBIzN566xSowDk6elZ23UQEd1XYVkl3v0rClvPpwIA+no74IvQjmhuYSxzZUQ6TlEBXD8ohZ7LO4HKEvU2t25S6OkwBrBoeNfmaR2AoqOjAQB+fn6q/30/fn5+D1cVEVGVS2lSyys2W2p5zRnkjRcfbcuWF5FchABSzkmhJ3oTUJyj3mbnCQRMBPzHA83bylejFrQOQP7+/gCk09C3/vf9NIVrgIhIXkIIrDmdhAXbpZaXs40pVkwOQme2vIjkkXMdiNogBZ/cWPW6ub0UeAJCAZdg4AHXCTcUWgegtLS0e/5vIqLaVlBagXf+isb2CKnl1b99CyyZEMiWF1F9K8qWblmPXAckn1GvG5kD7YdLZ3va9gUManRFjay0rtjJyQnTpk3DTz/9xFlfRFRnLqTmYcbqcMRVtbzeGuKNab3Z8iKqN+XFwJW/gcj1wPUDgLJSWtfTB9r2k0JP+2GAiaW8dT6kat0Gr6enpzPtLd4GT1S/hBBYdSoRH+64iPJKJVxspLu8OrVmy4uozikVQNy/Uui5tA0oL1RvcwmSQo/vWMDKUb4atVSnt8ETEdWmgtIKzNschR2RUnt9QFXLqxlbXkR1RwggPVIKPVEbgcJ09TbbVlUXM4cCDu3kq7EOMQARkayiU/IwY3UY4nOKYaivh7eGtMe0R9o88IGrRFRDNxOrLmZeD2RdVq+bNQN8x0jBx61bo7mYuaaqHYAMDR98SGVlZY2KISLdIYTAnycT8NGOSyhXKNHS1gwrpgQhuFUzuUsjanpKbgAXt0qhJ+GYet3ARHo4YcBEwPMxwFB3zrpWOwCtXLmyLuogIh2SX1qBtzdF4u8o6ZT7Yz6OWDIhALbmuvPDl6jOVZYBV/dId3Bd2wsoyqs26EljKAImAh1GAqY2spYpl2oHoJdeeqku6iAiHRGVnIfpq8OQmCu1vN4e2h7P9WbLi6hWKJVA4gkp9FzcApTmqbc5+gH+E6Rn9ti4ylZiQ8FrgIioXggh8PuJBHyyU93yWjklCEFseRE9vMxLVRczbwDyktTrVi5AwATpYmYnTmm4HQMQEdW5/NIKvLUxEruipZbXwA6OWDI+EDbmRjJXRtSI5acB0Rulsz3pUep1E2uptRUwEWjdq04mrjcF1QpAJSUlD96JiOg2kck3MWN1OBJzi2FkoId5Q33wTC93tryIaqI0H7hcNXE99jCAqmfz6RsBXoOkcRTtBjeYiesNWbUCkKmpaV3VQURNjBAC/3c8Hp/+fQkVCgHXZmb4ekowAt1s5S6NqHFRVAAxB4Co9cDlv++YuN5dCj2+YwBzPjS0OtgCI6Jal1dSgTc3RmDPhQwAwBBfJywaHwAbM7a8iLQiBJB8VjrTc2HzHRPXvW6buN5GvhobOQYgIqpV55NuYsbqMCTfKIGRgR7eDfHBUz3Z8iLSSs516WLmyHXAjTj1ukUL9cR1545N/iGF9YEBiIhqhRACvx6Lx8JdUsvLrbnU8gpwtZW7NKKGrTBLOssTuQ5IOadeN7IAfIZLoadN30Y5cb0h46dJRA8tr7gCczdGYO9FqeU11M8Jn41jy4vovlQT19dJ1/cIhbSuZwB49K+auB4CGFvIW2cTxgBERA8lPPEGZqwOR8rNEhgb6ON/w33wRPfWbHkR3UmpAOIOV01c337HxPVgKfT4jQUsW8hXow5hACKiGhFC4Oejcfhs12VUKgVa25nj6ynB8Gupm4/VJ7onIYC0CCn0RG8ECjPU22xbS6EnIBSw95KvRh3FAERE1XazuBxzNkRi/yXph/kwf2csHOcPa1O2vIgAADcS1BPXs6+o182aS2d5AiYCrl14MbOMGICIqFrCEm/g1dtaXvNHdMDj3Vqx5UVUnCvN34pcL83jusXQVD1x3WOATk1cb8gYgIhIK0II/HQkDot2Sy0vdztzrGTLi3RdRSlwbY8Ueq7uAZQVVRv0gDaPSqHHZwRgai1rmXQ3BiAieqAbReWYsyECBy5nAgCGBzhj4Vh/WLHlRbpIqQQSj1c9pHArUHb7xHV/6Zoe//GAtYt8NdIDMQAR0X86l5CLV1eHIzWvFMaG+nh/RAdM6cqWF+mgjItS6InaCOQnq9etWwL+E6Tg4+grX31ULQxARHRPSqXAj0di8fmeK1AoBdrYW2DllCD4urDlRTokP1UKPJHrgYzbJ67bAL6jpBZXq56Avr58NVKNMAAR0V1yi8rxxvrzOHglCwAwMtAFn471h6UJf2SQDijNBy5tk0JP3L/QmLjebrB0psdrMGDEAeGNmew/zcrLy3HgwAFkZGTA398fnTp1qpVjEhMTcerUKRgaGqJr165o2bJlXZRP1OScjc/Fq2vCkVbV8low0heTurix5UVNW2U5cP2A1OK6sguoLFVva9VDCj0dRnPiehMiawDKyspC//79UV5ejoCAAMyaNQsTJ07Ed999V+NjhBCYMmUKTp06hc6dO6O4uBhTp07Fp59+itdff72e3hlR46NUCnz373Us3XsVCqVAW3sLfD01GD7OvHuFmighgOQzUuiJ3gyU5Kq32bermrg+AWjWWr4aqc7IGoDmzZsHAAgPD4e5uTnOnTuHLl26YMSIERg2bFiNjhFCYNSoUVi1ahX0q3qyf/zxB55++mmMGDECHh4e9fPmiBqRnMIyzF4fgcNXpZbX6I4u+HgMW17URGVfk9pbUeuBG/HqdUtHwO/WxPVAPqSwidMTQgg5vrBSqYStrS0++OADzJ49W7Xeu3dvtGnTBn/88UetHAMAmZmZcHR0xM6dOxESEqJVffn5+bCxsUFeXh6srfkvYGq6TsflYuaacKTnl8LEUB8fjvJFaGe2vKiJKcyUzvJErgNSw9TrRhZAh5HSmZ42fThxvQnQ9ve3bP9PJyUloaCgAB06dNBY79ChA86ePVtrxwDAjh07YGBggICAgPvuU1ZWhrKyMtXf8/PztXkbRI2WUinw7eHr+GKf1PLycJBaXu2dGPipiSgvAi7vlM72XP9Hc+K65wCpxeU9lBPXdZRsAehWwLC1tdVYb9as2X3DR02OuXTpEmbPno3Zs2fD1dX1vvUsXLgQCxYs0LJ6osYtp7AMs9ZH4N+qlteYoJb4eLQfLNjyosZOUQnEHaqauL4DqChSb2vZSQo9vmMBSwfZSqSGQbafdmZmZgCAgoICjfX8/HyYm5vXyjGxsbEYNGgQQkJC8Nlnn/1nPfPmzdNoq+Xn58PNze3Bb4SokTkVm4OZa8ORkV8GUyN9fDjSDxM6u7LlRY2XEEDa+arrejYCRZnqbc3aqCeu2/EaUFKTLQC1bt0axsbGiIuL01iPi4uDp6fnQx8TFxeHvn37omfPnvjjjz9UF0Tfj4mJCUxMTGrwTogaB6VS4JtDMfhi31UoBeDZwhLfTA1GO0cruUsjqpkb8UDkBuli5uyr6nWz5oDfuKqJ6515MTPdk2wByMjICEOGDMHatWvx/PPPQ09PD6mpqTh48CC+//571X6HDx9GRkYGQkNDtT4mPj4effv2RY8ePbBq1SoYGBjI8RaJGozswjLMWnceR65lAwDGBbvio9G+MDdmy4sameJc4MJf0tmepJPqdUNTwDtECj2eAwADzqmj/ybbXWAAcPnyZfTs2RO9e/dG9+7d8fvvv6NFixb4559/YGgo/WCeNm0aTp48iejoaK2OKS0thY+PD4qLi/Hee+9phJ++ffuiffv2WtXGu8CoqThxPQevrQ1HZoHU8vpolB8mdGZ7lxqRihLg6m7pbM+1vZoT19v2kUJP++GcuE4AGsFdYADQvn17REZG4vfff0dGRgbmzJmDJ598UhV+ACm0tG7dWutjFAoFBg8eDACIiorS+Hr+/v718K6IGgaFUuDrgzH4ar/U8vJqYYmv2fKixkKpBBKOSretX9wGlN12o4uTvxR6/MZx4jrVmKxngBoyngGixiyrQGp5HY2RWl4TOrliwSi2vKgRyLhw28T1FPW6jZt64noLH/nqowavUZwBIqLadzwmG6+tO4+sgjKYGRng49F+GNfp/o+AIJJdXgoQfWvierR63cQG8B1dNXG9ByeuU61iACJqIhRKgRX/XMOyA9cgBNDOUbrLy7MFW17UAJXmSa2tyHVA/FGoJq4bGANeg6TQ4zWIE9epzjAAETUBmQWleH3teRy/ngMAmNjZDR+M9IWZMe+ApAakshyI2a+euK5QP30frXtVTVwfBZg1k69G0hkMQESN3LGYbLy29jyyC8tgbmyAT8b4YUwQW17UQAgBJJ2SQs+Fv4CSG+pt9t5AYNXEddtW8tVIOokBiKiRUigFlh24hhX/SC2v9k5WWDklGJ4tLOUujQjIuio9oDByPXAzQb1u6QT4V01cdwrgQwpJNgxARI1QZn4pZq4Nx8nYXADA5K5ueH+EL0yN2PIiGRVmAtGbqiauh6vXjS0Bn5FS6GnzKKDP71OSHwMQUSNz5FoWZq07j+zCclgYG+DTsf4Y1bGl3GWRriorrJq4vg6IPQgIpbSuZwB4PiaFHu8QwPjeMx6J5MIARNRIVCqUWHbgGlYejFG1vL6eGgwPB7a8qJ4pKoHYQ1LoubwDqChWb3PtAviHAn5jAQt72UokehAGIKJGICO/FDPXhONUnNTymtKtFd4b3oEtL6o/QgCpYdI1PdGbgKIs9bbmbaXb1v0ncOI6NRoMQEQN3L9XpZZXTpHU8lo4LgAjA/n4f6onuXFA1AbpbE9OjHrd3F46yxMwEWjZiRczU6PDAETUQFUqlPhy/1V8c+g6hAB8nK3xzdRgtLG3kLs0auqKc4ELm6smrp9SrxuaAe2HSaHHox8nrlOjxgBE1ACl50ktr9PxUsvr8e6t8L9hbHlRHaookR5OGLkeiNkHKCuldT19oE3VxHWf4YAJnyxOTQMDEFEDc+hKJmavj0BuUTksTQzx2Th/DA9gy4vqgFIhjaGIXA9c3AqUF6i3OQdWXcw8DrB2lq9GojrCAETUQFQqlFi67yq+PXQdAODrYo2vpwTDnS0vqm3p0eqJ6wWp6nWbVkDABCn4tGgvX31E9YABiKgBSMsrwcw14TgTL40JeLJHa7wT4sOWF9WevOSqi5nXA5kX1eumtuqJ627dOXGddAYDEJHMDl7JxOx153GjuAJWJoZYND4AIf5sOVAtKLkJXNomhZ47J663G1I1cX0gYGgiZ5VEsmAAIpJJhUKJJXuv4PvDsQAAv5ZSy6u1HVte9BAqy4Br+6Q5XFd23zFxvXfVxPWRnLhOOo8BiEgGqTdL8OqacJxLkFpeT/d0x7yQ9jAxZMuLakCp1Jy4XnpTvc3BRwo9/hMAWzfZSiRqaBiAiOrZgUsZeGNDBG5Wtbw+Hx+AoWx5UU1kXZHaW1HrgZuJ6nUr56qJ6xMBRz8+pJDoHhiAiOpJhUKJJXuu4Pt/pZZXgKsNVk4ORis7DomkaihIV09cT4tQrxtbSa2tgFDA/RFOXCd6AAYgonqQcrMEr64OQ1jiTQDAM73c8fZQtrxIS2WF0tDRyHXSENJbE9f1DQHPgVUT14cCRmaylknUmDAAEdWx/RellldeSQWsTA2xeHwghvg5yV0WNXSKSiD2YNXE9Z13TFzvKoUe37GAhZ18NRI1YgxARHWkvFKJz3dfxk9H4wAAga42WDklGG7N2fKi+xACSAmTQk/0JqA4W72tuYd0TU/ABGn6OhE9FAYgojqQfKMYM1aH43zSTQDAs73a4O2h7WFsyIfM0T3kxgKRVRPXc6+r183tqy5mDgVcgnkxM1EtYgAiqmV7L6RjzoYI5JdWwtrUEIsnBGKwL1tedIeibOmW9ch1QPIZ9bqhmTR0NGAi0LYvJ64T1REGIKJaUl6pxKLdl/FzVcuro5stVkwOYsuL1MqLgau3Jq7v15y43rafdKan/TBOXCeqBwxARLUgKbcYM9aEI6Kq5fX8I20wdzBbXoSqietHqiaub7tj4npH6UyP3zjAylG2Eol0EQMQ0UPaHZ2OuRsjUFBaCRszIyyZEIiBHfjLTKcJAaRHqS9mLkhTb7NtJU1bDwgFHLzlq5FIxzEAEdVQeaUSC3ddwq/H4gEAQa2klpdrM7a8dNbNJPXE9axL6nVTW8BvrBR83Lpx4jpRA8AARFQDiTnFmLEmDJHJeQCAFx5ti7mDvWFkwF9sOqfkBnBxq3QXV8JR9bqBCeBdNXHd8zFOXCdqYBiAiKppd3Qa5m6MREFpJWzNjbB0QiAG+LDlpVMqy4Bre6UW19U9gKK8aoMe4F41cd1nJGBmK2eVRPQfGICItFRWqcCnOy/htxMJAIBOrZthxeQguNhy/IBOUCqBpJO3TVzPU29r0UE60+M/HrBxla9GItIaAxCRFhJyijBjdTiiUqRfei/2aYs5g9jy0gmZl6XQE7URyLt94rqLeuK6k5989RFRjTAAET3A31FpeGtjJArKKtHM3AhfhHZEv/Yt5C6L6lJBuhR4ItcB6ZHqdRNrqbUVECq1ujhxnajRYgAiuo/SCgU+/fsSfq9qeXVu3QzL2fJqusoKgEvbpTu44g5rTlz3GiSFnnZDOHGdqIlgACK6h/jsIkxfHYYLqfkAgJf7emD2wHZseTU1igrg+j9VE9f/BipL1Nvcukmhp8MYTlwnaoIYgIjusCMyFW9vikJhWSWaWxjji9BA9PVmy6vJEAJIOXfbxPUc9TY7TyBgknRtT/M28tVIRHWOAYioSmmFAh/vvIg/T0oXunZ1b47lk4PgZGMqc2VUK3KuS+2tqPXS9PVbLBwAv1sT14M4cZ1IRzAAEQGIyy7C9FVhuJgmtbym9/PArMfawZAtr8atKBuI3iyd7Uk5q143Mgfa3z5xnT8KiXQN/6snnbctIhXzNkWiqFyB5hbG+HJiR/Rp5yB3WVRT5cXAlb/VE9eFQlrX0wc8+kuhxzsEMLGUt04ikhUDEOms0goFPtxxEatPVbW82jTH8klseTVKSoV051bkeulOrvJC9TaXICn0+I7lxHUiUmEAIp0Um1WI6avDcSktH3p6wIx+nnhtgBdbXo2JENIzeiLXS8/sKUxXb7NtLYWegFDA3ku+GomowWIAIp2z9XwK3tkchaJyBewsjPHVpI54xIstr0bjZuJtE9cvq9fNmklneQImAm5deTEzEf0nBiDSGaUVCizYfgFrTicBALq3bY5lk4LgaM2WV4NXcgO4sEUKPYnH1esGJoD30NsmrhvLViIRNS4MQKQTYjILMWN1GC6nF0BPD3i1vxdeG+AFA32eJWiwKkrVE9ev7dWcuN7mESn0+IwATG1kLZOIGicGIGrytoSn4J2/olBcroC9pQm+mtgRvb3s5S6L7kWplM7wRK4DLm7VnLju6Cdd0+M3HrBpKV+NRNQkMABRk1VSrsAH2y5g3Vmp5dXTww5fTeqIFlZseTU4mZek0BO5AchPVq9bt5SeyuwfyonrRFSrGICoSYrJLMD0VeG4kiG1vF4b4IVX+7Pl1aDkpwHRtyauR6nXTayBDqOkFlfrXoA+78wjotrHAERNzqZzyfjflmiUVEgtr+WTOqKnJ1teDUJpftXE9XVA3L8AhLSub3THxHWepSOiusUARE1GSbkC722NxoZzUgull6cdvpzIlpfsFBVAzAEp9Fz5G6gsVW9r1QPwnwD4jgHMm8tXIxHpHNkD0P79+7FixQpkZGTA398f7733Htzc3B76mEOHDuG7777D5cuX8dNPP6Fz5851+TZIZtcyCjB9dRiuZhRCXw94/bF2mN7Pky0vuQgBJJ+RbluP3gSU5Kq32XkBgROl4NPMXbYSiUi3yRqA9u3bh5CQELz//vvo0aMHli1bhl69eiEqKgo2Nve+tVWbY95++22cOHECY8aMwbp161BYWHjP16KmYeO5ZMyvank5WJlg+aQg9PCwk7ss3ZQdI01bj1wP3IhTr1u0kC5mDggFnDvyIYVEJDs9IYSQ64v36NEDHh4e+PPPPwEApaWlcHZ2xrx58/Dmm2/W+JiioiJYWFggOTkZbm5uOHjwIPr27Vut2vLz82FjY4O8vDxYW1vX/E1SnSkur8T8LRewKUxqeT3iZY8vQjvCwcpE5sp0TGEWcOHWxPVz6nUjC+k5PQGhQJs+nLhORPVC29/fst1eUVhYiFOnTiEkJES1ZmpqigEDBuDAgQMPdYyFhUXdFU4NwtWMAoxceQybwpKhrwfMGdQOvz3TleGnvpQXSbes/zkeWOoN7HpTCj96BoDnQGDsT8Dca8DY7wHPAQw/RNTgyPZTKSUlBUIIODs7a6y7uLhg//79tXaMtsrKylBWVqb6e35+/kO9HtUNIQQ2nEvGe1ujUVqhRAsrEyyfHITubdnyqnOKSs2J6xVF6m0tO0nP6vEbC1i2kK9GIiItyRaAKioqAAAmJpr/YjcxMVFtq41jtLVw4UIsWLDgoV6D6lZRWSXmb4nG5vAUAFLL68uJHWFvybM+dUYIIC2i6mLmjUBhhnpbM3fpWT3+oYC9p2wlEhHVhGwByM5O+hd7Tk6OxnpOTo5qW20co6158+Zh9uzZqr/n5+c/8G40qj9X0gvwyqpzuJ5VBH094I1B3ni5jwf0eZdX3bgRr564nn1VvW7WXDrLEzARcO3Ci5mJqNGSLQA5OzvDxcUFp0+fxogRI1TrJ0+eRL9+/WrtGG2ZmJjcdWaJ5CeEwPqzSXh/2wWUVijhZG2K5ZOD0LUNnxlT64pzgYtbqiaun1CvG5oC3iFS6PHoz4nrRNQkyHpl4vPPP4/vv/8ezz33HNzd3bF69WpcvnxZdYcXAHz44YeIjIzExo0btT6Gmoaiskq8+1cUtpxPBQD0aeeAL0IDYceWV+2pKAWu7ZFCz9U9gPJWK1kPaPPobRPXeSckETUtsgagd999F7GxsfD29oajoyNu3ryJH3/8EcHBwap9EhMTcfny5Wods23bNrz33nuq64KmTZsGS0tLvPTSS3jppZfq7w1SjV1Ky8f01WGIzSqCgb4e5gzyxouPtmXLqzYolUDCsaqJ69uAstsnrvtLt637jwesXeSrkYiojsn6HKBbsrOzkZWVBXd3d5iZmWlsS0pKQnFxMby9vbU+Jjc3F4mJiXd9HScnJzg5OWlVE58DJA8hBNaeScIH2y6grFIJZxup5dXFnS2vh5ZxUQo9URuA/BT1urUrEDBBupjZsYN89RER1QJtf383iADUEDEA1b/CqpbX1qqWVz9vBywN7YjmFrzmpMbyUqomrq8HMqLV6yY2gG/VxPVWPTlxnYiaDG1/f/PpZNQgXEzNx4zVYYjNllpebw72xvOPsOVVI6V5t01cPwKNievtBkuhx2sQJ64TkU5jACJZCSGw+nQiFmy/iPJKJVxsTLFiShA6tWbLq1oqy4Hrtyau77pj4npP6bqeDqM4cZ2IqAoDEMmmoLQC8zZHYUdkGgCgf/sWWDohEM3Y8tKOEEDSaSn0XNgMlNxQb7P3rrqYeQLQrLV8NRIRNVAMQCSL6JQ8zFgdhvicYhjq6+HNId6Y1pstL61kX5Ou6YlaLz2w8BZLRynwBIQCTgF8SCER0X9gAKJ6JYTAn6cS8dEOqeXV0tYMyycHoVPrZnKX1rAVZgLRm6TgkxqmXje21Jy4rm8gX41ERI0IAxDVm4LSCry9OQo7q1pej/m0wJIJgbA1Z8vrnsqLgMs7pRbX9YOAUEjregbShPWAiYD3UMDYQt46iYgaIQYgqhfRKXmYvjoMCVUtr7eHtsdzvdtAj20aTYpKIO5Q1cT1HXdMXO8shR7fMYClg2wlEhE1BQxAVKeEEPjjZAI+3nEJ5Qqp5bVyShCCWrHlpSIEkBpeNXF9E1CUqd7WrI0UegJCATsP+WokImpiGICozuSXVuDtTZH4OyodADCwgyOWjA+EjbmRzJU1EDfigcgNUosr55p63dwO8BsnPZnZtTMvZiYiqgMMQFQnopKllldibjGMDPTw9lAfPNvLnS2v4lzplvXIDUDSSfW6oSnQfph64roBQyIRUV1iAKJaJYTA7ycS8MlOqeXl2swMX08JRqCbrdylyaeiBLi6W2pxXdunOXG9bR8p9LQfzonrRET1iAGIak1eSQXe2hiJ3RekltdgX0d8Pj4QNmY6eDZDqQQSjt42cT1fvc0pQAo9fuMAa2f5aiQi0mEMQFQrIpJuYsaaMCTllsDIQA/vhPjg6Z462PJKj5ZCT/QmzYnrNm7qhxS28JGvPiIiAsAARA9JCIFfj8Vj4a5LqFAIuDU3w8rJOtbyyksBojZILa7MC+p1Uxugw+iqies9OHGdiKgBYQCiGssrrsDcjRHYezEDADDUzwmfjQvQjZZXaZ7U2opcB8QfhWriuoGx5sR1QxNZyyQiontjAKIaOZ90EzNWhyH5RgmMDfTxv+E+eKJ766bd8qosB2L2VU1c3w0oytTbWvdST1w34zOOiIgaOgYgqhYhBH45Fo/PqlperZqb4+spwfB3tZG7tLohBJB0qmri+l+aE9cd2ktnevzHA7at5KuRiIiqjQGItHazuBxzN0ZiX1XLa5i/MxaO84e1aRNseWVdlaatR64Hbiao1y2dpMATMBFw8udDComIGikGINJKWOINvLo6HCk3pZbX/OE+eLyptbwKMqomrq8D0s6r140tAZ+RVRPXH+XEdSKiJoABiP6TUinwy7E4fLbrMiqVAq3tpJaXX8sm0vIqK1RPXI89CAiltK5vCHg+JoWedkMBY3N56yQiolrFAET3lVVQhjkbInD4ahYAYHiAMxaO9YdVY295KSqlsBO5Tgo/FcXqba5d1BPXLezlq5GIiOoUAxDd0+GrWXhjfQSyC8tgYqiP+cM7YGq3Vo235SUEkBp228T1LPW25h7SmR7/CZy4TkSkIxiASENZpQKLd1/BT0fjAADtnaywfHIQ2jlayVxZDeXGVT2kcB2QE6NeN7eXRlEETARaBvNiZiIiHcMARCqxWYWYuTYc0SnS3KqnerTGvBAfmBo1sot+i3KqJq6vB5JPq9cNzW6buN6PE9eJiHQYAxBBCIEN55LxwbYLKC5XoJm5ET4fH4iBHRzlLk17FSXAlV1S6InZBygrpXU9faBtX8A/FPAZDpg00jNZRERUqxiAdFxeSQXe/SsKOyLTAAA9PezwRWhHONmYylyZFpQKIP6IFHoubgPKC9TbnAPVE9etnOSrkYiIGiQGIB12LiEXM9ecR8rNEhjq62H2oHZ48VEPGOg34OthhAAyqiauR20ECtLU22xaAQETpLM9LdrLVyMRETV4DEA6SKEU+PpgDJYduAaFUhpnsXxyEDo25Anuecm3TVy/qF43tZVuWQ+YCLh148R1IiLSCgOQjkm9WYJZ687jVFwuAGB0Rxd8NNqvYT7bp+QmcHGrFHoSjqrXDYyBdkOqJq4P5MR1IiKqNgYgHbI7Oh1vbYpEXkkFLIwN8NFoP4wNdpW7LE2VZcC1qonrV/doTlx3f0R6Vk+HUYCZrWwlEhFR48cApANKyhX4aOdFrD6VCAAIdLXBsklBcLe3kLmyKkolkHRSOtNz4S+g9KZ6m4MPEDgR8BsP2LrJViIRETUtDEBN3KW0fMxcE45rmYUAgBf7tMUbA71hbNgArpXJuiKd6YncAOQlqtetnNUT1x39+JBCIiKqdQxATZQQAr8dj8enuy6jvFIJBysTfBnaEb29ZJ5vVZB+28T1CPW6sZXU2goIBdx7c+I6ERHVKQagJiinsAxvbozEgcuZAID+7Vtg8fgA2FnKdLFwWQFwaQcQtR6IPXTHxPWBUujxHgoYmclTHxER6RwGoCbmWEw2Zq07j8yCMhgb6uOdoe3xVE/3+h9iqqgArt82cb2yRL3NtasUenzHAhZ29VsXERERGICajAqFEkv3XsX3/16HEIBnC0usmBwEH2fr+itCCCAlTAo90ZuA4mz1NjtP6Zoe//FA87b1VxMREdE9MAA1AQk5RZi5JhwRyXkAgMldW+G94R1gZlxP19HkXFdPXM+NVa+b21ddzBwKuHDiOhERNRwMQI3c5rBkzN8SjaJyBWzMjLBonD+G+DnX/RcuypZuWY9cBySfUa8bmQPth0tne9r2BQz4LUZERA0Pfzs1UgWlFZi/JRpbzqcCALq2aY6vJnaEi20dXkhcXgxcvTVxff8dE9f7SaGn/TDAxLLuaiAiIqoFDED1rawQJTH/wsw3pMYvEZ54A6+tPY/E3GIY6OvhtQFemN7Ps26GmFaWSxPXozYCl7YB5YXqbS5B0uBRv3GAlWPtf20iIqI6wgBUj/LybsB4WQeYKYtRaHcWlk5e1TpeqRT47t/r+GLvVVQqBVrammH55I7o1Lp57RZakAFc2wtc3S3dtn576LFtVXUxcyjg0K52vy4REVE9YQCqR1ZWtgjTa4fOOI+Le/8PXZ/8ROtjM/JLMWvdeRy/ngMAGB7gjE/G+MPGrBaGmCqVQNp5afbWtT1AarjmdktHqbV1a+I6L2YmIqJGjgGoHunr60H4jgUiz6NZ3HaUV36k1UiK/RczMHdjBG4UV8DMyAALRvpiQmfXh3u2T1mB9Jyea3uAq3uBokzN7S7BQLvB0h+nQEC/AYzOICIiqiUMQPUsYODjqIj8EF4iAbuP/Ish/fred9/SCgU+/fsSfj+RAADwdbHG8slB8HCo4UXGOdfVZ3nijwHKCvU2Y0vAox/Qboj0dGZe00NERE0YA1A9M7GyQ7xdT7jn/IusE2ug7NMH+ve4ePlqRgFeXR2OKxkFAIBpvdtg7hBvmBhW49k+leVA4gn19Tw5MZrbm7eVAo/XIKB1T8BQplEZRERE9YwBSAYtek4Btv+LnqWH8c+lDDzm66TaJoTAqlOJ+GjHRZRVKmFvaYwlEwLR17uFdi9emAXE7JMCz/WDQFm+epu+oRR0vAZLwcfes5bfGRERUePAACQDc78RqNj5GjyQhu/+2YvHfJ8EANwoKsdbmyKx92IGAKBPOwcsmRAIB6v/ODMjBJAeKbW2ru4BUs4BELd9MXvpDE+7wVKLy9SmDt8ZERFR48AAJAcTSyg8B8Po6jZ4ZOzFuYThKK8UmLXuPNLzS2FkoIe3hrTHs73a3LM9hvIi6fb0q3uk9lZBmuZ258CqszyDpYuZeQEzERGRBgYgmZh2nABc3YbhBicwaU04UvJKIQTQ1t4CyycHwa/lHWdqcuOqruXZA8QfBRRl6m1GFtLYiXaDpbM91vUwCoOIiKgRaxABKDMzE5mZmWjbti3Mzc1r7ZiavG698RoIpZElXCuy0SIvEsmiHUI7u+L9Eb6wMDEEFBVA0il1ayv7iubxtq2l63jaDQJa9waMTOV5H0RERI2QrL2R8vJyTJ06Fa1atcKIESPQokUL/Pjjjw99TE1et94ZmUHfZxgAYJL5GaycEoTPh7rC4vImYMMzwGIP4P+GAceXS+FHz0AKOgM/BKafBl6LAEI+BzwfY/ghIiKqJlnPAH388cc4ePAgrl27Bjc3N6xbtw6TJ09GcHAwOnXqVONjavK6svAbB0SuQ6jxceDM08Dm09C4gNmsOeA1sOoC5v6AWTO5KiUiImpS9IQQ4sG71Q0XFxdMmzYNH374oWrN19cXffr0wTfffFPjY2ryunfKz8+HjY0N8vLyYG1tXZO392CV5cASL6D0pnrN0V9qa3kNBlw7A/rVeO4PERGRjtP297dsZ4DS0tKQlpaGLl26aKx369YNYWFhNT6mJq8rG0NjYMQy4NJ2wL2XdAGzjavcVRERETV5sgWgnBxpqKednZ3Gur29vWpbTY6pyesCQFlZGcrK1HdW5efn33ffWuU7WvpDRERE9Ua2i6CNjKQp5reHDgAoKSlRbavJMTV5XQBYuHAhbGxsVH/c3Nyq8W6IiIioMZEtALm6StPMU1NTNdZTU1PRqlWrGh9Tk9cFgHnz5iEvL0/1JykpqSZvi4iIiBoB2QKQhYUFunfvjp07d6rWSkpKcODAAQwYMEC1lpCQgAsXLmh9jLaveycTExNYW1tr/CEiIqKmSdbb4D/66CMMGTIE3t7e6NGjB5YtWwZbW1u8+OKLGvucPHkS0dHR1TrmQfsQERGR7pL1QYgDBgzAnj17EBERgQULFsDNzQ1Hjx7VOPvi7u4OPz+/ah2jzT5ERESku2R9DlBDVi/PASIiIqJape3vb44JJyIiIp3DAEREREQ6hwGIiIiIdA4DEBEREekcBiAiIiLSOQxAREREpHMYgIiIiEjnyPok6Ibs1uOR6m0qPBERET20W7+3H/SYQwag+ygoKAAAToUnIiJqhAoKCmBjY3Pf7XwS9H0olUqkpqbCysoKenp6tfa6+fn5cHNzQ1JSEp8wXYf4OdcPfs71h591/eDnXD/q8nMWQqCgoAAuLi7Q17//lT48A3Qf+vr6cHV1rbPX58T5+sHPuX7wc64//KzrBz/n+lFXn/N/nfm5hRdBExERkc5hACIiIiKdwwBUz0xMTPD+++/DxMRE7lKaNH7O9YOfc/3hZ10/+DnXj4bwOfMiaCIiItI5PANEREREOocBiIiIiHQOAxARERHpHAagepSXl4ezZ88iKSlJ7lIarfz8fISHhyMzM/O++1RWViIiIgIXLly476PQtdmHgIyMDBw9ehRpaWn33B4TE4Nz586hpKTkvq+hzT667sqVK7h06dJ9vxczMzNx5swZZGVl3fc1tNlHl+Xm5iIsLAzXrl2DQqG45z5FRUU4d+4cYmNj7/s62uyjS/Ly8nDs2LH7/owAgKysLJw5c+Y/f27X1j7VIqheLF++XJiZmQkfHx9hZmYmxo4dK0pLS+Uuq9G4du2aGDNmjLC1tRVBQUHC0tJShISEiJycHI39jh8/Llq2bCnc3NxEixYtRPv27cWVK1eqvQ8JUVJSIgIDA4Wenp5YsWKFxrasrCzRs2dPYWNjIzw9PYWNjY3YvHlztffRdUePHhVeXl7CxcVFBAUFiU6dOolr166ptiuVSvHqq68KExMT0aFDB2FiYiLeeOMNjdfQZh9dVllZKZ599llhZmYmgoKCRMuWLYW7u7v4999/NfZbtWqVsLKyEu3atRNWVlaiX79+4ubNm9XeR1fExcWJ559/Xjg5OQkDA4O7fkbcMmfOHI3vzVdffVUolco62ae6GIDqwcmTJ4Wenp7Ytm2bEEKIlJQU4eLiIubNmydzZY3H7t27xebNm1Xf8NnZ2aJDhw5i8uTJqn2Ki4uFi4uLeOWVV4QQ0g++kJAQERwcXK19SPLyyy+L6dOnCwsLi7t+uI0fP14EBweLwsJCIYQQixcvFmZmZiI5Obla++iymJgYYWFhId59913V93VUVJQ4fPiwap+ffvpJWFpaisjISCGEEGfOnBEmJiZi1apV1dpHl/3+++/CyMhIXLhwQQghhEKhEFOnThUeHh6qfa5duyaMjIzEDz/8IIQQ4saNG8Lb21s888wz1dpHl+zevVt8//33oqCgQNjY2NwzAP3555/CzMxMnDt3TgghREREhDA3Nxc///xzre9TEwxA9eCFF14QHTt21Fj73//+JxwdHWWqqGn44IMPhJubm+rvmzdvFnp6eiI1NVW1dvToUQFAhIeHa70PSZ+Tj4+PKC4uvisA5ebmCgMDA/Hnn3+q1srKyoSNjY1YvHix1vvouueff154eXkJhUJx33169uwpHn/8cY210aNHiwEDBlRrH122dOlSYW9vr7G2YsUKYW1trfr7e++9J5ydnTXOKKxcuVKYmpqK4uJirffRVfcLQP379xfjx4/XWJs0aZLo1atXre9TE7wGqB6Eh4ejU6dOGmtdu3ZFRkbGf/ZN6b+dOXMGnp6eqr+Hh4fDxcUFzs7OqrWuXbuqtmm7j65LTEzEyy+/jFWrVsHMzOyu7VFRUVAoFBrf08bGxggMDFR9htrso+sOHDiAkJAQVFRU4Ny5c0hISLjrGqD7/ey4/TPUZh9d9uSTT8LR0REvvfQS9u3bhz/++ANLly7FZ599ptonPDwcwcHBGoOvu3btitLSUly+fFnrfUhTbX3/1tX3OIeh1oPc3FzY2dlprN36e25ursYvY9LOn3/+iV27dmHv3r2qtXt9zkZGRrCyskJubq7W++gyhUKBKVOmYM6cOQgKCrrnPrc+p3t9T9/+OT9oH12XmpqKzMxMtG/fHra2tkhKSoK7uzvWrl0LT09PlJaWoqSk5J6f4Y0bNyCEQFlZ2QP3uf0Xti6yt7fHjBkz8O677+LkyZPIyspChw4dEBISotonNzcXHh4eGsfd/jNa231ITQiBmzdv3vN7s7i4GGVlZTA2Nq6VfWr6NGmeAaoHRkZGKC0t1Vi7dUeMsbGxHCU1art27cJzzz2Hr776CgMGDFCt3+tzBoDS0lLV56zNPrps2bJlSEtLQ7du3XD06FEcPXoUSqUSsbGxOHv2LADpMwRwz+/p2z/nB+2j64yMjLBjxw7s3r0b4eHhSExMhJWVFZ555hnVduDen6GhoSH09PS02kfXff/993jzzTdx5MgRnD9/HomJiWjTpg369++P8vJyANr9jObP8erR09ODoaHhfT8zIyOjWtunphiA6kHr1q2RkpKisZaSkgJ9fX24urrKVFXjtHv3bowdOxafffYZXn31VY1trVu3Rnp6OpRKpWotMzMTFRUVaNWqldb76DJDQ0M4Oztj3rx5ePvtt/H222+jrKwMW7duxaJFiwBInyGAe35P3/45P2gfXefu7o5+/frB29sbAGBubo4nn3wSJ0+eREVFBQwMDNCyZct7foa3Pl9t9tF1O3bsQL9+/dChQwcA0mf28ssvIzY2FtHR0QDu/zMagMb39IP2IU2tWrW652fm6uoKfX39Wt2nJhiA6sHAgQOxf/9+FBcXq9a2bt2KXr163fMaC7q3vXv3YsyYMfjkk08wa9asu7YPHDgQ+fn5OHTokGpt69atMDY2xqOPPqr1Prps5syZqjM/t/6YmZlh1qxZ2LBhAwCgQ4cOcHFxwbZt21THxcbGIioqCgMHDtR6H103ePDgu36oJycnw9bWVvWv2oEDB2L79u2qa4OUSiW2b9+u8Rlqs48uc3BwQHJyssbarWexOTg4AJA+w1OnTmk8X2br1q3w8vJSBUlt9iFNAwcOxI4dO1Tfm0IIbNu27a7v39rYp0Ye6hJq0kp+fr5o27atGDRokNi6dat46623hKGhocbtrvTfjh49KszMzERoaKg4cuSI6s/Ro0c19nviiSdEq1atxKpVq8SPP/4obGxsxHvvvVftfUjtXrfB//bbb8LIyEgsWbJEbNq0SXTs2FH07t1b444mbfbRZenp6cLZ2Vm89NJLYs+ePWLZsmXCyspK4y65q1evCmtra/H000+Lbdu2iSlTpohmzZqJ+Pj4au2jy06fPi0MDQ3FtGnTxK5du8Svv/4q3NzcxKhRo1T7VFRUiODgYNG9e3exefNm8cknnwgDAwOxcePGau2jSwoKClQ/hy0tLcWsWbPEkSNHxKVLl1T7xMXFiWbNmompU6eKbdu2iaeeekpYW1trPOuqtvapCU6Dryfp6en47LPPEBUVBUdHR0yfPh29evWSu6xG4/fff8cPP/xw17qhoaHG2ZyKigqsXLkSe/bsgaGhIcaNG4enn35a41oIbfYhtUGDBuGll17C2LFjNda3bduG3377Dfn5+ejRowfmzp0LKyurau+jy5KSkvD555/j4sWLcHJywsSJEzFy5EiNfS5evIilS5ciLi4OHh4emDt3Ltq1a1ftfXRZVFQUvv32W1y/fh3W1tbo06cPXnjhBY1rd27evIlFixbhzJkzaNasGaZNm4bBgwdrvI42++iKK1eu4LnnnrtrvV+/fvjoo49Uf7969SoWL16M69evo02bNpgzZw58fHw0jqmtfaqLAYiIiIh0Dq8BIiIiIp3DAEREREQ6hwGIiIiIdA4DEBEREekcBiAiIiLSOQxAREREpHMYgIiIiEjnMAARUb25cuUK9uzZI3cZUCgUOHLkCNavX4+rV6/KXQ4RycBQ7gKIqGmJiopCfHw8HB0dERgYCBMTE9W27du3488//5T16blCCDz22GPIyMhAQEAArKys+NRkIh3EAEREtSIzMxMjR45EXFwcunTpghs3biA1NRXz58/Hs88+CwBo3749hgwZImudV69exaFDh5CamgpnZ2dZayEi+TAAEVGtePPNN1FSUoL4+HiYmZkBALKzs7F//37VPl5eXqpJ5wCwdu3au15HX18foaGhqr/HxMQgOjoajo6OCA4O1jijdD/nzp1DQkIC3Nzc0KVLF9X61atXVV9z//79MDIywujRo2FqaqpxfEJCAk6cOAEAsLCwQIcOHeDh4aGxT3R0NDIyMtC7d28cP34c2dnZmDBhAv755x84ODjAxcUFp06dgrm5Ofr27YszZ87g+vXrAAB7e3sEBgaqppEDQGRkJNLT0zFo0CCNr3P+/HlkZWVxujtRLWMAIqJaER0djR49eqjCDyD9op80aZLq73e2wLZs2aLxGmFhYUhISEBoaCgqKysxbdo0/P333+jWrRuSk5NRVFSErVu33ncIYnFxMUaOHInIyEh07twZYWFhaN++PbZv3w4rKytcv34dR44cUdWir6+PoUOH3hWAkpKSVLUVFBTgyJEjeOqpp7BixQrVPhs3bsQff/wBCwsLODg4wMnJCRMmTMCHH36IyspKpKSkwNfXFz169EDfvn0RHh6Of/75B4A0HPncuXP49ttv8fjjjwOQzqCNGDECKSkpsLe3V32dZ555BoMGDWIAIqptDzVLnoioyvTp04Wtra349ddfRUZGxj33Wbx4sQgMDLzntqioKGFpaSk+//xzIYQQn376qejYsaPIz89X7fP666+LXr163beGDz74QLRq1Ur19bOysoS7u7uYN2+eap8jR44IAKKkpETr95aQkCBsbGzEoUOHVGvvv/++ACC2b9+usW+fPn2Era2tSEpK+s/X3Lp1q7C2tla9P6VSKdq2bSu+/PJL1T7h4eECgLh8+bLWtRKRdngXGBHVis8++wxPPPEEZs+eDUdHR7Rt2xYzZsxAenr6A4/Nzc3FqFGjMGrUKMydOxcA8OuvvyIwMBB79uzBhg0bsH79etjZ2eHEiRMoLS295+usXbsW06ZNQ4sWLQBIZ6Beeumle7baHqS0tBTHjh3Dxo0bcfz4cbi4uOD06dMa+7Rp0wbDhw+/69gxY8bA1dX1rvXs7Gz8888/WL9+PQoLC1FYWIjLly8DAPT09PDss8/i119/Ve3/888/o1evXvD29q52/UT039gCI6JaYWlpieXLl+PLL79EVFQU/v33XyxZsgQ7d+5EVFQULC0t73lcZWUlQkND0bx5c/z000+q9fj4eNjb22Pjxo0a+0+YMAHFxcV3ta0A6dqdtm3baqx5eHggMTERQgjo6elp9V6OHTuGsWPHwt7eHh4eHjA3N8eNGzeQmZmpsd/9LqK+1/qKFSswb948BAQEwNnZWXUt1O2v+cwzz+D999/H2bNn4e/vj9WrV2Px4sVa1UxE1cMARES1ysDAAB07dkTHjh3RrVs3dO/eHcePH7/r4t5b3njjDVy4cAFnz57VCDXW1tYYPXo03nzzTa2/tr29PXJzczXWcnNzYWdnp3X4AYC5c+fi8ccfx9KlS1VrnTt3hhBCY7/7vead68XFxZg1axb++usvjBgxAgBQWFiIdevWabymi4sLQkJC8Msvv6BPnz4oLy/XuCCciGoPW2BEVCvi4uLuWrvVqrK1tb3nMb/++iu+//57/PXXX2jZsqXGtiFDhuCXX35BeXm5xnpKSsp9a+jduzc2b96ssbZx40b07t1bm7egkp6ertF2unbtGiIjI6v1GrfLzs6GQqHQeM07z2zdMm3aNKxZswbffvstQkND73vmjIgeDs8AEVGteOutt5CZmYkBAwagVatWSEhIwLfffoshQ4agU6dOd+2flpaGl19+GSEhIYiPj0d8fDwA9W3wixYtwiOPPIJu3brhqaeegqGhIY4ePYqSkhJs3br1njV89NFH6NKlC8aNG4chQ4Zg3759OHXqFE6dOlWt9zJ69GgsWLAAZWVlqKiowJdffglzc/Nqfya3uLm5ITg4GE899RSmTZuGmJgY/Pzzz9DXv/vfoMOGDYO5uTkOHz6MTz75pMZfk4j+GwMQEdWK9evX49ixY9i7dy8OHjwIe3t7fPPNNxg5ciQMDAwAaD4IUQiB0aNHA9C8Hd7AwAChoaFo2bIlIiIi8Pvvv+PcuXOwsrLCuHHjMG7cuPvW4OHhgfPnz+PHH3/EkSNH4OXlhUWLFqFNmzaqfRwcHDBx4kRVTffy+eefw9vbG6dOnYKFhQX++OMPnDx5Em5ubqp9/Pz87nls//790b59e401PT097Nu3DytXrsThw4fRsmVLHD9+HB9++OFdZ74MDAwwfPhwHD58GL169bpvjUT0cPTEnU1tIiKSjVKphIeHB6ZPn445c+bIXQ5Rk8UzQEREDcSWLVuwc+dOFBcX44UXXpC7HKImjRdBExE1ELt374aBgQH27t0La2trucshatLYAiMiIiKdwzNAREREpHMYgIiIiEjnMAARERGRzmEAIiIiIp3DAEREREQ6hwGIiIiIdA4DEBEREekcBiAiIiLSOQxAREREpHP+H7xdM9RKdZr8AAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGxCAYAAACKvAkXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXwRJREFUeJzt3XdclXX/x/EXe8hSRHCAuPfCnVpmuUtTU3P0666sO0ttWnl3V3c2LBtWrnZ3d2pmZmrlSCvNnQIONMGFgspwMWRzrt8f5ClS7IDABZz38/Hg8ZDr+n7P+Zyjct5c4/txMAzDQERERMSOOJpdgIiIiEh5UwASERERu6MAJCIiInZHAUhERETsjgKQiIiI2B0FIBEREbE7CkAiIiJidxSARERExO44m11ARWWxWDh16hTe3t44ODiYXY6IiIjYwDAM0tLSqFOnDo6ORR/nUQAqwqlTpwgODja7DBERESmBuLg46tWrV+R+BaAieHt7AwVvoI+Pj8nViIiIiC1SU1MJDg62fo4XRQGoCJdOe/n4+CgAiYiIVDJ/d/mKLoIWERERu6MAJCIiInZHAUhERETsjq4BugYWi4WcnByzy7BLLi4uODk5mV2GiIhUUhUiAOXk5JCamoq/v7/Na+7YOic9PR1nZ2fc3d1Lq1zr8x87dgyLxVKqjyu28/PzIygoSOs0iYhIsZkagCwWC1OnTmX+/Pk4Ojri6+vLnDlzGDZs2DXP2bZtGw8//DBRUVF4eXkxZMgQ3n77bby8vK65bsMwOH36NE5OTgQHB191oSUpfYZhkJGRQVJSEgC1a9c2uSIREalsTA1Ab775Jp9++ilbt26lbdu2zJkzh9GjR7Nnzx5atGhR4jn79u3jpptu4oknnmDz5s04Ozvz+eefEx0dTceOHa+57ry8PDIyMqhTpw6enp7X/HhSfB4eHgAkJSVRq1YtnQ4TEZFicTAMwzDryUNDQxk1ahQzZ860bmvcuDG33nors2bNKvGcIUOGkJyczLZt20pcW2pqKr6+vqSkpFy2DlBWVhbHjh0jNDTU+kEs5S8zM5PY2FgaNGhQ6qc4RUSkcrra5/efmXbuJikpiePHj9OjR49C23v27Mmvv/5a4jl5eXmsW7eO22+/HcMwOHv2bJldp6NrT8yl919ERErKtACUnJwMQM2aNQttr1mzpnVfSeYkJyeTlZXFuXPnaNSoEU2aNMHLy4v777+fjIyMIuvJzs4mNTW10Jf8vbfeeotly5aZXYaIiEixmHYN0KULh/Py8gptz83NLfJ6DlvmXDoq8OGHH7JhwwZatmxJTEwMvXv3plq1akWeWpsxYwYvvPBCyV9QJfDpp5+yZcsWoOA28uDgYIYNG1bk9VZ/NXv2bGrVqsXo0aOt21atWkWnTp0YPnx4mdQsIiJSFkw7AlS3bl0AEhISCm1PTEy07ivJnICAANzc3BgzZgwtW7YEoGnTptx5552sWrWqyHqmTZtGSkqK9SsuLq5kL6wC27hxI5s2baJbt260bduWqKgo2rRpwzfffGPT/LVr117TdVUiIiIVhWlHgHx8fGjfvj3r1q2zHlHIy8vjxx9/ZPLkydZx58+fJycnh8DAQJvmODk50atXL9LS0go9X1pa2lVvgXdzc8PNza20X2aFU7t2bSZMmADAxIkTSU9PZ/r06Xh6erJx40ZeeeWVQuMXLlzIyZMnCQgIYO/evcTGxlrnv/TSS9ZxGzZsYP369eTn5zNy5EjCwsIKPU5UVBRffvkl586do23btvzf//1foQvI33rrLUJDQ6lRo8ZVH0dERCq/3XEXOHAqlbFdQ0yrwdQFbJ599lk+++wz3n//ffbu3cs999wDFHwwXzJ16lRuuummYs157rnn+PLLL/n000+JiYnh888/57///S/3339/Ob2yyqN169bExcXRsGFDZsyYQVRUlHWfxWJh2rRpODs706hRI6pXr07t2rXp1q0b3bp1swaYBQsW8J///Ad/f3/Onj1Lt27diIiIsD7O6tWrCQsL4/Tp04SGhjJnzhx69uxZaBXtVatWMWXKlKs+joiIVG6GYfD5tlhGvreVfy/fx6/HzplWi6nrAA0fPpwFCxbwzjvvMHPmTNq0acPGjRsJCAiwjqlRowZBQUHFmtOrVy+WL1/Oq6++yssvv0xISAgfffQRY8eOLZPXYRgGmbn5ZfLYf8fDxanEd0Pl5+fz448/0rp1a5o0acL111/PJ598wltvvQXAunXrSEhI4M477yQgIIDg4GAaN25sPQJ0SY0aNfjxxx+t12EdPnyYzz77jLCwMAzDYMqUKUyZMoU33ngDgPvuu48GDRrwwQcfMGnSJJseR0REKreMnDz+tWwfy3efAqB/q0Ca1/Y2rR7TW2GMHj260EW1f/Xn9X5snQPQt29f+vbte8312SIzN5+Wz60tl+f6qwPT++PpavtfY3R0NBMmTCAvL4/t27eTkpLC999/DxQEk8cee4zXXnsNFxcXPvnkE2655ZZC4fJKbrzxxkIXrjdr1oz4+HgATp48yeHDhxkzZox1v5+fH4MHD2bjxo2FAtDVHkdERCqvI8npTFwQTkxiOk6ODjw9oDkTejUwdTkT9XCwMz4+PnTr1o0bb7yRuXPncvToUesRlttvv53c3Fy+/fZbzp07x4oVK6ynGK/mr4tBOjk5kZ9fcETsUruKKy1dkJiYaPPjiIhI5bRq32mGzN5MTGI6Ad5uLJrQlfuub2j6Wm6mHwGqCjxcnDgwvb9pz10cf74I+q/c3d0ZP348n3zyCSdPnqRGjRoMHDjQur8k/1iDg4MBOH78OPXr17duP378OCEh5l38JiIiZSs338Krqw/y8eZjAHRpUIM5YzpQy6dirNyvAFQKHBwcinUaqiK77777CAsLIzo6mrvuuqvQKakaNWpw7lzxLlgLCAjg+uuv55133qFnz544Ojry22+/sWrVKhYvXlza5YuISAWQkJLFpEUR7Dp+HoB/Xt+Qqf2b4exUcU48VY1PbSk1bdu2pUOHDuzatYu777670L6hQ4cyfvx4cnJy8PLyKnQb/NXMmzePfv36ERYWRuPGjVm/fj1jx45l2LBhZfESRETERFuPnGHKF5GcSc/B282Z10e2Y0DroL+fWM4UgOzIPffcc9n6SFfSoUMH3N3dadq0aaHtw4cPZ9euXezZs4eLFy/i4eHB448/ftn1PePGjePixYvW71u1asWhQ4f46aefOH/+PM8++yzt2rUrNMeWxxERkYrLYjF475cjvLE2GosBzYO8mT++Iw1qVjO7tCsytRt8RWZLN/iq2IU8NTWV+vXrM3fu3DJbNqC0VOW/BxGRyiQlI5fHv9rN+t8KbnwZHlaXl29rg4dr8a5TLQ22doPXESCxmjp1KuvWraNhw4aMGjXK7HJERKQS2H8qhYkLIjhxLgNXJ0f+M6QVY7oEm36X199RABKrsLAwunTpwsCBA3F21j8NERG5uiU743h2RRTZeRbqVfdg/riOtKnna3ZZNtGnnFj9ebFCERGRomTl5vPciiiW7CpYrPbGZgHMGt0eP09XkyuznQKQiIiI2OzE2QweWBDOgdOpODjA432b8mDvxjg6VuxTXn+lACQiIiI2WXcgkceW7CYtK48a1Vx5944O9GxS8+8nVkAKQCIiInJVefkW3loXw7wNRwDoEOLH3LFh1PHz+JuZFZcCkIiIiBQpOS2bKV9Esu3oWQD+cV0o/xrUAlfnirOqc0koAImIiMgV7Yo9x0OLIkhMzcbT1YlXR7RlSLs6ZpdVKhSAREREpBDDMPh48zFeXX2QPItB41pevDc+jMa1vM0urdQoANmRXbt2ERsbC4CLiwv16tWjbdu2uLi4lNpznDx5kvDwcIYMGVJqjykiIuUnPTuPJ5fuYdW+BABuaVub10a0pZpb1YoMVevVyFXNmTOH77//nhtuuIG8vDwiIyNxdnZm5cqVtGrVqlSeY9u2bUyYMIELFy6UyuOJiEj5iUlM44EF4RxNvoizowP/HtyCu64LrfCrOpeEApCdadWqFUuXLgUgJyeH6667jocffpj169cDcPjwYY4dO0bfvn2tcxITE9myZQvDhw+3bktNTSUiIgIoWEHax8eH5ORktm/fTm5urvU5mjdvTuvWrcvr5YmISAktjzzJtGX7yMzNJ8jHnbnjwuhYv7rZZZUZBSA75urqSr9+/fjwww+t27777js++ugjoqKirNsiIyMZNWoUeXl5APz888+MGDGCZs2a4eXlxZEjR3j33Xdp0KABW7ZsITc3l8WLFwMwbNgwBSARkQosOy+fl777jc+3HwegZ+OavHNHe/y93EyurGwpAJUGw4DcDHOe28UTruHQ5NGjR6lZs3iLWM2YMYN7772X119/HYCUlBR27NhBq1atePzxx5kwYYL1CJCIiFRcJy9k8uDCCPbEXQBgcp/GPHJzU5wq2arOJaEAVBpyM+AVk24L/NcpcK1m8/Dk5GSWLl1KXl4eO3bsYNmyZXz++efFeko3NzeOHz9OZmYmHh4e+Pr60q9fv+JWLiIiJtoYk8wjiyM5n5GLr4cLs0a3o0/zQLPLKjcKQHYmKSmJxYsXk52dzdatWxk4cCDDhg0r1mPMnDmTe+65h4CAAHr06MEtt9zCfffdh7u7exlVLSIipcViMZj902He/jEGw4DWdX2YP64jwTU8zS6tXCkAlQYXz4IjMWY9dzH8+SLoxMREOnXqxNNPP81bb70FgKOjIxaLpdCcrKysQt+3aNGCbdu2cfr0aX766Sdefvll1q5dy3fffXcNL0RERMra+Ys5PPLlbjbGJAMwpksIz9/aEncXJ5MrK38KQKXBwaFYp6EqisDAQN58803Gjh3LfffdR4sWLahbty4nT54kOzsbN7eCC+A2btxYaN7p06epXbs2tWvXZty4cVgsFh5++GEAvLy8yM7OLvfXIiIiV7cn7gIPLozg5IVM3JwdeXlYG27vWM/sskyjAGTnRo0axRtvvMG0adNYvnw5ffv2xd3dnTvuuINhw4axa9culixZUmjO+PHjCQ4OpkePHuTn5zNr1ixGjBgBQJs2bcjPz+fZZ5+lXbt2ug1eRMRkhmGwYMcJXvz2ADn5Fur7ezJ/XEda1vExuzRTVe5OZlIsnTt35oYbbrhs+9tvv42LiwunT5/Gx8eHHTt20LhxYzZs2ECzZs1YuXKlNeAArF27lj59+vDrr78SGRnJs88+y/z58wGoW7cuq1ev5syZM3z55Zfs2bOn3F6fiIgUlpGTx2NL9vDs8ihy8i30axnIykk97T78ADgYhmGYXURFlJqaiq+vLykpKfj4FP6HkpWVxbFjx2jQoIEu/DWR/h5ERIp2NDmdiQsiiE5Mw8nRgSf7N+P+6xtWyVWd/+xqn99/plNgIiIiVczqfaeZunQv6dl51PRyY87YDnRr6G92WRWKApCIiEgVkZtv4bXVB/lo8zEAuoTWYM7YDtTy0VHyv1IAEhERqQISU7OYtCiCnbHnAbj/+oZM7d8MFydd7nslCkAiIiKV3LYjZ5n8RSRn0rPxcnPmjZFtGdC6ttllVWgKQCIiIpWUYRi8t/Eor689iMWA5kHezBsXRsMAL7NLq/AUgK6BbqAzl95/EbFnKZm5PPHVHtYdSARgeFhdXr6tDR6u9reqc0koAJWAk1PBP66cnBw8PDxMrsZ+ZWRkAODi4mJyJSIi5Wv/qRQeXBjB8bMZuDo58p8hrRjTJbjK3+JemhSASsDZ2RlPT0+Sk5NxcXHB0VEXmJUnwzDIyMggKSkJPz8/ayAVEbEHX+2K49/Lo8jOs1DXz4P548NoW8/P7LIqHQWgEnBwcKB27docO3aM48ePm12O3fLz8yMoKMjsMkREykVWbj7/WbmfxTvjAOjdLIBZo9pTvZqryZVVTgpAJeTq6kqTJk3IyckxuxS75OLioiM/ImI3TpzNYOLCcPafSsXBAR69uSmTbmyMo6NOeZWUAtA1cHR0VAsGEREpUz/+lsijX+4mNSuP6p4uvDumA72aBJhdVqWnACQiIlIB5VsM3loXzdyfjwDQPtiPeePCqOOnm29KgwKQiIhIBXMmPZspX0Sy9chZAO7qXp9nBrfE1Vk33ZQWBSAREZEKJPz4OR5aGElCahYeLk68OqINQ9vXNbusKkcBSEREpAIwDINPt8TyyqrfyLMYNAqoxnvjO9Ik0Nvs0qokBSARERGTpWfn8dTXe/l+72kABretzWsj2uLlpo/psqJ3VkRExEQxiWk8sCCco8kXcXZ04JnBLfjHdaFa1bmMKQCJiIiYZMXukzz99T4yc/MJ9HFj3rgwOtavYXZZdkEBSEREpJzl5Fl4+fsDfLatoJvAdY38eXdMB2p6uZlcmf1QABIRESlHpy5k8uDCCHbHXQBg0o2NebRvU5y0qnO5qhAB6OzZsyQnJxMaGmrzyspXmxMfH8+ZM2cKbfPw8KBZs2alVrOIiEhx/RKTzMOLIzmfkYuPuzOzRrfnphaBZpdll0wNQLm5uUyYMIHFixdTq1YtUlJSePvtt7nnnnuuac5LL73E4sWLCQ0NtW5r3LgxS5cuLcuXIyIickUWi8Gcnw8za30MhgGt6vjw3viOBNfwNLs0u2VqAHr55Zf54YcfiI6OJjQ0lEWLFnHnnXfSoUMHOnTocE1zbr75ZgUeEREx3fmLOTy6ZDcbopMBuKNzMP8Z0gp3FzV0NpOpa2p/+OGHTJgwwXqkZuzYsTRr1oyPPvromufk5eURExNDYmJiWZUvIiJyVXvjL3DL7M1siE7GzdmRmbe35dURbRV+KgDTAtDp06c5deoUXbp0KbS9W7duREREXPOclStXMmDAABo3bkzTpk35+eefS/cFiIiIFMEwDBbuOM7t87dx8kIm9f09WfbgdYzqFGx2afI70wLQ2bMFDd78/f0Lbff397/sAubizunduzexsbEcPXqUs2fP0q9fP4YOHcrx48eLrCc7O5vU1NRCXyIiIsWVmZPP40v28Mw3UeTkW7i5RSArJ/WkVR1fs0uTPzEtALm4uAAFwePPsrOzrftKOueOO+4gJCQEAFdXV2bNmgXA8uXLi6xnxowZ+Pr6Wr+Cg5XSRUSkeI6duciweVtYFnkSRwd4akBzPrizI74eV/5cE/OYFoDq1q2Lg4MDp0+fLrT91KlTRYaPksyBguBUq1Yt4uLiihwzbdo0UlJSrF9XGysiIvJXa6JOM2T2Zg4mpFHTy42FE7oxsXcjHLW+T4VkWgDy8vKiS5curFq1yrotKyuLH3/8kZtuusm6LS4ujujoaJvnGIZBTk5OoeeKjY0lNjaW5s2bF1mPm5sbPj4+hb5ERET+Tm5+warODyyIIC07j86h1fl+Sk+6N/L/+8liGlNvg58+fTqDBw+mRYsWdO/enbfffhtvb2/++c9/Wse88MILbN++naioKJvm5Obm0qlTJyZNmkSrVq04ceIEL7zwAi1atGDcuHGmvE4REamaklKzmLQokl9jzwFwX68GPDmgOS5Opt5kLTYw9W+oX79+rFq1ih07djBt2jRq1arF5s2b8fX940KxkJCQQkdu/m6Oq6srK1asICoqiqeffpovvviCe++9l507d+Lh4VHur1FERKqm7UfPMujdzfwaew4vN2fmjwvjmcEtFX4qCQfDMAyzi6iIUlNT8fX1JSUlRafDRETEyjAMPvjlKDPXRpNvMWgW6M388WE0DPAyuzTB9s/vCtELTEREpDJIzcrliSV7+OFAwSK7wzrU5eVhrfF01cdpZaO/MRERERscOJXKgwvDiT2bgauTI8/d2pJxXUNwcNBdXpWRApCIiMjf+GpXHP9eHkV2noW6fh7MGxdGu2A/s8uSa6AAJCIiUoSs3Hxe+HY/X/xasDbcDU0DeHt0e6pXczW5MrlWCkAiIiJXEHcug4kLw4k6mYqDAzxyU1Mm92mshQ2rCAUgERGRv/jpYCKPfrmHlMxcqnu68PYdHbihaYDZZUkpUgASERH5Xb7FYNa6GOb8fBiAdsF+zBsXRl0/rSNX1SgAiYiIAGfTs5myOJIth88C8H/d6/PM4Ba4OTuZXJmUBQUgERGxe+HHz/PQwggSUrPwcHHi1RFtGNq+rtllSRlSABIREbtlGAb/3RrLy9//Rp7FoGFANd4b35Gmgd5mlyZlTAFIRETs0sXsPJ76ei/f7T0NwOA2tXnt9rZ4uemj0R7ob1lEROzOocQ0HlgQzpHkizg7OjBtUAvu6RGqVZ3tiAKQiIjYlZV7TvH013vJyMkn0MeNuWPD6BRaw+yypJwpAImIiF3IybPwyqrf+O/WWAC6N/Tn3TEdCPB2M7cwMYUCkIiIVHmnUzJ5cGEEkScuAPBg70Y81rcpzk6O5hYmplEAEhGRKm3zoTNMWRzJuYs5eLs7M2tUe25uGWh2WWIyBSAREamSLBaDuT8f5q31MRgGtKrjw/xxHQnx9zS7NKkAFIBERKTKuZCRw6Nf7ubn6GQARncK5oWhrXB30arOUkABSEREqpR98SlMXBhO/PlM3JwdeXFoa0Z1Dja7LKlgFIBERKRKMAyDL36N4z8r95OTbyGkhifzxoXRuq6v2aVJBaQAJCIilV5mTj7/Xh7F1xHxANzcIpA3R7XD18PF5MqkolIAEhGRSu3YmYtMXBDOwYQ0HB1gav/m/PP6hjg6alVnKZoCkIiIVFpr9yfwxJI9pGXnUdPLlXfHdOC6RjXNLksqAQUgERGpdPLyLby+Npr3fzkKQKf61ZkzNowgX3eTK5PKQgFIREQqlaTULCZ9Ecmvx84BcG/PBjw9sDkuWtVZikEBSEREKo0dR88y6YtIktOy8XJzZubtbRnUprbZZUklpAAkIiIVnmEYfLjpKK+tiSbfYtA00Iv54zvSKMDL7NKkklIAEhGRCi01K5epX+1h7f5EAG5rX4dXhrfB01UfYVJy+tcjIiIV1m+nU5m4IJzYsxm4ODnw3K2tGN81BAcH3eIu10YBSEREKqSvw+N5Zvk+snIt1PXzYO64MNoH+5ldllQRCkAiIlKhZOXm88K3B/ji1xMAXN80gLdHt6dGNVeTK5OqRAFIREQqjLhzGTy4MIJ9J1NwcICHb2rC5D5NcNKqzlLKFIBERKRC+PlgEo98uZuUzFz8PF14e3R7ejerZXZZUkUpAImIiKnyLQbvrI/h3Z8OA9Cuni9zx4VRr7qnyZVJVaYAJCIipjmbns0jX+5m06EzANzZrT7/vqUFbs5OJlcmVZ0CkIiImCLixHkeWhjB6ZQsPFycmDG8Dbd1qGt2WWInFIBERKRcGYbB/7Yd56XvD5Cbb9CwZjXmj+9IsyBvs0sTO6IAJCIi5eZidh5PL9vHt3tOATCwdRAzb2+Lt7uLyZWJvVEAEhGRcnE4KY0HFkRwOCkdJ0cHpg1szr09G2hVZzGFApCIiJS5b/ec4qmv95KRk08tbzfmjgujc2gNs8sSO6YAJCIiZSYnz8Irq37jv1tjAeje0J93x3QgwNvN3MLE7ikAiYhImTidkslDCyOIOHEBgIm9G/F436Y4OzmaW5gICkAiIlIGthw+w5QvIjl7MQdvd2feGtWevi0DzS5LxEoBSERESo3FYjBvw2HeWheDxYAWtX14b3wY9f2rmV2aSCEKQCIiUipSMnJ5dMlufjqYBMCoTvWYPrQ17i5a1VkqHgUgERG5ZvviU5i4MJz485m4Ojvy4tBWjO4cYnZZIkVSABIRkRIzDIMvd8bx3Mr95ORZCK7hwfxxHWld19fs0kSuqkIEoEOHDpGYmEjz5s2pWbNmqc45d+4cERERhISE0LRp09IqWUTE7mXm5PPsiiiWhscDcHOLWrw5sj2+nlrVWSo+U+9FzMjIYNCgQXTq1InJkycTHBzMG2+8UWpzDMNgzJgxDBgwgHnz5pXFSxARsUuxZy4yfP5WlobH4+gAU/s344M7Oyn8SKVh6hGg559/nv3793Po0CFq1arFqlWrGDx4MNdddx3XXXfdNc957bXXcHNzo3Xr1uXxckRE7MLa/Qk8sWQPadl5+FdzZfaYDlzX2Laj9yIVhalHgD777DMmTJhArVq1ABg0aBDt27fnv//97zXP2bFjB3PnzuXjjz8uq/JFROxKXr6FGat/45+fh5OWnUfH+tX5fkovhR+plEw7AnTy5EmSk5MJCwsrtD0sLIzdu3df05yUlBTGjBnDBx98QEBAgE31ZGdnk52dbf0+NTXVthciImIHktKymPJFJNuPngPgnh4NmDaoOS5a1VkqKdMC0Pnz5wGoUaNwMzx/f3/rvpLOue+++xg8eDADBw60uZ4ZM2bwwgsv2DxeRMRe/HrsHJMWRZCUlk01Vydeu70tt7StY3ZZItfEtOju6uoKQGZmZqHtGRkZ1n0lmfPNN9/www8/0K9fP9avX8/69etJT08nLi6O9evXYxjGFR972rRppKSkWL/i4uKu6fWJiFR2hmHw4S9HGfPhdpLSsmlSy4sVk3oq/EiVYNoRoODgYBwdHYmPjy+0PT4+ntDQ0BLPcXR0pFOnTrzzzjvW/YmJiezcuZOUlBT69OmDg4PDZY/t5uaGm5u6E4uIAKRm5fLkV3tZsz8BgKHt6/DKsDZUc6sQq6eIXDPTjgB5eHjQq1cvli9fbt2WlpbGjz/+SL9+/azbfvvtN7Zv327znKFDh1qP/Fz6atSoEcOHD2f9+vU4Oup8tYjI1RxMSGXonC2s2Z+Ai5MDLw5txduj2yv8SJVi6r/mV155hRtvvJFHH32U7t27M3fuXOrWrcuECROsY9588022b99OVFSUzXNERKRklkXE869v9pGVa6GOrztzx4XRIaS62WWJlDpTD4dcd911bNmyhZSUFD777DO6d+/O5s2bqVbtj67BLVu2pHv37sWa81fdunWjWbNmZfpaREQqs+y8fJ75Zh+PLdlDVq6FXk1q8t2UXgo/UmU5GEVdFWznUlNT8fX1JSUlBR8fH7PLEREpM3HnMnhoUQR741NwcIDJfZrw8E1NcHK8/HpJkYrO1s9vndAVEbFjP0cn8eiXu7mQkYufpwtvj25P72a1zC5LpMwpAImI2KF8i8E7Px5i9k+HMAxoW8+XeePCqFfd0+zSRMqFApCIiJ05dzGHhxdHsunQGQDGdQ3huVtb4ubsZHJlIuVHAUhExI5EnjjPQwsjOJWShbuLI68Ma8PwsHpmlyVS7hSARETsgGEYfL79OC9+d4DcfIMGNasxf3wYzYN0k4fYJwUgEZEqLiMnj2nL9rFi9ykABrQK4vWRbfF2dzG5MhHzKACJiFRhh5PSmbggnENJ6Tg5OjBtYHPu7dngii2BROyJApCISBX1/d7TPLl0Dxdz8qnl7cacsWF0aVDD7LJEKgQFIBGRKiY338KMVQf5ZMsxALo2qMHssR2o5e1ucmUiFYcCkIhIFZKQksVDiyIIP34egAduaMQT/Zri7KRG0CJ/pgAkIlJFbD18hslfRHL2Yg7ebs68Maod/VsFmV2WSIWkACQiUslZLAbzNx7hzR+isRjQPMib98Z3JLRm0U2iReydApCISCWWkpHLY0t28+PBJABu71iPF4e2xsNVqzqLXI0CkIhIJRV1MoWJC8OJO5eJq7Mj04e0YnTnYN3iLmIDBSARkUroy50neHbFfnLyLNSr7sF74zvSuq6v2WWJVBoKQCIilUhWbj7PLo/iq/B4APo0r8WsUe3x9dSqziLFoQAkIlJJHD97kYkLIjhwOhVHB3i8XzMm3tAIR0ed8hIpLgUgEZFK4If9CTz+1R7SsvLwr+bKu2M60KNxTbPLEqm0FIBERCqwvHwLb/wQw3sbjwAQFuLH3HFh1Pb1MLkykcpNAUhEpIJKTstm8hcRbD96DoC7e4QybWALXJ21qrPItVIAEhGpgHbGnuOhhREkpWXj6erEzNvbckvbOmaXJVJlKACJiFQghmHw8eZjzFh9kHyLQeNaXrw3PozGtbzNLk2kSil2AIqNjWXJkiX88ssvxMcX3IYZHBzM9ddfz6hRo6hfv36pFykiYg/SsnJ56uu9rNqXAMCQdnWYMbwN1dz0u6pIabP5RPLRo0e5/fbbadKkCQsWLCAwMJBBgwYxaNAgatWqxf/+9z8aN27MyJEjOXr0aFnWLCJS5UQnpDF0zhZW7UvAxcmBF4a04p072iv8iJQRm/9nde/enfvvv5833niD0NDQK46JjY3l448/pnv37iQmJpZWjSIiVdryyJNMW7aPzNx8avu6M3dcGGEh1c0uS6RKczAMw7Bl4NmzZ/H397fpQYsztqJKTU3F19eXlJQUfHx8zC5HRKqg7Lx8XvzuAAu2nwCgV5OavD26Pf5ebiZXJlJ52fr5bfMRoKsFGsMwOHLkCEFBQXh5eVX68CMiUtbiz2fw0MII9sSnADClT2MevrkpTlrVWaRclGgxiZ07d/LQQw9Zvx87dixNmjQhKCiITZs2lVpxIiJV0YboJG6ZvZk98Sn4erjw6T8681i/Zgo/IuWoRFfXPfHEE7zyyisA7N27l9WrV7Nr1y7Wrl3LM888wy+//FKqRYqIVAX5FoN3fzzEuz8dwjCgTV1f5o0LI7iGp9mlididEgWg8PBwwsLCAFi3bh3Dhw+nY8eONGvWjFdffbVUCxQRqQrOXczhkS9380tMMgBju4bw3C0tcXdxMrkyEftUolNgPj4+1lvdv/32W2688UYALly4oAuGRUT+YnfcBW6dvZlfYpJxd3HkzZHteGVYG4UfEROV6AjQqFGjGDx4MC1btmTfvn3ccsstAKxZs4ZBgwaVaoEiIpWVYRgs2H6c6d8dIDffINTfk/njO9Kitn5RFDFbiQLQG2+8QZMmTTh+/DgzZsygevWC9SqOHDnCc889V6oFiohURhk5efxr2T6W7z4FQP9Wgbw+sh0+7i4mVyYiUIx1gOyN1gESkZI6kpzOxAXhxCSm4+TowNMDmjOhVwMcHHSXl0hZs/Xz2+ZrgEaOHMnBgwf/dtyBAwcYOXKkrQ8rIlKlrNp3miGzNxOTmE6AtxuLJnTlvusbKvyIVDA2nwLr1q0b3bp1o0OHDtx666107NiRwMBADMMgISGBnTt3snLlSvbt28ezzz5bljWLiFQ4ufkWXl19kI83HwOgS4MazBnTgVo+7iZXJiJXUqxTYGfPnuX9999n8eLFREVFcWmqg4MDbdq0YcyYMdx3331VYiVonQITEVslpGQxaVEEu46fB+Cf1zdkav9mODuV6EZbEbkGtn5+l/gaoJSUFE6ePImDgwN16tTB19e3xMVWRApAImKLrUfOMOWLSM6k5+Dt5szrI9sxoHWQ2WWJ2K1S7wX2V76+vlUu9IiI2MpiMXjvlyO8sTYaiwHNg7yZP74jDWpWM7s0EbFBiY/PpqWl8fXXX/P6669bt/3222/opjIRqepSMnO5//NwZq4pCD/Dw+ryzYM9FH5EKpESnQI7ePAgffv2xWKxcOrUKWvoueuuu+jfvz9jx44t9ULLm06BiciV7D+VwsQFEZw4l4GrkyP/GdKKMV2CdZeXSAVR6rfB/9mjjz7KnXfeSXx8fKHtU6ZM4Y033ijJQ4qIVHhLdsYxfN5WTpzLoF51D76eeB1ju4Yo/IhUQiU6AuTn50dsbCx+fn44ODhYjwBdvHiRGjVqkJ2dXeqFljcdARKRS7Jy83luRRRLdhX80ndjswBmjW6Pn6eryZWJyF+V6UXQhmFYQ86ff/M5evSoLowWkSrlxNkMHlgQzoHTqTg4wON9m/Jg78Y4Ouqoj0hlVqJTYP369WPmzJnAHwEoKSmJSZMmMXDgwNKrTkTEROsPJHLL7E0cOJ1KjWqufH5PVyb1aaLwI1IFlOgUWFxcHL1798bR0ZHDhw/Ts2dPIiMjCQoKYtOmTdSuXbssai1XOgUmYr/y8i28tS6GeRuOANAhxI+5Y8Oo4+dhcmUi8nfK9BRYcHAwe/fuZdGiRezatQuLxcLYsWO588478fLyKnHRIiJmS07LZsoXkWw7ehaAf1wXyr8GtcDVWas6i1QlpneDt1gs7Nixg8TERFq3bk3jxo1LZU5GRgbh4eGkp6fTokULQkNDi1WXjgCJ2J9dsed4aFEEianZeLo68eqItgxpV8fsskSkGMp8JWgoCCIZGRmXbbf1KFBKSgoDBgzgxIkTtGzZkq1btzJ58mReffXVa5rz8ccf89JLL9GwYUOcnZ3ZvHkzo0eP5qOPPsLRUb/FiUhhhmHwyZZYZqz6jTyLQaOAarx/Z0ca1/I2uzQRKSMlCkDR0dE88MADbN26lZycnMv223pQ6ZlnnuHcuXMcOHAAX19fNm/eTK9evejbty833XRTiedUr16dvXv34u1d8MNr3759tG3blmHDhnHrrbeW5CWLSBWVnp3HU0v38v2+0wDc0rY2r45oi5fbNf1+KCIVXIn+h991110EBQWxYsUK/Pz8SvTEhmGwcOFCpk2bZr11vmfPnnTp0oUFCxZcMQDZOmf48OGF5l06EpSWllaiWkWkaopJTOOBBeEcTb6Is6MD/x7cgruuC9XChiJ2oEQBaM+ePaxZs6bE4QcgPj6eCxcu0Lp160Lb27Rpw+7du695TkJCAhs2bCA1NZUFCxYwaNAgbr/99iLryc7OLrSAY2pqavFekIhUKssjTzJt2T4yc/MJ8nFn7rgwOtavbnZZIlJOSnRBTGhoKElJSdf0xCkpKQDUqFGj0HZ/f38uXLhwzXMSExNZvnw5S5YsITo6ms6dO+PsXHTemzFjhrXDva+vL8HBwcV8RSJSGWTnFazq/MiXu8nMzadn45p8P6Wnwo+InSnREaDp06dz991389prr9GoUaPLDhcHBQX97WO4ubkBkJ6eXmh7eno67u7u1zynXbt2LF68GIADBw7QpUsXAgMDue+++6742NOmTeOxxx6zfp+amqoQJFLFnLyQyYMLI9gTdwGAyX0a88jNTXHSwoYidqdEAcjf35+oqCh69ep1xf22XAQdEhKCs7MzJ06cKLT9+PHjNGzYsNTmALRs2ZKOHTuyadOmIgOQm5ubNWCJSNXzS0wyDy+O5HxGLr4eLswa3Y4+zQPNLktETFKiU2APPvgggwcPZtOmTezbt++yL1u4ublx00038dVXX1m3nTlzhp9++onBgwdbt+3cuZM1a9bYPCc/P58zZ84Ueq709HRiYmJ0REfEDlksBu+sP8Rdn/7K+YxcWtf14bvJPRV+ROxciRZC9PT0JCEh4ZoXCNy9ezc9e/Zk2LBhdO/enY8++ggHBwe2bt1qPRozYcIEtm/fTlRUlE1zsrKyCAsLY9CgQbRs2ZILFy7w2WefkZGRwebNmwkMtO2HnhZCFKn8zl/M4ZEvd7MxJhmAMV1CeP7Wlri7OJlcmYiUFVs/v0t0BKhJkybEx8eXuLhL2rdvT0REBLVr12bHjh2MHTuWX375pdCpqC5duhRqsPp3c9zd3dm5cycNGzZk27ZtnDhxgscee4z9+/fbHH5EpPLbE3eBW2ZvZmNMMm7Ojrwxsh0zhrdR+BERoIRHgF5//XW++OILXnvtNRo3bnzZRdDFbTtREekIkEjlZBgGC3ecYPq3B8jJt1Df35P54zrSso7+H4vYA1s/v0sUgP5ukTCT24uVCgUgkconIyePZ76J4pvIkwD0axnI6yPb4evhYnJlIlJeyrQX2KFDh0pcmIhIWTianM7EBRFEJ6bh5OjAk/2bcf/1DbWqs4hcUYkCkC0d20VEysvqfaeZunQv6dl51PRyY87YDnRr6G92WSJSgdkcgC7dhdW6dWvrn4vy11YVIiJlITffwsw1B/lw0zEAuoTWYM7YDtTyufJiqiIil9gcgNq0aQMUXN9z6c9FqQrXAIlIxZaYmsWkRRHsjD0PwP3XN2Rq/2a4OJXo5lYRsTM2B6DTp09f8c8iIuVt25GzTP4ikjPp2Xi5OfPGyLYMaF3b7LJEpBKxOQAFBQUxYcIEPvroI5t6fYmIlDbDMHhv41FeX3sQiwHNg7yZNy6MhgFeZpcmIpVMsW6Dd3BwsJvTW7oNXqRiScnM5Ymv9rDuQCIAw8Pq8vJtbfBw1cKGIvKHMr0NXkSkPB04lcrEheEcP5uBq5Mj/xnSijFdgnWLu4iUmAKQiFRoX+2K49/Lo8jOs1DXz4P548NoW8/P7LJEpJIrdgBydv77KXl5eSUqRkTkkqzcfP6zcj+Ld8YB0LtZALNGtad6NVeTKxORqqDYAWjOnDllUYeIiNWJsxlMXBjO/lOpODjAozc3ZdKNjXF01CkvESkdxQ5ADzzwQFnUISICwI+/JfLol7tJzcqjuqcL747pQK8mAWaXJSJVjK4BEpEKId9i8Na6aOb+fASA9sF+zBsXRh0/D5MrE5GqSAFIREx3Jj2bhxdHsuXwWQDu6l6fZwa3xNVZqzqLSNkoVgDKzMwsqzpExE6FHz/HQwsjSUjNwsPFiVdHtGFo+7pmlyUiVVyxApC7uxoMikjpMAyDT7fE8sqq38izGDQKqMZ74zvSJNDb7NJExA7oFJiIlLv07Dye+nov3+8t6Cs4uG1tXhvRFi83/UgSkfKhnzYiUq4OJabxwIJwjiRfxNnRgWcGt+Af14VqVWcRKVcKQCJSblbsPsm0ZfvIyMkn0MeNeePC6Fi/htlliYgdUgASkTKXk2fh5e8P8Nm24wBc18ifd8d0oKaXm8mViYi9UgASkTJ16kImDy6MYHfcBQAm3diYR/s2xUmrOouIiRSARKTMbDqUzJQvIjmfkYuPuzOzRrfnphaBZpclIqIAJCKlz2IxmPPzYWatj8EwoFUdH94b35HgGp5mlyYiAigAiUgpO38xh0eX7GZDdDIAd3QO5j9DWuHu4mRyZSIif1AAEpFSszf+AhMXRHDyQiZuzo68eFtrRnUKNrssEZHLKACJyDUzDINFv57ghZUHyMm3UN/fk3njwmhVx9fs0kRErkgBSESuSWZOPs8s38eyiJMA3NwikDdHtcPXw8XkykREiqYAJCIlduzMRSYuCOdgQhqODjC1f3P+eX1DHHWLu4hUcApAIlIia6JOM/WrvaRl51HTy43ZYzrQvZG/2WWJiNhEAUhEiiU338LMNQf5cNMxADqHVmfO2DACfdxNrkxExHYKQCJis6TULCYtiuTX2HMA3NerAU8OaI6Lk6PJlYmIFI8CkIjYZPvRs0xaFMmZ9Gy83Jx5/fa2DGxT2+yyRERKRAFIRK7KMAw++OUoM9dGk28xaBbozfzxYTQM8DK7NBGpbPKyIXYTxKyFU7vhnrXgaM4RZAUgESlSalYuTyzZww8HEgEY1qEuLw9rjaerfnSIiI3SEuHQDxCzBo78DLkX/9iXsAfqdDClLP0UE5ErOnAqlQcXhhN7NgNXJ0eeu7Ul47qG4OCgW9xF5CoMAxL2FhzliV4NpyIK7/cKgqb9odlAqNnMnBpRABKRK1gaHs8z3+wjO89CXT8P5o0Lo12wn9lliUhFlZMBx34pOMoTsxbSThXeX6cDNB1YEHxqt4MK8IuUApCIWGXl5vPCtwf44tcTANzQNIC3R7enejVXkysTkQon5SQcWgvRa+DYRsjL+mOfiyc06lMQeJr0A+8g8+osggKQiAAQdy6DiQvDiTqZioMDPHJTUyb3aaxVnUWkgMUCpyIhZnXBkZ6EfYX3+wZD0wEFX6E9waVirw2mACQi/HQwkUe/3ENKZi7VPV14+44O3NA0wOyyRMRs2WkFFy7HrC042nMx+U87HSC4S8FRnqYDoFbLCnFqy1YKQCJ2LN9i8Pb6GGb/dBiAdsF+zBsXRl0/D5MrExHTnI8tCDwxayB2M+Tn/LHPzef3U1sDoElfqFbTtDKvlQKQiJ06m57Nw4t3s/nwGQD+r3t9nhncAjdnJ5MrE5FylZ8H8Tv/uIA5+bfC+6s3KLhjq+kACOkOzlXjmkAFIBE7FH78PJMWRXA6JQsPFydeHdGGoe3rml2WiJSXzAtw5MffT239AJnn/9jn4FQQdJr9fj2Pf+NKdWrLVgpAInbEMAz+uzWWl7//jTyLQcOAarw3viNNA73NLk1EytqZw78f5VkDx7eCkf/HPne/gru1mvaHxjeBR3XTyiwvCkAiduJidh5Pfb2X7/aeBmBwm9q8dntbvNz0Y0CkSsrPhRPbCm5Tj1kD544U3h/Q/I8LmOt1ASf7+llgX69WxE4dTkrjgQURHE5Kx9nRgWmDWnBPj1Ct6ixS1Vw8C4fXFQSewz9Cduof+xxdCm5PbzoAmvaDGg3Nq7MCUAASqeJW7jnF01/vJSMnn0AfN+aODaNTaA2zyxKR0mAYkPTbHxcwx/8KhuWP/Z41fz/K0x8a3gjuPubVWsGYHoCys7P54YcfSExMpE2bNnTt2rVU5hw7dozt27fj7OxM165dCQkJKYvyRSqsnDwLr6z6jf9ujQWge0N/3h3TgQBvN3MLE5Fr8+eO6jFr4MKJwvsD2/xxaqtuR9O6rVd0pgagpKQkevfuDUC7du148sknGT58OB999FGJ5xiGwahRo9i9ezedO3cmIyOD//u//+PFF1/kiSeeKOuXJFIhnE7J5MGFEUSeuADAg70b8Vjfpjg76QehSKV0tY7qTm7Q8IY/Qo9vPfPqrERMDUBPP/00Li4ubN++HQ8PD3bv3k3Hjh0ZOnQot956a4nmGIbB6NGjWbJkifX6hkWLFjF+/HiGDRtGo0aNyvMlipS7zYfOMGVxJOcu5uDt7sysUe25uWWg2WWJSHEUp6N6g+vBtZo5dVZiDoZhGGY8scViwc/PjxdeeIFHH33Uur1Xr17Ur1+fBQsWlMocKDhqFBgYyPfff8+gQYNsqi81NRVfX19SUlLw8dE5U6n4LBaDeRsO8+a6GAwDWtXxYf64joT4e5pdmojYohJ2VK+IbP38Nu0IUFxcHGlpabRo0aLQ9hYtWrBr165SmwOwcuVKnJycaNeuXZFjsrOzyc7Otn6fmppa5FiRiuZCRg6PLdnDTweTABjdKZgXhrbC3UWrOotUaJW8o3plZloASktLA8DPz6/Q9urVqxcZPkoyZ//+/Tz++ONMnTqVunWLXul2xowZvPDCCzZWL1Jx7ItPYeLCcOLPZ+Lm7MiLQ1szqnOw2WWJyJVUsY7qlZlpAcjDo6DZ4qVQc0lqaiqenlc+ZF/cOYcPH6Zfv34MGTKEl19++ar1TJs2jccee6zQYwYH60NEKi7DMPji1zj+s3I/OfkWQmp4Mm9cGK3r+ppdmoj8WRXuqF6ZmRaAQkJCcHV15dixY4W2Hz16lCZNmlzznCNHjtC7d2969+7Nf//7Xxz/5jZANzc33Nx0e7BUDpk5+fx7eRRfR8QDcHOLQN4c1Q5fDxeTKxMRwG46qldmpgUgFxcXBg4cyKJFi7jvvvtwcHAgPj6eDRs28MEHH1jH/fzzzyQkJDBmzBib5xw9epTevXtzww038L///Q8nJ10HIVVH7JmLPLAgnIMJaTg6wNT+zfnn9Q1xdNRvjSKmKdRRfQ0kHyy8v4p2VK/MTLsLDCA6OprrrruObt260bVrVxYsWEDdunVZt24dzs4F2WzChAls376dqKgom+ZkZmbSvHlzsrKy+Ne//lUo/PTp04eWLVvaVJvuApOKaO3+BJ5Ysoe07Dxqerny7pgOXNdIvz2KmEId1SukCn8XGECzZs2Iiori888/JzExkX/961+MGzfOGn6gILQ0bNjQ5jkWi8W6htChQ4cKPV/Hjh3L4VWJlL68fAuvr43m/V+OAtCpfnXmjA0jyFcXSIqUK3VUrzJMPQJUkekIkFQUSalZTPoikl+PnQPg3p4NeHpgc1y0qrNI2VNH9UqnUhwBEpGr23H0LJO+iCQ5LRsvN2dm3t6WQW1qm12WSNWmjup2QQFIpAIyDIMPNx3ltTXR5FsMmgZ6MX98RxoFeJldmkjVU5yO6o36gJu3ebVKqVEAEqlgUrNyefKrvazZnwDAbe3r8MrwNni66r+rSKmxtaN6s4FQJ0wd1asg/UQVqUB+O53KxAXhxJ7NwMXJgedubcX4riHWxr4icg1s6qg+oCD4qKN6lacAJFJBfB0ezzPL95GVa6Gunwdzx4XRPtjP7LJEKq+/66juXfuPC5jVUd3uKACJmCwrN5/p3x1g0Y6CQ/DXNw3g7dHtqVFNC6WJFJu1o/pqiPlBHdWlSApAIiaKO5fBgwsj2HcyBQcHePimJkzu0wQnreosYruUk39cwKyO6mIjBSARk/x8MIlHvtxNSmYufp4uvD26Pb2b1TK7LJGKz2IpOJ11aUFCdVSXElAAEiln+RaDd9bH8O5PhwFoV8+XuePCqFfd0+TKRCowdVSXUqYAJFKOzqZn88iXu9l06AwAd3arz79vaYGbsxr2ilxGHdWlDCkAiZSTiBPneWhhBKdTsvBwcWLG8Dbc1qGu2WWJVBx/11G9RsM/LmBWR3W5RgpAImXMMAz+t+04L31/gNx8g4Y1qzF/fEeaBWk1WRF1VBezKACJlKGL2Xk8vWwf3+4puBV3YOsgZt7eFm93F5MrEzGROqpLBaAAJFJGDiel8cCCCA4npePk6MC0gc25t2cDreos9kcd1aUC0r8ykTLw3d5TPLl0Lxk5+dTydmPuuDA6h9YwuyyR8qOO6lLBKQCJlKKcPAszVv/Gp1tiAeje0J93x3QgwNvN3MJEypo6qkslowAkUkpOp2Ty0MIIIk5cAGBi70Y83rcpzk7qIi1VlDqqSyWmACRSCrYcPsOULyI5ezEHb3dn3hrVnr4tA80uS6T0qaO6VBEKQCLXwGIxmLfhMG+ti8FiQIvaPrw3Poz6/uoqLVXEpY7qly5gVkd1qSIUgERKKCUjl0eX7Oang0kAjOpUj+lDW+PuolWdpZL7247qYX8c5VFHdamkFIBESiDqZAoTF4YTdy4TV2dHXhzaitGdQ8wuS6Tk1FFd7IwCkEgxGIbBlzvjeG7lfnLyLATX8GD+uI60rutrdmkixaOO6mLnFIBEbJSZk8+zK6JYGh4PwM0tavHmyPb4empVZ6kk1FFdxEoBSMQGsWcuMnFhBL+dTsXRAR7v14yJNzTC0VEfEFLBqaO6yBUpAIn8jR/2J/D4kj2kZefhX82V2WM6cF1jfVBIBaWO6iI2UQASKUJevoXXf4jm/Y1HAehYvzpzx4YR5KtrIaSCudRRPXpNQfsJdVQX+VsKQCJXkJSWxZQvItl+9BwA9/RowLRBzXHRqs5SUZw5/Ptt6mvVUV2kBBSARP7i12PnmLQogqS0bKq5OvHa7W25pW0ds8sSe5efWxB0Ll3Po47qItdE/0NEfmcYBh9vPsaM1QfJtxg0qeXF/PEdaVzLy+zSxF6po7pImVEAEgHSsnJ5culeVkclADC0fR1eGdaGam76LyLlSB3VRcqNfrqL3TuYkMrEBREcO3MRFycHnrulJeO71cdBF4pKeVBHdRFTKACJXVsWEc+/vtlHVq6FOr7uzB0XRocQXTAqZUwd1UVMpwAkdik7L5/p3x5g4Y6C37Z7NanJO3d0oEY1rYkiZUAd1UUqHAUgsTvx5zN4cGEEe+NTcHCAyX2a8PBNTXDSqs5SmnIyCpqKxqxRR3WRCkgBSOzKhugkHvlyNxcycvHzdOHt0e3p3ayW2WVJVaGO6iKVhgKQ2IV8i8E7Px5i9k+HMAxoW8+XeePCqFfd0+zSpDJTR3WRSksBSKq8cxdzeHhxJJsOnQFgXNcQnru1JW7OTiZXJpWSzR3VB0KtFjq1JVJBKQBJlRZ54jwPLYzgVEoW7i6OvDKsDcPDdFeNFJM6qotUOQpAUiUZhsGC7ceZ/t0BcvMNGtSsxvzxYTQP8jG7NKkM1FFdpMpTAJIqJyMnj2nL9rFid8FdNwNaBfH6yLZ4u7uYXJlUaOqoLmJXFICkSjmclM7EBeEcSkrHydGBaQObc2/PBlrVWa5MHdVF7JYCkFQZ3+89zZNL93AxJ59a3m7MGRtGlwY1zC5LKhJ1VBeR3+l/t1R6ufkWZqw6yCdbjgHQtUENZo/tQC1v3XIsqKO6iFyRApBUagkpWUxaFMGu4wXXazxwQyOe6NcUZyc1jLRbNndUHwCNblRHdRE7pQAkldbWw2eYsjiSM+k5eLs588aodvRvpdV17VJuFhzffPWO6pcuYFZHdRFBAUgqIYvFYP7GI7z5QzQWA5oHefPe+I6E1lQDSbuijuoicg0UgKRSScnI5bElu/nxYBIAt3esx4tDW+PhqlWdqzx1VBeRUmR6AEpJSWHZsmUkJibSpk0bBg0a9Le3LNsyJycnh2XLlnHw4EH+8Y9/EBoaWoavQspD1MkUJi4MJ+5cJq7Ojkwf0orRnYN1i3tVpo7qIlJGTA1AJ06coGfPntStW5dOnToxe/ZsunTpwrJly4r8ULNlzsKFC3nqqado06YNa9asoXfv3gpAldyXO0/w7Ir95ORZqFfdg/fGd6R1XV+zy5KyoI7qIlIOTA1ATz31FLVr12bTpk04OzszefJkWrZsydKlSxk5cmSJ5zRq1IiIiAhycnIIDg4uz5ckpSwrN5/nVkSxZFc8AH2a12LWqPb4empV5ypDHdVFxASmBaD8/HxWrFjBzJkzcXYuKKNp06Zcf/31RQYgW+d069YNgPj4+HJ6NVIWjp+9yMQFERw4nYqjAzzerxkTb2iEo6NOc1R66qguIiYzLQCdOHGCzMxMmjRpUmh7kyZN2LFjR6nNsVV2djbZ2dnW71NTU68yWsraD/sTePyrPaRl5eFfzZV3x3SgR2N12a7UbOmo3mwgNL5ZHdVFpMyZFoDS09MB8PUtfB2Hn5+fdV9pzLHVjBkzeOGFF67pMeTa5eVbeHNdDPM3FLQoCAvxY+64MGr7ephcmRSbtaP677221FFdRCoQ0wKQl5cXUHBH159duHDBuq805thq2rRpPPbYY9bvU1NTdf1QOUtOy2bKF5FsO3oWgLt7hDJtYAtcnbVoXaWReQEOry8IPOqoLiIVmGkBKDg4GA8PDw4dOkT//v2t2w8dOkSzZs1KbY6t3NzccHNzu6bHkJLbGXuOhxZGkJSWjaerEzNvb8stbeuYXZbYQh3VRaQSMi0AOTs7M3ToUD7//HMeeOABnJ2diYmJ4ZdffmHRokXWcStXriQ+Pp4HH3zQ5jlSeRiGwcebjzFj9UHyLQaNa3nx3vgwGtdSf6YKSx3VRaQKcDAMwzDryU+cOEGPHj0IDg6mU6dOLFu2jM6dOxda02fChAls376dqKgom+fs3r2b5cuXk5qayqxZs7jrrrsIDQ2ld+/e9O7d26baUlNT8fX1JSUlBR8fnzJ5/fYuLSuXp77ey6p9CQAMaVeHGcPbUM1NH5gVjjqqi0glYevnt6mfNCEhIURFRfH111+TmJjIe++9x+DBgwstgjhkyBDCwsKKNecSHx8fnn/++XJ5LVI80QlpTFwQztEzF3FxcuDfg1vyf93ra1XnikId1UWkijP1CFBFpiNAZWd55EmmLdtHZm4+tX3dmTsujLAQXRtiOnVUF5EqoFIcARL7kp2Xz4vfHWDB9oIP1l5NavL26Pb4e+nic9Ooo7qI2CkFICkX8eczeGhhBHviC5YwmNKnMQ/f3BQnrepcvtRRXUQEUACScrAxJpmHF0dyISMXXw8X3h7dnhub1zK7LPtRqKP6Wkg7XXi/OqqLiB1SAJIyY7EYvPvTId758RCGAW3q+jJvXBjBNTzNLq3qS4n//VoedVQXEbkSBSApE+cu5vDIl7v5JaagyeXYriE8d0tL3F2cTK6silJHdRGRYlEAklK3O+4CDy2M4OSFTNxdHHn5tjaM6KgLaEudOqqLiJSYApCUGsMwWLD9ONO/O0BuvkGovyfzx3ekRW0tI1BqLnVUj15d0FHdkvvHPnVUFxGxmQKQlIqMnDz+tWwfy3efAqB/q0BeH9kOH3cXkyur5NRRXUSkTCgAyTU7kpzOxAXhxCSm4+TowNMDmjOhVwOt6lxSf9dRvf51f9yqro7qIiIlogAk12TVvtM8uXQv6dl5BHi7MWdMB7o29De7rMpHHdVFRMqVApCUSG6+hVdXH+TjzccA6NKgBnPGdKCWj+4usok6qouImEo/VaXYElKymLQogl3HC07N/PP6hkzt3wxnJ/WGuip1VBcRqTAUgKRYth45w5QvIjmTnoO3mzOvj2zHgNZaSO+K1FFdRKTCUgASm1gsBu/9coQ31kZjMaB5kDfzx3ekQU31iirkUkf16N9DT4o6qouIVEQKQPK3UjJzeXzJHtb/lgjA8LC6vHxbGzxctaoz8HtH9d/bTqijuohIpaAAJFe1/1QKExdEcOJcBq5OjvxnSCvGdAm271vcDQNO7/njAmZ1VBcRqXQUgKRIS3bF8ezyKLLzLNSr7sH8cR1pU8/X7LLMoY7qIiJVigKQXCYrN5/nV+zny11xANzYLIBZo9vj52lnqwxftaN6tYILl9VRXUSkUlIAEgBy8ixsO3qWtfsTWHcgkeS0bBwc4PG+TXmwd2McHe3giIatHdWbDYD66qguIlKZKQDZsYvZeWyITmbt/gR+PphEWnaedV9NLzfeHt2enk2qeENNdVQXEbFLCkB25mx6Nj/+lsTa/QlsOnyGnLw/1qUJ8Hajb8tA+rUM5LpGNXF1rqK3aKujuoiI3VMAsgNx5zL44UAia/cnsCv2HBbjj331/T3p3yqI/q0C6RBcvWqe6lJHdRER+QsFoCrIMAyiE9NYG5XIDwcS2H8qtdD+VnV8fg89QTQN9Kqat7Sro7qIiFyFAlAVYbEYRMadZ+3+giM9x89mWPc5OkDn0Br0axVEv5aBBNfwNLHSMnTm0B+3qaujuoiIXIUCUCWWk2dh65EzrN2fyLoDiZxJz7buc3V2pFfjmvRvFcRNLWrh7+VmYqVlRB3VRUSkhPSJUMmkZ+exITqJH/YnXnbnlrebM31a1KJ/qyCubxqAl1sV/Ou1uaN6f6jRwLw6RUSkQquCn5BVz9n0bNb/lsja/YlsvsKdW/1aBtKvVRDdG/pXvTu31FFdRETKgAJQBRV3LoO1+xP44UDiZXduhf5+51a/VkF0CParenduqaO6iIiUMQWgCuLPd26t3Z/AgdOF79xqXdeH/i2D6N86iCa1quCdW+qoLiIi5UgByEQWi0HEifPWNXqudOdWwZGeQOpVr2J3bqmjuoiImEgBqJz93Z1b1zepSb9WQdzcIpAa1arYgnzqqC4iIhWEAlA5yszJp9uMH0nJ/KP1gre7Mzc1/+POrWpV7c4tdVQXEZEKqIp92lZsHq5ONAvyJvbMRfq1CqRfyyC6VbU7t9RRXUREKgEFoHI2b1wYNTxdq9adW9aO6mvg0A9FdFT//a4tdVQXEZEKQAGonNWsKisy29xRvS9U8zetTBERkStRABLbqKO6iIhUIQpAUjR1VBcRkSpKAai8Hfy+4HZwjIKWDoalYE0cw/KnbX/+3vjj+yLHWAqPu+qYS4/D1cecPayO6iIiUmUpAJW3VVMh9aTZVdhOHdVFRKQK0qdZeQvpVnCXlINjwRcOv//Z4QrfX2nbleY5/On7oh7r0jyKGPOXbZ41oPHN6qguIiJVkgJQebv9E7MrEBERsXtVaAU+EREREdsoAImIiIjdUQASERERu6MAJCIiInZHAUhERETsjgKQiIiI2B3Tb4NPTExk0aJFJCYm0qZNG0aPHo2z89XLsmVOSR5XRERE7IOpR4AOHTpEmzZtWLNmDS4uLjz//PMMGDCA/Pz8a5pTkscVERER++FgGIZh1pMPHz6cM2fOsGHDBhwdHTlx4gSNGzfm448/5s477yzxnJI87l+lpqbi6+tLSkoKPj4+pfaaRUREpOzY+vlt2hGg3NxcVq1axdixY3F0LCgjJCSE3r17s3z58hLPKcnjioiIiH0xLQCdOHGC7OxsGjVqVGh7o0aNOHToUInnlORxAbKzs0lNTS30JSIiIlWTaQEoIyMDAG9v70LbfXx8rPtKMqckjwswY8YMfH19rV/BwcHFeDUiIiJSmZgWgC4FlAsXLhTafv78+cvCS3HmlORxAaZNm0ZKSor1Ky4uztaXIiIiIpWMafeFh4SE4OXlxcGDBxkwYIB1+8GDB2nZsmWJ55TkcQHc3Nxwc3Ozfn/p2nCdChMREak8Ln1u/+09XoaJ7rrrLqNdu3ZGZmamYRiGsWfPHsPR0dFYvny5dczixYuNV199tVhzbBnzd+Li4gxAX/rSl770pS99VcKvuLi4q37Om3obfEJCAjfccAOurq506NCBVatWMXjwYD777DPrmAkTJrB9+3aioqJsnmPLmL9jsVg4deoU3t7eODg4lPg1pqamEhwcTFxcnG6nL2N6r8uP3uvyo/e6/Oi9Lj9l+V4bhkFaWhp16tSx3g1+JaYGIIDMzExWr15tXbG5Z8+ehfavX7+ehIQExo8fb/McW8eUB60nVH70XpcfvdflR+91+dF7XX4qwnttem8IDw8Phg8fXuT+m2++udhzbB0jIiIi9knNUEVERMTuKACVMTc3N55//vlCd5hJ2dB7XX70XpcfvdflR+91+akI77Xp1wCJiIiIlDcdARIRERG7owAkIiIidkcBSEREROyOAlAZOnv2LDt37iQhIcHsUiq1kydPsmfPHtLT04sck5KSwq5du67aw82WMVIgPDycrVu3XnHfxYsXCQ8P5+jRo0XOt2WMQFJSEhEREUU2as7OziYiIoLo6OgiH8OWMfYuPT2dvXv3cuDAAbKysq44Ji8vj927d3PgwIEiWyjYMsbepKSksGXLFk6fPl3kmOTkZHbu3ElSUlKZjykWm3tDSLE899xzhpubm9GyZUvDzc3NuPfee438/Hyzy6pUVq9ebbRr186oU6eO0bZtW8PT09N4+umnLxv37rvvGh4eHkaLFi0MDw8PY/jw4UZWVlaxx0iBFStWGI6Ojoabm9tl+xYuXGh4e3sbTZs2Nby9vY0bb7zRuHDhQrHH2LsLFy4YI0aMMKpVq2Z06tTJCAkJMf73v/8VGrNq1SrD39/faNiwoVG9enWjY8eOxqlTp4o9xt699NJLRrVq1Yw2bdoYjRs3NmrUqGF8/vnnhcZs3rzZqF27thESEmIEBAQYLVu2NA4fPlzsMfbk2LFjxn333WcEBQUZTk5OxuzZs6847oknnij0WTh58mTDYrGUyZjiUgAqA8uXLzdcXFyMLVu2GIZhGAcPHjR8fX2Nd955x+TKKpe5c+cae/bssX6/bds2w83Nzfjss8+s27Zv3244ODgYK1euNAzDME6ePGnUqVPHmDZtWrHGSIG4uDijXr16xuTJky8LQIcOHTJcXFyMDz74wDAMwzh//rzRrFkz4+677y7WGDGMm2++2QgLCzOSk5MNwzCMixcvGp9++ql1f3JysuHt7W1Mnz7dMAzDyMzMNLp162YMHDiwWGPsXUREhAEY33zzjXXbSy+9ZDg7OxupqamGYRhGenq6ERQUZEyZMsUwDMPIy8sz+vfvb3Tu3Nk6x5Yx9mbNmjXG+++/b6SlpRm+vr5XDEALFiwwPDw8jPDwcMMwCvpyenp6Gh9//HGpjykJBaAyMGTIEGPAgAGFtk2YMMFo166dOQVVId26dTPuu+8+6/f333+/0b59+0Jj/v3vfxuBgYHFGiMFP9Svv/56Y86cOcb8+fMvC0DPPfecUbt27UK/dc2ZM8dwd3c3MjIybB5j7zZu3GgAxtatW4scM2/ePMPT09O4ePGiddvSpUsNBwcH6xEeW8bYu7Vr1xqAkZCQYN32888/G4Bx/PhxwzAMY8mSJYajo6ORmJhoHbNhwwYDMPbt22fzGHtWVADq06ePcfvttxfadscddxg9evQo9TEloWuAykBkZCQdO3YstK1Lly5ERUWRm5trUlWVX1paGtHR0TRu3Ni6raj3OjEx0XpO2pYxAtOnT8fLy4uHHnroivsjIyMJCwsr1By4S5cuZGVlcfDgQZvH2Lsff/wRf39/unfvTkxMDFFRUZddlxIZGUmLFi3w9PS0buvSpQuGYbB7926bx9i7Pn360L9/f+655x5Wr17NN998w+OPP87kyZMJCQkBCt7H4OBgatWqZZ3XpUsX6z5bx8jlivrZ++f3rLTGlIQCUBk4d+4c/v7+hbb5+/uTn59PamqqSVVVfhMnTsTd3Z17773Xuq2o9/rSPlvH2LuNGzfy4Ycf8sknnxQ5Ru916Th16hQBAQEMGjSIwYMHM2LECGrXrs3//vc/6xi916XD2dmZSZMmsXfvXqZOncrUqVPJzc3l//7v/6xjrvQ+enh44OHhcdX3+q9jpDDDMLhw4cIV/41mZGSQnZ1damNKSgGoDLi4uFz2G11mZiYArq6uZpRU6U2dOpXvvvuOlStXFvqPYMt7rb+PqzMMg3HjxvGPf/yDQ4cOsXnzZo4cOYJhGGzevNl6lEzvdelwcXHh4MGD3HjjjRw6dIjo6GimT5/OhAkTOHz4sHWM3utrt3nzZoYOHcr7779PVFQUhw8f5u6776Z3797Ex8cDV34fDcMgJyfnqu/1X8dIYQ4ODjg7Oxf5b9TFxaXUxpSUAlAZqF+/PidPniy07eTJk/j5+eHt7W1SVZXXtGnT+OCDD1i7di2dOnUqtK+o99rR0ZF69erZPMaeWSwWQkND+eWXX3j66ad5+umn+eabb8jNzeXpp59m27ZtQNHvI2A9nWDLGHsXGhoKwAMPPGDddv/995OXl8f27dsBvdel5fvvvyc0NJRBgwZZtz344INkZGTw008/AQXv4+nTpwvd1n769Gny8/MLvdd/N0YuFxIScsV/o/Xq1cPR0bFUx5SEAlAZ6Nu3L6tWrSI/P9+6bcWKFfTt29fEqiqnf/3rX8ybN4+1a9fStWvXy/b37duX9evXF1pHZcWKFfTo0QMPDw+bx9gzJycnNm/eXOjriSeewNXVlc2bNzN8+HCg4H3csWNHoTU4VqxYQZMmTahfv77NY+xd//79AQr9QD916hSGYRAQEAAUvI9HjhzhwIED1jErVqygRo0ahIWF2TzG3gUEBHD27NlCRw9Onjx52Xt9/vx5Nm3aZB2zYsUK3N3d6dWrl81j5HJ9+/blu+++swZHwzBYuXJloc/C0hpTItd0CbVc0alTp4xatWoZt99+u7Fy5Urjn//8p+Hp6am7BYrp5ZdfNhwcHIw33njD2LRpk/Vr//791jGpqalGw4YNjX79+hkrVqwwnnrqKcPZ2dnYuHFjscZIYVe6Cyw3N9cICwszunXrZixbtsx4+eWXDScnJ2Pp0qXFGiOGceeddxrt27c3vv76a2PZsmVGp06djM6dOxs5OTnWMf369TNatmxpfPXVV8Y777xjuLm5GfPmzSv0OLaMsWenTp0yatasaQwYMMD49ttvja+++sro0KGD0apVKyMzM9M6bsyYMUZoaKixaNEi44MPPii0vEBxxtiTtLQ0689kLy8v49FHHzU2bdpk/Pbbb9Yxx44dM6pXr26MGzfOWLlypXHXXXcZPj4+xqFDh0p9TEmoG3wZOXbsGDNnziQ6OpqQkBAeffRR2rVrZ3ZZlcqDDz7I3r17L9veo0cPXnvtNev3CQkJvPrqq+zbt4/AwEAeeughevToUWiOLWPkDytWrODdd9/lxx9/LLT9woULvPbaa+zcuZPq1aszYcIE6xGN4oyxd3l5ecyfP5/Vq1fj7OxMt27dePjhh6lWrZp1TEZGBm+99Ra//PILnp6ejBs3jpEjRxZ6HFvG2Lv4+Hjeeecd9u/fj4uLC506dWLy5Mn4+flZx+Tk5DB79mx++OEHXF1dGTFiBP/4xz8KPY4tY+xJdHR0oRtSLrnxxht58cUXrd/HxMTw+uuvc+TIERo0aMATTzxBixYtCs0prTHFpQAkIiIidkfXAImIiIjdUQASERERu6MAJCIiInZHAUhERETsjgKQiIiI2B0FIBEREbE7CkAiIiJidxSARKTcREdHs3btWrPLID8/n02bNrFkyRJiYmLMLkdETOBsdgEiUrXs27eP2NhYAgMDadeuHW5ubtZ93377LQsWLDB1ZWjDMLj55ptJTEykbdu2eHt707RpU9PqERFzKACJSKlISkpiyJAhHDt2jM6dO3P+/HlOnTrFs88+yz333ANA8+bNGTBggKl1xsTEsGHDBk6dOkXt2rVNrUVEzKMAJCKl4sknnyQzM5PY2Fg8PDwAOHPmDOvXr7eOadKkCS4uLtbvFy9efNnjODo6MmrUKOv3hw8fJioqisDAQMLCwgodUSpKeHg4x48fJzg4mM6dO1u3x8TEWJ9z/fr1uLi4cNttt+Hu7l5o/vHjx9m2bRsA1apVo2XLljRq1KjQmKioKBITE+nZsydbt27lzJkzjBw5kp9++omAgADq1KnDjh078PT0pHfv3uzcuZMjR44AULNmTdq1a2ftSA6wd+9eEhIS6NevX6Hn2b17N8nJydfe+VpEClEAEpFSERUVRffu3a3hBwo+6O+44w7r9389BbZ8+fJCjxEREcHx48cZNWoUeXl5TJgwgVWrVtG1a1fi4+O5ePEiK1asKLIJYkZGBkOGDGHv3r106tSJiIgImjdvzrfffou3tzdHjhxh06ZN1locHR0ZOHDgZQEoLi7OWltaWhqbNm3irrvuYvbs2dYxS5cu5fPPP6datWoEBAQQFBTEyJEjmT59Onl5eZw8eZJWrVrRvXt3evfuTWRkJD/99BNQ0Jw3PDyc+fPnM378eKDgCNqtt97KyZMnqVmzpvV57r77bvr166cAJFLarqmXvIjI7x566CHDz8/P+PTTT43ExMQrjnn99deNdu3aXXHfvn37DC8vL2PmzJmGYRjGK6+8YrRv395ITU21jnnkkUeMHj16FFnDf/7zHyMkJMT6/MnJyUZoaKgxbdo065hNmzYZgJGZmWnzazt+/Ljh6+trbNiwwbrt+eefNwDj22+/LTT2hhtuMPz8/Iy4uLirPuaKFSsMHx8f6+uzWCxGw4YNjVmzZlnHREZGGoBx8OBBm2sVEdvoLjARKRWvvvoqd955J4899hiBgYE0bNiQSZMmkZCQ8Ldzz507x9ChQxk6dChTp04F4NNPP6Vdu3asXbuWr776iiVLluDv78+2bdvIysq64uMsXryYCRMmUKtWLaDgCNQDDzxwxVNtfycrK4stW7awdOlStm7dSp06dfj1118LjWnQoAG33HLLZXOHDRtGvXr1Ltt+5swZfvrpJ5YsWUJ6ejrp6ekcPHgQAAcHB+655x4+/fRT6/iPP/6YHj160KxZs2LXLyJXp1NgIlIqvLy8ePfdd5k1axb79u3jl19+4Y033uD7779n3759eHl5XXFeXl4eo0aNokaNGnz00UfW7bGxsdSsWZOlS5cWGj9y5EgyMjIuO20FBdfuNGzYsNC2Ro0aceLECQzDwMHBwabXsmXLFoYPH07NmjVp1KgRnp6enD9/nqSkpELjirqI+krbZ8+ezbRp02jbti21a9e2Xgv158e8++67ef7559m1axdt2rRh0aJFvP766zbVLCLFowAkIqXKycmJ9u3b0759e7p27Uq3bt3YunXrZRf3XvL444+zf/9+du3aVSjU+Pj4cNttt/Hkk0/a/Nw1a9bk3LlzhbadO3cOf39/m8MPwNSpUxk/fjxvvvmmdVunTp0wDKPQuKIe86/bMzIyePTRR/nmm2+49dZbAUhPT+fLL78s9Jh16tRh0KBBfPLJJ9xwww3k5OQUuiBcREqPToGJSKk4duzYZdsunary8/O74pxPP/2U999/n2+++Ya6desW2jdgwAA++eQTcnJyCm0/efJkkTX07NmTZcuWFdq2dOlSevbsactLsEpISCh02unQoUPs3bu3WI/xZ2fOnCE/P7/QY/71yNYlEyZM4IsvvmD+/PmMGjWqyCNnInJtdARIRErFU089RVJSEjfddBMhISEcP36c+fPnM2DAADp27HjZ+NOnTzNx4kQGDRpEbGwssbGxwB+3wb/22mv06tWLrl27ctddd+Hs7MzmzZvJzMxkxYoVV6zhxRdfpHPnzowYMYIBAwawbt06duzYwY4dO4r1Wm677TZeeOEFsrOzyc3NZdasWXh6ehb7PbkkODiYsLAw7rrrLiZMmMDhw4f5+OOPcXS8/HfQwYMH4+npycaNG3n55ZdL/JwicnUKQCJSKpYsWcKWLVv44Ycf+Pnnn6lZsybz5s1jyJAhODk5AYUXQjQMg9tuuw0ofDu8k5MTo0aNom7duuzZs4f//e9/hIeH4+3tzYgRIxgxYkSRNTRq1Ijdu3fz4YcfsmnTJpo0acJrr71GgwYNrGMCAgIYPXq0taYrmTlzJs2aNWPHjh1Uq1aNzz//nO3btxMcHGwd07p16yvO7dOnD82bNy+0zcHBgXXr1jFnzhw2btxI3bp12bp1K9OnT7/syJeTkxO33HILGzdupEePHkXWKCLXxsH460ltERExjcVioVGjRjz00EM88cQTZpcjUmXpCJCISAWxfPlyvv/+ezIyMrj//vvNLkekStNF0CIiFcSaNWtwcnLihx9+wMfHx+xyRKo0nQITERERu6MjQCIiImJ3FIBERETE7igAiYiIiN1RABIRERG7owAkIiIidkcBSEREROyOApCIiIjYHQUgERERsTsKQCIiImJ3/h/tUIfOVK5Q3gAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -703,7 +742,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGxCAYAAAB2qSLdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYihJREFUeJzt3Xd4VFXixvHvTHpIAQKEFjoiTQQUQYooTRQLNlZW1q6oi7qWFVTsiu6quz9X3bXvWhE7VgSRXqQpVUQIvbckpMxkZs7vj5sMGUhgEia5k8n7eZ48ek/OvTkzhOTlVIcxxiAiIiIiAZx2N0BEREQkHCkkiYiIiJRCIUlERESkFApJIiIiIqVQSBIREREphUKSiIiISCkUkkRERERKoZAkIiIiUopouxtQnfl8PrZv305ycjIOh8Pu5oiIiEgQjDHk5OTQuHFjnM6y+4sUkk7A9u3bycjIsLsZIiIiUgFbtmyhadOmZX5eIekEJCcnA9abnJKSYnNrREREJBjZ2dlkZGT4f4+XRSHpBBQPsaWkpCgkiYiIVDPHmyqjidsiIiIipVBIEhERESmFQpKIiIhIKTQnqZL5fD7cbrfdzaiRYmJiiIqKsrsZIiJSTSkkVSK3201mZiY+n8/uptRYtWvXpmHDhtrHSkREyk0hqZIYY9ixYwdRUVFkZGQcc7MqCT1jDHl5eezevRuARo0a2dwiERGpbhSSKonH4yEvL4/GjRuTmJhod3NqpISEBAB2795NgwYNNPQmIiLlou6NSuL1egGIjY21uSU1W3FALSwstLklIiJS3SgkVTLNhbGX3n8REakohSSpdM8//zyffvqp3c0QEREpF81JkgBvvfUWc+fOBawl9BkZGQwfPpz27dsHdf+//vUvGjRowIgRI/xl33zzDaeddhqXXHJJpbRZRESkMqgnSQLMnDmT2bNn07NnT0455RRWrlxJ586d+eyzz4K6f8qUKcyfP7+SWykiIlL51JMkR2nUqBE33HADALfccguHDh3iscceIzExkZkzZ/LUU08F1H/vvffYtm0b9evXZ/ny5WzcuNF//xNPPOGvN2PGDKZNm4bX6+Xyyy+nW7duAc9ZuXIlH374Ifv37+eUU07hT3/6k3+FGljDdi1atKBu3brHfI6IiFRPxhgO5BWyIyufXdkF7Mxy8YfTM3A67ZlfqpAkx9WpUyfmzZtHq1atOPfccxk5ciSdOnUCrB3Fx40bx5133knr1q2pU6cODRo0oGfPnsDhZfjvvvsuCxYs4KKLLmLNmjX07NmTBQsW+APOt99+y0UXXcSf/vQn2rVrx4svvsirr77K/Pnz/SsEv/nmG3799VfatGlT5nNERCQ8FXp97MlxsSOrgF3ZBYH/zSpgZ7b14fYEbsA8sEMDGiTH29JmhaQqYowhv9Bry9dOiImq8Covr9fLDz/8QKdOnWjbti39+vXjzTff5Pnnnwdg6tSp7Ny5k1GjRlG/fn0yMjJo06aNvyepWN26dfnhhx/8exX9/vvv/O9//6Nbt24YY7j99tu5/fbbefbZZwG48cYbadmyJa+++ip//vOfg3qOiIjYI9flYWe2FXZ2FAWeI4PQ3kMujAnuefWSYklPiadRajyF3iBvqgQKSVUkv9BLh4em2PK1Vz82hMTY4P+o165dyw033IDH42HBggVkZWXx9ddfA1Z4ueuuu3jmmWeIiYnhzTffZNiwYdSvX/+Yzzz77LMDNnNs164dW7duBWDbtm38/vvvXHnllf7P165dm/PPP5+ZM2cGhKRjPUdERELLGMP+XLfVy1McfkoEoeKynAJPUM+LiXLQINkKP+mp8TQsCkLpJf7bICWOuOjw2PxXIUmOkpKSQs+ePYmJiWHUqFGceeaZ/mGzyy67jDFjxvDll1/Sv39/vvjiCz7++OPjPrPk3CKAqKgo/4abxUeH1KtXL6BOvXr1WLp0adDPERGR4BV6fezOcVlBxx968tmZ7bKCUHY+u7JdRw1/lSUpLpr0lDgapSYcDj1HBKG0WrG2zS+qCIWkKpIQE8Xqx4bY9rXLo+TE7SPFx8dz1VVX8eabb7Jt2zbq1q3L0KFD/Z+vyLBeRkYGAJs2baJ58+b+8k2bNtGsWbNyP09EpKYrHv4KDECB/y3v8FfDosBT/F8rCCXQMDWO9JR4kuNjKvdF2UAhqYo4HI5yDXmFsxtvvJFu3bqxdu1arr766oDhr7p167J///5yPa9+/fr069eP//u//6NPnz44nU7WrFnDN998w8SJE0PdfBGRaqt4+OvIyc8BASirgBxX8MNf6SlFoSc1nkbFIahEIGqQHE9sdM3cMSgyfmtLlTrllFPo2rUrixcv5tprrw343EUXXcRVV12F2+0mKSkpYAuAY3n55ZcZPHgw3bp1o02bNkybNo2RI0cyfPjwyngJIiJhx+3xsTunwL/0vXgZfMlAtDvbhdsb3PBXcly0f7jryF6g4iBUN7F6DX9VNYUkCXDdddeRk5Nz3Hpdu3YlPj6ek046KaD8kksuYfHixfzyyy/k5uaSkJDA3XfffdR8oz/+8Y/k5ub6rzt27Mi6deuYPn06Bw4cYPz48XTp0iXgnmCeIyISjg65POw8aul7PjuzXP6yfbnlGf6Ko2FqHA1TrOGu4nlAJQNQUpx+xZ8ohzHB/pHIkbKzs0lNTSUrK4uUlJSAzxUUFJCZmUnLli2Jj7dnf4fKkp2dTfPmzXnppZcYOXKk3c05pkj+cxAR+/l8hv157lLn/pTcAyjY4a/YKCcNUuL8E51Lhh7/6q8aPPwVKsf6/V2SYqaUy7333svUqVNp1aoVV1xxhd3NERGpNMXDX0fO9ykZhCoy/HXkknd/INLwV9hRSJJy6datGz169GDo0KFER+vbR0SqJ2v4yxruOrz0vWQIcrH3kCuoZzkckFYrLiD0NCwlAGn4q/rRn5iUS8kNH0VEws2Rw187sksceVHiv4fKMfyVnhpXNOyVQMOUuICl7w1TE2iQHEdMlIa/IpFCkoiIVAtuj49d2Ucvfd9RYhfo3TkFQR9jkRwfXeqKr8N7AMVTt1ZshY91kupPIUlERGyXU1DoDz9HrwKz/rv3kDuoZzkcRau/jrH0vWFKPLU0/CXHoe8QERGpND6fYV+u+3AAKp7/k+ViZ3Z+USBylXv4q1FKQtEeQHFFw2CHA5CGvyRUFJJERKRCioe/jlr5VeK6vMNfJZe+F5/9VbJMw19SlRSSRETkKDkFhf7QU7zXz5GTn/fllm/4q7Sl78XHYWj4S8KRviNFRGoQn8+wN9fFriOWvgecAZZVQK7bG9TzYqOcR833OTII1dfwl1RTCkkSYPHixWzcuBGAmJgYmjZtyimnnEJMTOhOd962bRtLlizhwgsvDNkzRQRcHi+7s10BvT/+8JNd/uGvlPjoouBjLX33L4P3H4cRT53EGA1/ScRSSJIAL774Il9//TVnnXUWHo+HZcuWER0dzeTJk+nYsWNIvsb8+fO54YYbOHjwYEieJxLpjDHkuDz+0BNw9EWJIFSe4a/6SXGlrvgqeZ0Yq18RUrPpb4AcpWPHjnz88ccAuN1uzjzzTO644w6mTZsGwO+//05mZiaDBg3y37Nr1y7mzp3LJZdc4i/Lzs5m6dKlgLVTd0pKCnv27GHBggUUFhb6v8bJJ59Mp06dqurliYSV4uGvnUcsfT9y/k9esMNf0c6AJe8ld3wuLtPwl0hwFJLkmGJjYxk8eDCvvfaav+yrr77i9ddfZ+XKlf6yZcuWccUVV+DxWMt4f/zxRy699FLatWtHUlIS69ev54UXXqBly5bMnTuXwsJCJk6cCMDw4cMVkiQiuTzew3N/ylj6viu7AI8v+OGvRqlHL30vOf+ntoa/REJGIamqGAOFefZ87ZhEq3+9gjZs2EC9evXKdc+ECRO4/vrr+fvf/w5AVlYWCxcupGPHjtx9993ccMMN/p4kkeqmePjLv+y95CqwEj1A+8sx/NUgOS5gp+cjl75r+Euk6ulvXFUpzIOnGtvzte/fDrG1gq6+Z88ePv74YzweDwsXLuTTTz/lnXfeKdeXjIuLY9OmTeTn55OQkEBqaiqDBw8ub8tFqpzXZ9h3yFXqiq+SQ2DlGf46asn7EUGoflIc0Rr+Egk7CklylN27dzNx4kRcLhfz5s1j6NChDB8+vFzP+Nvf/sZ1111H/fr16d27N8OGDePGG28kPj6+klotcnwFhdbqrx1Fy96POvoiq4DdOa6gh79SE2IC5v8Uh56SZRr+Eqm+FJKqSkyi1aNj19cuh5ITt3ft2sVpp53G2LFjef755wFwOp34fL6AewoKCgKu27dvz/z589mxYwfTp0/nySefZMqUKXz11Vcn8EJESmeMIbvAc9SKryODULDDX04H1E8+8uyvwKXvDVPiSYiNquRXJiJ2UkiqKg5HuYa8wkV6ejrPPfccI0eO5MYbb6R9+/Y0adKEbdu24XK5iIuLA2DmzJkB9+3YsYNGjRrRqFEj/vjHP+Lz+bjjjjsASEpKwuVyVflrkeqpePjrWEvfd2QVkF8Y3PBXXPTRmx8eufRdw18iAgpJEoQrrriCZ599lnHjxvH5558zaNAg4uPj+cMf/sDw4cNZvHgxkyZNCrjnqquuIiMjg969e+P1evnHP/7BpZdeCkDnzp3xer2MHz+eLl26aAuAGqyg0Bsw0bm0/+7OceEtx/DXkUdflAxCjVLjSU3Q8JeIBEchSQKcfvrpNG/e/Kjyf/7zn/zjH//w9xAtXLiQl156iRkzZtC9e3cmT57Mc889568/ZcoU3n//fWbPno3T6WT8+PH84Q9/AKBJkyZ8++23fPzxx3z44YdcfPHFCkkRxhhDdr6nzKXvxT1AB/IKg3qe0wENkuP9S98bpSYcHYQ0/CUiIeYwxgT3TzQ5SnZ2NqmpqWRlZZGSkhLwuYKCAjIzM2nZsqUmK9tIfw6h5/UZ9h5yBYSdI5e+7yzH8Fd8jPPoFV8pJc8AS6BeUqyGv0QkZI71+7sk9SSJiF/x8FfJ0HNkECrP8FftxCNWfx2x9L1hioa/RCR8KSSJ1ADFw187/Ds9B4afnRUc/ip1AnSJQKThLxGpzhSSRKo5r8+wJ8d1eMJzVj47s11F/7WOvtiRlU9Boe/4D+Pw8FfA0vfiIzCKyjT8JSI1gUKSSBgrKPSWvvKrxP/vOVSx4a8jj7xomBpPo5QEUhKiNfwlIoJCkogtjDFk5RcePvqijCXwB4Mc/opyOmiQHHfUiq8jl8PHx2j4S0QkWApJlUyLB+1lx/tfPPy1Iyv/8OTnIzY/3JldUK7hL2vJe+lL3xulxlMvKY4op3p/RERCSSGpkkRFWf9id7vdJCQk2NyamisvLw+AmJiYkDyvePirtKXvxUFod04BQY5+UScx5vDBp0f0+jRKTaBhSryGv0REbKKQVEmio6NJTExkz549xMTE4HRqkmtVMsaQl5fH7t27qV27tj+0Hqt+Vn5h4NEXpawCy8ov3/DXkUvfS64A0/CXiEh4U0iqJA6Hg0aNGpGZmcmmTZvsbk6NVbt2berVb2Cd+l5ywnMpE6BdnuCGvxJiokpd+l4yCGn4S0Sk+lNIqkSxsbG0bdsWtzu4k8el/ArcXvbmutiT42LvIRd7D7nZm1PAnkNuMvcVsPngNvbkLC3X8FfAkveUeOvkd///x5MSr+EvEZGaQCGpkjmdTh2HUQHGGA7mFQas9CptFVh5hr/Sk+OKzv46euPDRqkJNEiJ0/CXiIj4KSRJlfN4few55PKHnpIrvkpOhC7P8FfAUvcj9gBqlBpPmoa/RESknBSSJKTy3B5/L8+uEr0/JYPQnhxX0MNfdWvFHrHiq2j+T4kgpOEvERGpDApJcsJcHi83vb2EZZsPkF3gCeqe6JKrv8pY+q7hLxERsZNCkpywJRsPMPO3Pf7rxNioo+f9HDEHSMNfIiIS7mzfvOftt9+me/fuNG3alKFDh7J8+fKQ3BNMnW3btnHTTTfRpk0bTjnlFF588UXtkF0BG/bmAtCnTT2WPzKYVY8OYfo9/Xn/xp48P+JU/nruyfypVwsGd2zIKU1r0yAlXgFJRETCnq0hadKkSdxwww2MGTOGH374gaZNm3L22Weza9euE7onmDo7duzgjDPOYN++fXz22Wd89tlnrF+/njlz5lTqa45EG/ZYIal9o2RS4mM0P0hERCKCw9jYddKlSxd69uzJK6+8AoDX66Vx48aMHj2aRx99tML3BFPnuuuuY+7cuaxatYro6MOjjsaYoH/JZ2dnk5qaSlZWFikpKRV7EyLANW/9xIy1e3hqeGdGntHM7uaIiIgcU7C/v23rScrKymL58uUMHDjQXxYVFcU555zD7NmzK3xPMHWMMXz66aeMHDkyICAB6gWpgMyi4bZW9WvZ3BIREZHQsS0kbd++HYD09PSA8vT0dHbs2FHhe4Kps3v3brKyskhLS+Piiy8mIyODM844g5dffvmYc5JcLhfZ2dkBHzWdy+Nly37rEFmFJBERiSS2haTiMHLkwaPR0dH4fKVvIhjMPcHU8Xq9ANx///1cccUVzJ07l3vuuYd7772X5557rsw2T5gwgdTUVP9HRkZGUK81km3Zn4fPQFJcNPWT4uxujoiISMjYFpLq168PwJ49ewLK9+zZ4/9cRe4Jpk5aWhpRUVGMGDGCkSNH0qxZMy6//HKuvfZa3nnnnTLbPG7cOLKysvwfW7ZsCfblRqz1ew4PtWmoUkREIomtIally5ZHrSabNWsWZ5xxRoXvCaZOXFwcXbt2JSEhIaBOYmIihYVlnwUWFxdHSkpKwEdNV7yyrWU9DbWJiEhksXULgNtvv53XX3+dhQsX4vF4+Nvf/sb27du5+eab/XX+8pe/0Ldv33LdE0ydu+66i/fee49ly5YBsGLFCv73v/9xySWXVMErjxyZew8B0Kpeks0tERERCS1bd9y+44472L17NwMHDsTlctGkSRM+/fRTTjrpJH+dnJwcDhw4UK57gqlz5ZVXsnPnTgYNGkReXh7x8fHccMMNPPzww1Xz4iPEhj1a2SYiIpHJ1n2Sivl8PnJzc0lOTj7qc4cOHcLj8VC7du2g7ylPHWMMubm5JCWVvydE+yRBt8ensj/XzVdj+tCpSardzRERETmuYH9/h8XZbU6ns8wgU1Z4OdY95anjcDgqFJAEDua52Z/rBjQnSUREIo/tZ7dJ9VV8ZlvDlHhqxYVF3hYREQkZhSSpsEzNRxIRkQimkCQVtqF4ZZtCkoiIRCCFJKmww3skaU6XiIhEHoUkqTAdbCsiIpFMIUkqxOcz/pDUWj1JIiISgRSSpEK2HczH5fERG+WkSZ2E498gIiJSzSgkSYUU9yI1T0skyqmDbUVEJPIoJEmFbNhjrWzTJpIiIhKpFJKkQg5P2tZ8JBERiUwKSVIhG7SyTUREIpxCklRI8R5JrTTcJiIiEUohScqtoNDLtoP5gIbbREQkcikkSbkVz0eqnRhD3VqxNrdGRESkcigkSbkdPo5EQ20iIhK5FJKk3DKLD7bVTtsiIhLBFJKk3PyTtrWyTUREIphCkpSbf/m/httERCSCKSRJuRhj/Ltta2WbiIhEMoUkKZd9uW6yCzw4HNa5bSIiIpFKIUnKpXj5f5PaCcTHRNncGhERkcqjkCTlooNtRUSkplBIknIpXtnWWvORREQkwikkSbnoYFsREakpFJKkXDTcJiIiNYVCkgTN4/WxeX8eoOX/IiIS+RSSJGhbD+RT6DXExzhplBJvd3NEREQqlUKSBG1D0ZltLdJq4XQ6bG6NiIhI5VJIkqBpZZuIiNQkCkkStOKVbZq0LSIiNYFCkgTt8JltCkkiIhL5FJIkaJn+PZI03CYiIpFPIUmCcsjlYVe2C9Bwm4iI1AwKSRKUjUW9SPWSYklNiLG5NSIiIpVPIUmCsr54PlI9DbWJiEjNoJAkQSle/q+hNhERqSkUkiQomTrYVkREahiFJAlK8W7b6kkSEZGaQiFJjssYQ+YeLf8XEZGaRSFJjmt3jotct5cop4NmdRPtbo6IiEiVUEiS4ype2ZZRJ4HYaH3LiIhIzaDfeHJc2mlbRERqIoUkOS4t/xcRkZpIIUmOSwfbiohITaSQJMflH27TbtsiIlKDKCTJMbk9PrYcyAfUkyQiIjWLQpIc0+b9eXh9hlqxUTRIjrO7OSIiIlVGIUmO6fB8pCQcDofNrREREak6CklyTBv2amWbiIjUTApJckyHjyNRSBIRkSq04xdY+IqtTYi29atL2NPBtiIiUqWyd8D0x+Hn98HhgJb9oEF7W5qikCTHVLyRZGvtti0iIpXJnQfz/gVz/wmFeVZZx0shLtm2JikkSZmy8grZl+sG1JMkIiKVxOeDFZNg2qOQs90qa9oDhjwFGafb2jSFJClT8VBbekocteL0rSIiIiG2aR5MuR+2L7OuU5vBoEeg4yXWUJvN9JtPyqSdtkVEpFLs3wBTH4Y1k63r2GToexf0vBVi4u1tWwkKSVKmDVrZJiIioZR/EGY/a61a87rB4YRuV8PZ90NSA7tbdxSFJCmTVraJiEhIeD2w5C348SnI32+VtT4HBj8J6R3sbdsxKCRJmbSyTURETogxsG4qfP8g7F1rldVrB0OehDYDw2Le0bEoJEmpfD7Dxn3abVtERCpo1yqY8gBs+NG6TkyD/uOg+7UQVT3iR/VopVS57Vn5FBT6iIly0LROgt3NERGR6uLQbvjxSVj6NhgfRMXCGaOh792QUNvu1pWLQpKUqnhlW/O0WkRH6fQaERE5jsICWPASzH4e3NacVjpcBAMfgbqtbG1aRSkkSamK5yNpqE1ERI7JGFj5ibUZZNZmq6xxVxgyAZr3srdtJ8j2kLR48WL+/e9/s2vXLjp37sw999xDWlraCd9zvDr/93//x5dffhlwT8uWLXnttddC9+KqMf8eSVr+LyIiZdmyCKaMg62LrOuUJjDgYeh8OTir/yiEra9g3rx59O7dm+TkZEaNGuW/zs3NPaF7gqmzZs0a3G43Y8eO9X9cf/31lfp6q5P1e6yu0lbqSRIRkSMd3AwfXwdvDLQCUkwinP0A/HkxdBkREQEJwGGMMXZ98f79+1O3bl0+/fRTAHJycmjcuDFPPPEEd9xxR4XvCabO6NGj2bt3Lx9//HGF25+dnU1qaipZWVmkpKRU+DnhqPfT09l2MJ+PRvfi9BZ17W6OiIiEg4JsmPMPmP8SeF2AA7r+Ec5+EFIa2d26oAX7+9u2qJefn8/s2bO5+OKL/WXJyckMGDCA77//vsL3lOe5S5cu5cILL2TUqFG8+uqreL3ekL2+6qyg0Mv2rHxAPUkiIgL4vLD4LfhXN5jzvBWQWvSFm2fBRS9Vq4BUHraFpC1btuDz+WjatGlAedOmTdm4cWOF7wn2uXFxcVxwwQVcc8019OjRg8cff5whQ4bg8/nKbLPL5SI7OzvgIxJt3JeLMZASH03dWrF2N0dEROy0fjr8py98dSfk7oG6reEPH8DVX0KjU+xuXaWybeK22+0GICEhcA+exMRE/+cqck+wz33qqaeoVetwL8nAgQPp1KkTn376KZdddlmpX3/ChAk8+uijx31t1d3hM9uScIT5bqgiIlJJ9qy1dspeVzQKE18b+o+F066H6JrxD2jbepLq1KkDwP79+wPK9+3b5/9cRe4J9rklAxJA+/btadGiBUuXLi2zzePGjSMrK8v/sWXLljLrVmda2SYiUoPl7oOv74GXe1kByRkNPW+F25dBz1tqTEACG0NSkyZNqF+//lGhZOnSpZx66qkVvqcizwXw+Xzs37+f+Pj4MuvExcWRkpIS8BGJtLJNRKQG8rhg7gvwQldY9BoYL7Q7H25dCOdOgMSat4jH1jV6V199NW+88Qa7d+8G4JtvvuHnn3/m6quv9td5/vnnufHGG8t1z/HqFBYW8tJLL/knahtjeOSRR8jJyWH48OGV+6KrgcM9STrYVkQk4hkDq7+Al3rA1PHgyoKGneFPk+HK96FeG7tbaBtbN5N89NFHWbVqFW3btqV169asWbOGv/3tb/Tu3dtfZ/Xq1SxYsKBc9xyvTlRUFL///jtNmjShZcuWbN26FWMMH374IZ07d666NyAMGWO027aISE2xbal1CO3medZ1UjoMeAi6XAnOKHvbFgZs3Sep2G+//cauXbto37499erVC/jcmjVryMrKomfPnkHfE2ydnJwcVq9eTZ06dWjZsiUxMTHlanck7pO075CL7k9Mw+GANY+dS3yM/pKIiEScrG3ww2OwfKJ1HZ0AvW+HM2+HuMgfRQj293dYhKTqKhJD0uKN+7nsP/NpUjuBuWPPsbs5IiISSq5DMO8Fa+6Rx9oPj1P+AAPGQ2rTY98bQYL9/W372W0SXg4v/9dQm4hIxPB54ZcP4IfH4dBOq6xZLxjyFDTpZm/bwphCkgRYv1cr20REIkrmLJhyP+xcYV3XaQGDHoP2F4L2wjsmhSQJkLlHK9tERCLC3t9h6kOw9mvrOi4F+t0LZ9wM0XH2tq2aUEiSABv2amWbiEi1lrcfZv0dfnoVfB5wRMFp10L/cVCr9IVOUjqFJPHz+gyb9mlOkohIteQthEWvw4ynoeCgVdZ2MAx6HBqcbGvTqiuFJPHbeiCPQq8hLtpJ49SE498gIiL2MwbWfmttBLnvd6usfnsY8iS0GWBv26o5hSTxK7mJpNOpyXwiImFvx3L4/gFrcjZArfpw9gPQdRRE6Vf8idI7KH4bdLCtiEj1kLMTpj8Oy94DDETFQa/boM9fID4y9u0LBwpJ4reh6GBbTdoWEQlT7jyY/xLM+QcUWv+wpdOlMOBhqNPc3rZFIIUk8fNvJFlPy/9FRMKKzwcrPoIfHoXsbVZZk9Pg3AmQ0cPetkUwhSTxyyxe/q/hNhGR8LFpvrUZ5Pal1nVqBgx8xOpB0maQlUohSQDIdXnYmV0AQGv1JImI2G9/Jkx7GFZ/YV3HJkHfu6DnrRCjFchVodwhaePGjUyaNIlZs2axdetWADIyMujXrx9XXHEFzZtrTLQ6Ku5FSqsVS2pijM2tERGpwQqyYNazsPA/4HWDw2mtVjvnQUhqYHfrahRnsBU3bNjAZZddRtu2bXn33XdJT0/nvPPO47zzzqNBgwa8/fbbtGnThssvv5wNGzZUZpulEminbRERm3k98NNr8EJXmPeCFZBa9YebZ8OFLygg2SDonqRevXpx00038eyzz9KiRYtS62zcuJE33niDXr16sWvXrlC1UapA8co2Lf8XEbHBuqkw5QHYu9a6rncSDH4S2g7SvCMbBR2SVq9eTVpa2jHrtGjRgscff5w777zzRNslVSxzrw62FRGpcrtWw/cPwvofrOuEunD2/dD9GojS1Ae7BR2SjhWQjDGsX7+ehg0bkpSUdNwwJeGn5G7bIiJSyQ7tgR+fhKX/A+MDZwyccTP0uxcSatvdOikS9JykkhYtWsRtt93mvx45ciRt27alYcOGzJ49O2SNk6phjPH3JLXWcJuISOUpLLA2gnyhKyx5ywpI7S+EP/9knbWmgBRWKrQFwD333MNTTz0FwPLly/n2229ZvHgxU6ZM4YEHHmDWrFkhbaRUrj05Lg65PDgdkFE30e7miIhEHmNg1acw9RHI2myVNToVhjwFLXrb2TI5hgqFpCVLltCtWzcApk6dyiWXXEL37t1p164dTz/9dEgbKJVvfdFQW0bdROKio2xujYhIhNm6GL4bB1t/sq6TG8PAh6HzFeCs0ICOVJEKhaSUlBQ2bNhAx44d+fLLL7n++usBOHjwICkpOlivuvFP2tZ8JBGR0Dm4GaY9Cis/tq5jEqH3nXDmnyFWP2+rgwqFpCuuuILzzz+fDh06sGLFCoYNGwbAd999x3nnnRfSBkrlO3ywrVa2iYicMFeONe9o/kvgKQAccOpIOGc8pDSyu3VSDhUKSc8++yxt27Zl06ZNTJgwgTp16gCwfv16HnrooZA2UCrfBv/yf/3LRkSkwnxeWPYuTH8CcndbZc37WBOyG59qa9OkYioUkqKjowNWtxWbMGHCCTdIql6mQpKIyIlZ/6O1GeTuVdZ13VYw+Alod542g6zGgp4xdvnll/Prr78et97q1au5/PLLT6hRUnXcHh+b9+cB0ErDbSIi5bPnN3h/BLxzsRWQ4lNhyAS4dSGcfL4CUjUXdE9Sz5496dmzJ127duWCCy6ge/fupKenY4xh586dLFq0iMmTJ7NixQrGjx9fmW2WENpyIA+vz5AYG0V6SpzdzRERqR7y9sOMCbDoDTBecEbD6TfAWfdBYl27WychEnRIuvvuu7nmmmt45ZVX+O9//8s999yDMQYAh8NB586dufLKK/niiy+043Y1UnKnbYf+xSMicmweN/z0Ksz6GxRkWWXtzoNBj0G9tva2TUKuXHOS0tLSuP/++7n//vvJyspi27ZtOBwOGjduTGpqamW1USrR4YNtNdQmIlImY2DNlzD1ITiQaZWld4YhT0Cr/rY2TSpPhSZuA6SmpioYRQDtkSQichzbl1mTsjfNta6T0q3l/KeOBKc24I1kFQ5JOTk5fP/992zYsIF7770XgDVr1nDyySdr2KYaKR5u08o2EZEjZG+HHx6DXz6wrqPj4cwx0PsOiEu2t21SJSoUkn799VcGDRqEz+dj+/bt/pD09NNPM2TIEEaOHBnSRkrl2bC3aLhNK9tERCzuXJj7Asz9P/DkW2Wdr7COEkltam/bpEpV6NCYv/zlL4waNYqtW7cGlN9+++08++yzIWmYVL6s/EL2HnID0KKeDrYVkRrO54Of34d/dYeZT1sBKaMn3DAdLn1NAakGqlBP0vz58/nggw+OGlY7+eSTWbVqVUgaJpWveD5Sg+Q4kuNjbG6NiIiNNs6BKffDjl+s69rNrRVrHS7SXkc1WIVCkjEGl8sFEBCUNmzYoMnc1Uhm8VCb5iOJSE21b721Yu3Xr6zruBTodw/0uBli4u1tm9iuQsNtgwcP5m9/+xtwOCTt3r2bP//5zwwdOjR0rZNKdXiPJM1HEpEaJv8AfHc/vHSGFZAcTjjterh9mTUxWwFJqGBP0vPPP0///v2ZPHkyPp+Pvn37smzZMho2bMjEiRND3UapJMUhqbV6kkSkpvAWwuI3rd2y8w9YZW0GweDHoUF7e9smYadCISkjI4Ply5fz/vvvs3jxYnw+HyNHjmTUqFEkJalXorrYoINtRaSmMAZ++w6+fxD2/W6V1W9vbQbZZqC9bZOwVeF9kmrVqsWNN97IjTfeGMr2SBXx+Yx/TpKG20Qkou1cYW0GmTnTuk6sB+c8AF3/BFEV/jUoNcAJfXf4fD7y8vKOKldvUvjbkV1AQaGPaKeDjDoJdjdHRCT0cnbB9Mdh2buAgahY6Hkr9L0L4rXISI6vQiFp7dq1jB49mnnz5uF2u4/6fPHBtxK+MovmIzVLSyQ6qkLz90VEwlNhPsx/EWb/Awqtn3V0vMTaDLJOC1ubJtVLhULS1VdfTcOGDfniiy+oXbt2iJskVUE7bYtIxPH5YOUnMO0RyC7a7LhJdxgyAZqdYWvTpHqqUEj65Zdf+O677xSQqjGtbBORiLJ5gbUZ5LYl1nVKUxj0qNWD5FRvuVRMhUJSixYt2L17t0JSNVa8sq1lPYUkEanGDmy0eo5WfWZdxyZBn79Ar9sgRvMt5cRUKCQ99thjXHvttTzzzDO0bt36qONJGjZsGJLGSeXZsKd4t20Nt4lINVSQBbOfgwX/Bq8bcEC3UXD2g5CcbnfrJEJUKCSlpaWxcuVK+vbtW+rnNXE7vBUUetl20DrZWnskiUi14vXA0v/Bj09B3l6rrOVZMORJaNjZ3rZJxKlQSLr11ls5//zzufXWWzXkVg1t2peHMZAcH01arVi7myMiEpx10+D7B2DPr9Z1WlsY/AScNESH0EqlqFBI2rx5Mz/99BMpKSmhbo9UgZJDbUcOlYqIhJ3da6ydsn+fZl0n1IH+4+C06yAqxt62SUSrUEhq27YtW7dupUOHDqFuj1QB/3EkmrQtIuHs0B6Y8RQs+S8YHzhj4Iybod89VlASqWQVCklXXXUVV111Fc888wxt2rQ5qjeiRYsWoWibVJLi5f8KSSISlgoLYOF/rInZrmyrrP0FMPBRSGttb9ukRqlQSPrrX/8KwODBg0v9vCZuh7fiM9u0sk1EwooxsPpzmPowHNxklTXqAkOeghZ9bG2a1EwVCknr1q0LdTukCmmPJBEJO1uXwJRxsGWhdZ3cCAY8DKeM0GaQYpsKhaQ2bdqEuh1SRfbnujmYVwgoJIlIGDi4BX54DFZMsq5jEqH3HXDmGIjVzyixV9AhaeXKlQB06tTJ//9l6dSp04m1SipN8VBb49R4EmKjbG6NiNRYrkMw958w71/gKbDKuoyEAeMhpbGtTRMpFnRI6tzZ2qTLGOP//7JoTlL4Wl88aVvzkUTEDj4v/PweTH8CDu2yypr3tjaDbNzV3raJHCHokLRjx45S/1+qF//KNu20LSJVbcMMmPIA7CoajajTEgY/DicP02aQEpaCDkkNGzbkhhtu4PXXX9fZbNVY8XCb5iOJSJXZuw6+Hw+/fWtdx6XCWX+FHjdBtHb9l/BVriUDb7zxRmW1Q6rIBg23iUhVydsP3/wVXu5pBSRHFPS4GW5fBmf+WQFJwl6FVrdJ5crcm0uuy0Pr+kkhnVzt9Rk27csDtJGkiFQijxsWvQYzn4GCLKvspKEw6DGof5K9bRMpB4WkMPSHV+ezK9vFV2P60KlJasieu+1APm6vj9hoJ41rJ4TsuSIigLUZ5K9fw9TxsH+DVZbeyTqEtvXZ9rZNpALKHZKio49/i8fjqVBjxBIXbfUeuTy+kD53ffF8pLRaRDk1SVJEQmj7z9YhtBtnW9e1GljL+U/9Izi13YhUT+UOSS+++GJltENKiI+xpoq5Cr0hfW7mHu20LSIhlr0Dpj8OP78PGIiOh15/hj53Qlyy3a0TOSHlDkmjR4+ujHZICZXVk7TBf2abQpKInCB3Lsx70doQstCa60jny62jRGpn2No0kVCxfU7Svn37mDRpErt27aJz584MHz4c53HO6QnmnvI8d9myZXz44Yf06dOHYcOGhey1VVRcdFFPkifEPUl7tbJNRE6QzwfLP7SOEsnZbpVlnGEdQtv0NHvbJhJitp4amJmZSefOnfnwww/Jzc3l7rvv5oILLsDnK7sHJZh7yvPcrKwsrrjiCv7zn/8wbdq0Snmd5RUfY/UkFRSGuCdJw20iciI2zoXX+sPno62AVLsZXPYWXDdFAUkiUrl6kvLz80P6xe+77z5atGjBDz/8QFRUFLfccgvt2rXjww8/5Morr6zwPeV57k033cSVV17J5MmTQ/raTkRl9CTluT3syLLOR2qt4TYRKY9962Haw7DmS+s6Nhn63QNnjIaYeHvbJlKJytWTFB8fur8MHo+HL7/8kquuuoqoKKvnpFWrVpx11ll8+umnFb6nPM997bXX2LhxIw899FDIXlcoVEZPUvFQW91asdRO1AZuIhKE/IPWMSIvnWEFJIcTTrvO2gyyz50KSBLxbJuTtHnzZgoKCmjTpk1AeZs2bZg/f36F7wn2uatXr+aBBx5g3rx5QW1rAOByuXC5XP7r7OzsoO4rr8roSdJQm4gEzVsIi9+CGRMgf79V1nqAdQhtg/b2tk2kCtkWknJzrV/aKSkpAeWpqan+z1XknmDq5OfnM2LECCZMmHBUmDqWCRMm8OijjwZdv6Li/FsAhK4nyX8ciUKSiJTFGFj3vbXf0d7frLL6J8PgJ6HtQHvbJmID2yZuJyVZK6yysrICyg8ePOj/XEXuCabOu+++y5YtW1i3bh1jx45l7Nix7Nixg7lz5zJ27NgyJ46PGzeOrKws/8eWLVvK85KDVrwFQEEIe5L8B9tqPpKIlGbXKnjnYnj/CisgJabB+c/B6LkKSFJj2RaSmjVrRq1atVi7dm1A+dq1a2nfvvTu3GDuCaZO9+7dGTt2LLVr1/Z/REVFERcXR+3atXE4St+NOi4ujpSUlICPylApPUnFy//rafm/iJSQswsm3w7/6QMbZkBULPS+w5p3dPoNEGX7TjEitrHtuz8qKorhw4fz9ttvM3r0aGJjY1m9ejVz5sxh0qRJ/nqffvopmzdv5s477wzqnmDqdOvWjW7dugW0Z+LEiZx22mmMHTu26t6EMsSHuCfJGOPfbVsr20QEgMJ8WPAyzH4e3FZPMx0uhoGPQN2WdrZMJGzY+k+Ep59+mr59+9KrVy+6d+/O5MmTueyyyxg+fLi/zjfffMOCBQu48847g74nmDrhLNQ9SXsOuchxeXA6oFlaYkieKSLVlDGw8hOY9ghkFU0ZaNwNzp0AzXra2jSRcGNrSGrSpAnLly9n8uTJ7Nq1iyuuuIKBAwPHvi+99FJ69epVrnuCqXOkO+64g2bNmoXuxZ2AUB9LUjxpu2mdRP+zRaQG2vITfDcOti22rlOaWD1HnS6D45x0IFIT2T7YnJSUxMiRI8v8/NChQ8t9T7B1Srr22muDrlvZig+4LQjRAbfFeyRp+b9IDXVgk9VztKpor7iYWtD3L9DzNohV77JIWWwPSXK00Pck6WBbkRqpIBvmPA/zXwavC3BA16vgnAchuaHdrRMJewpJYSjUPUn+PZJ0sK1IzeD1wLK3YfqTkLfXKmvZzzqEtmFne9smUo0oJIWhUPckZe7VRpIiNcbvP1ibQe5ebV2ntYHBT8BJ50IZ25uISOkUksJQ8bEkoehJKvT62Lw/D9Bwm0hE2/2rFY5+n2pdx9eG/uPg9OshKsbWpolUVwpJYaj4gFt3CHqStuzPw+MzJMRE0TBFh1GKRJzcvdYZa4vfAuMFZzT0uBn63QOJde1unUi1ppAUhg4fcHviIankwbZl7SQuItWQxwULX4FZz4Kr6Bimk4fBoMcgrbW9bROJEApJYai4JykUw20b9mplm0hEMQZWfwFTH4KDm6yyhqdYk7Jb9rW3bSIRRiEpDIWyJ0mTtkUiyLYlMOUB2Dzfuk5qCAMegi5/AKc2ihUJNYWkMBQXwi0A1mv5v0j1l7UVfngMln9oXUcnWIfQ9r4dYvUPIJHKopAUhooPuPX4DB6vj+ioih8XcHiPJP0gFal2XIdg7v/BvH+BJ98q63IlnDMeUpvY2zaRGkAhKQwV9yQBuE8gJGUXFLL3kAvQkSQi1YrPCz+/D9Mfh0O7rLJmZ8KQJ6FJN3vbJlKDKCSFoZKH0BYU+kiMrdhzMot6keonx5Ecr31SRKqFzFkw5X7YucK6rtMCBj0O7S/QZpAiVUwhKQxFfXo9H8au5t7Cm3B5Kj4vSZO2RaqRvb/D1PGw9hvrOi4VzroXetwE0XH2tk2khlJICkdbfuIM5xZqc4iCwoqvcNPBtiLVQN5+mPk3WPQa+DzgiLJ2yT5rLNRKs7t1IjWaQlI4irZ2xo7HfUI9Sev9PUla2SYSdjxuWPwGzHgaCg5aZW2HwODHoX47W5smIhaFpHAUkwBAgsN9Qj1JmSV22xaRMGGMNaT2/XjYv94qa9ARhjwBrc+xt20iEkAhKRwVhaR4XLgquFeSz2cOz0nScJtIeNjxi7UZ5MbZ1nWt+nDOg9B1lDaDFAlDCknhyB+S3BXedXtndgH5hV6inQ4y6iaGsnUiUl7ZO2D6E/Dze4CBqDg488/Q5y8Ql2x360SkDApJ4SjGCjXWcFvFepKKe5Ga1U0k5gQ2oxSRE+DOg/kvwpx/QqH1d5JOl8HAh6F2M1ubJiLHp5AUjgImblesJ0kr20Rs5PPBikkw7VHI2W6VNe1hHUKbcbq9bRORoCkkhaPiniQq3pO0Ya8mbYvYYtM8azPI7cus69RmMOgR6HiJNoMUqWYUksJRTFFPksN1Aj1JOthWpErtz4SpD8GaydZ1bDL0vQt63ur/Oy0i1YtCUjgKwcTtDXuLhtvUkyRSufIPwuxnYeEr4HWDwwndroaz74ekBna3TkROgEJSOIou2icJNzkVGG5zebxsPWCdGN5Sc5JEKofXA0veghkTIG+fVdbqbOsQ2vSO9rZNREJCISkclehJ2luBnqRN+/IwBpLjoqmfpDOfRELKGFg3Fb5/EPautcrqtbPCUZuBmnckEkEUksKRfwuAim0mWXJlm0M/sEVCZ9cqazPIDT9a14lp0H8cdL8WovTjVCTS6G91OCqeuE1hheYkaWWbSIgd2g0/PglL3wbjg6hYOGM09L0bEmrb3ToRqSQKSeGoqCcpHleFtgDQyjaRECksgAUvw+znwZ1jlXW4CAY+AnVb2do0Eal8CknhqGgzyQRHxVa3ZaonSeTEGAMrP7E2g8zabJU17gpDJkDzXva2TUSqjEJSOPL3JLlxeU5sTpKIlNOWRTBlHGxdZF2nNIEBD0Pny8GpI35EahKFpHBUNCcpARcFheXrSTqQ6+ZAXiGgniSRcjm42eo5WvmxdR2TaB1A2+vPEKtDokVqIoWkcFS0BUCco7DcPUnFk7YbpcaTGKs/XpHjcuVYc47mvwReF+CAU/8I5zwIKY3sbp2I2Ei/RcOR/+y28vckaahNJEg+Lyx7B6Y/Abl7rLIWfa39jhp1sbdtIhIWFJLCUXTxFgDln5NUPGm7VT2tbBMp0/rpMOVB2L3Kuq7bGgY/Ae2GajNIEfFTSApH/p4kNy53OYfb9mhlm0iZ9qy1dspe9711HV8b+o+F066H6FhbmyYi4UchKRwVTdx2Ogw+T0G5bvUfbKvhNpHDcvdZZ6wtfhOMF5zR0OMm6HcvJNa1u3UiEqYUksJRTImVNIXBhySvz7BxXx6g4TYRADwu+OlVmPl3cGVZZe3Oh0GPQb029rZNRMKeQlI4iorBOKNx+Dw4PPlB37b9YD5uj4/YaCdN6iRUYgNFwpwxsOZLmPoQHMi0yhp2hsFPQquz7G2biFQbCklhykTH43AfwlGO4bb1RSvbWqQlEuXU5FOpobYttQ6h3TzPuk5KhwEPQZcrwRllb9tEpFpRSApX0QngPkSUtwBjDI4gVtzoOBKp0bK2wfTH4ZcPrOvoBDhzDPS+A+I0/Cwi5aeQFK6KNpRMwIXL4yM+5vj/AtbBtlIjuQ7BvBdg7gtQPDx9yh9gwHhIbWpv20SkWlNIClfF57cVHXIbTEhST5LUKD4f/PI+/PA4HNpplTXrBUOegibd7G2biEQEhaQw5YgpsaFkoRcSYo57T/Fu2621/F8iXeZsmHI/7FxuXddpYa1Ya3+hNoMUkZBRSApTjuKeJKyepOPJc3vYnmVN8tbyf4lY+9ZbK9Z+/cq6jkux9jo642aIjrO3bSIScRSSwlWJOUkFhcffdXvjXmt/pNqJMdSppZ2DJcLkH4CZf7P2PPJ5wBEFp10L/cdBrXp2t05EIpRCUrgqCknxjsKgepL8O21rPpJEEm8hLHoDZj5tBSWAtoNh0OPQ4GR72yYiEU8hKVwFrG47fk+SVrZJRDEGfvvOOmdt3+9WWf32MORJaDPA3raJSI2hkBSuog9P3C4oPH5Pkla2ScTYsRy+fwAyZ1nXterD2Q9A11EQpR9ZIlJ19BMnXAVsARBMT5JWtkk1l7MTpj8By94FDETFQa9boc9dEJ9id+tEpAZSSApXRVsAWBO3j92TZIxhg78nScNtUs2482D+SzDnH1BofR/T6VIY8DDUaW5v20SkRlNIClcBWwAcuydp7yE3OQUeHA5onpZYFa0TOXE+H6z8GKY9AtnbrLImp8G5EyCjh61NExEBhaTwVTxx2+HGdZyepOKhtqZ1EoLamVvEdpvmW5tBbl9qXadmwMBHrB4kbQYpImFCISlcRRdtAYCLnOPsk5SpoTapLvZnWj1Hqz+3rmOToO9d0PNW/z8MRETChUJSuCreJ4nj75NUPB9JeyRJ2CrIglnPwsL/gNcNDqe1Wu2cByGpgd2tExEplUJSuArYcTu44TatbJOw4/XA0v/Cj09B3j6rrFV/GPwkNOxkZ8tERI5LISlc+XfcPv7Eba1sk7C0bpq139GeX63reifB4CesHbM170hEqgGFpHAVXbwFwLE3kyz0+ti8zzq3rZV6kiQc7Fpt7ZS9/gfrOqEunH0/dL8GomJsbZqISHkoJIWroi0A4o6zBcDWA/l4fIb4GCcNU+KrqnUiRzu0B2Y8BUv+C8YHzhg442bodw8k1LG7dSIi5aaQFK5KbgFwjInbxfORWtZLwunUEIbYoLAAFv4bZj0H7hyrrP2FMOhRqNvK3raJiJwAhaRwFTBxu+yepMMH22qoTaqYMbDqM5j2MBzcbJU1OhWGPAUtetvaNBGRUFBIClf+LQCO05Ok5f9ih62L4btxsPUn6zq5MQx8GDpfAU6nvW0TEQkRhaRwVbyZpKMQl7uwzGrFw23qSZIqcXAL/PAorPjIuo5JhN53wpl/hlh9D4pIZLE9JPl8PhYuXMiuXbvo1KkTbdq0Cck9wdTJy8tjyZIlHDp0iPbt29OiRYtQvKTQKLH7sM9TUGY1Lf+XKuHKsQ6gnf8SeAoAB5w6Es4ZDymN7G6diEilsDUkZWVlce6557J582Y6dOjAvHnzGDNmDE8//fQJ3RNMnTfeeIMnnniCVq1aER0dzZw5cxgxYgSvv/46znAYLih5RENhfqlVcgoK2ZPjAtSTJJXE54Vl78L0JyB3t1XWvA8MeRIan2pr00REKputIemBBx5g//79rF69mtTUVObMmUPfvn0ZNGgQAwYMqPA9wdSpU6cOy5cvJzk5GYAVK1ZwyimnMHz4cC644IKqeQOOxRmFzxmD01dYZkgqPrOtXlIcKfHaf0ZCbMMMmPIA7FppXddtBYMeh5PP12aQIlIj2NZlYozhvffe4/rrryc1NRWAPn360KNHD959990K3xPscy+55BJ/QAL8PUo5OTmV8norwlc0L8npOXZI0qRtCak9v8H7I+Dti6yAFJ8KQybArQuh/TAFJBGpMWzrSdq6dSsHDx6kU6fA85s6d+7Mzz//XOF7yvPcnTt3MmPGDLKzs3n33Xc577zzuOyyy8pss8vlwuVy+a+zs7OP8ypPjImOB3c2jjJ6ktZr+b+EUt5+mPE0LH4DfB5wRsPpN8BZ90FiXbtbJyJS5WwLSVlZWQDUrRv4wzctLY2DBw9W+J7yPHfXrl18/vnn7N27l7Vr1zJmzBiio8t+SyZMmMCjjz56zNcVSqaoJ8nhLX3itla2SUh43PDTqzDrb1Bg/f2h3Xkw6DGo19betomI2Mi2kBQXFwfAoUOHAsoPHTpEfHzpx2sEc095ntulSxcmTpwIwOrVq+nRowfp6enceOONpX79cePGcdddd/mvs7OzycjIKPtFnqiiydtRxxlu08o2qRBj4Nev4PvxcCDTKkvvDEOegFb9bW2aiEg4sC0kNWvWjOjoaDZv3hxQvmnTJlq1Kv0og2DuqchzATp06ED37t2ZPXt2mSEpLi7OH8KqRFFIcnpdR33KGHN4TpJ6kqS8ti+zJmVvmmtdJ6Vby/lPHQnOKHvbJiISJmybuB0XF8eAAQP46KOP/GV79+5l+vTpnH/++f6yRYsW8d133wV9TzB1vF4ve/fuDWjPoUOH+O233yq3Z6icnEUhKc648HgDd93emV1AnttLlNNBRp1EO5on1VH2dvjsFnj1bCsgRcdDv3thzBLoNkoBSUSkBFu3AHj66afp06cPo0aNolevXrz++uu0b9+ea665xl/nlVdeYcGCBZx77rlB33O8OoWFhfTr14/zzjuPDh06cPDgQf73v/+RlJTE7bffXoXvwLE5Yq3wk+BwUeDxkRR1ONNmFk3ablY3kdjoMNjXScKbOxfmvgDzXoDCPKus8xXWUSKpTe1tm4hImLL1t+upp57K0qVLadSoEQsXLmTkyJHMmjUrYEirR48eDB06tFz3HK9OfHw8ixYtolWrVsyfP5/Nmzdz1113sWrVKtLT06vuDTgOZ1FIiqMQ1xGH3K7X8n8Jhs8HP78P/+oOM5+2AlJGT7hhOlz6mgKSiMgxOIwxxu5GVFfZ2dmkpqaSlZVFSkpK6L/ApzfB8g95snAk19z7PE1qH96F+7EvV/Pm3Exu6NOSB4d1CP3Xlupv4xyYcj/s+MW6rt3cWrHW4SLtdSQiNVqwv79tP7tNjqFoTlI87qN6kjbsLV7+r5VtcoR962HqQ9bKNYC4FOh3D/S4GWJKXzkqIiJHU0gKZ0X7JCU43Lg8gRO3N2gjSTlS/gGY9SwsfAV8heBwQvdr4ez7oVY9u1snIlLtKCSFsxI9SQUlepJcHi9bD1iTbzUnSfAWwuI3YcYEKygBtBkEgx+HBu3tbZuISDWmkBTO/CHJFdCTtHlfHj4DSXHR1E+uwn2bJLwYA79Nge8fhH3rrLL67a3NINsMtLdtIiIRQCEpnMUcHm4r2ZO0wb/Tdi0cmoBbM+1cYW0GmTnTuk6sB+c8AF3/BFH6ay0iEgr6aRrOSk7cLtGTpPlINVjOLvjxCVj6DmAgKhZ63gp974L4VLtbJyISURSSwlnxxG3cZAeEpKKVbTqzreYozIf5L8Gcf4C76FzCjsNh4CNQp4WdLRMRiVgKSeGsuCfJ4WZ3ieE2/8G26kmKfMbAio9h2iOQvdUqa9IdhkyAZmfY2jQRkUinkBTOypi4vUG7bdcMmxdam0FuW2xdpzSFQY9Cx0vAqaNoREQqm0JSOPOHpMPHkhzMc7M/1w1YE7clAh3YBNMehlWfWdexSdDnL9DrNv/3hIiIVD6FpHAWU3TAbYmepOJepIYp8dSK0x9fRCnIgtnPw4J/g9cFOKDbKDj7QUgOnzMFRURqCv2WDWfR1hESJbcA0Mq2COT1wNL/wY9PQd5eq6zlWTDkSWjY2d62iYjUYApJ4ayoJ6nkFgCZRWe2aagtQvw+DaY8CHvWWNdpbWHwE3DSEB1CKyJiM4WkcFZ0GGk8Lv+cpMM9SVr+X63t/hW+f8AKSQAJdaD/ODjtOoiKsbdtIiICKCSFt6KepFiHF7fbmqyt4bZqLnevNay25L9gvOCMgTNuhn73WEFJRETChkJSOCuakwTgc+fj8xky92n5f7XkccHC/8CsZ8GVbZWdPAwGPQZpre1tm4iIlEohKZwFhKQ8th3Mx+3xERPloGmdRBsbJkEzBlZ/DlMfhoObrLJGXWDIU9Cij61NExGRY1NICmdOJx5nPNG+Aown37/8v3laLaKcmtQb9rYusTaD3LLAuk5uBAMehlNGaDNIEZFqQCEpzPmi4sBXgKMwn0z/mW0aagtrWVth2qOwYpJ1HZMIve+AM8dArP7sRESqC4WkMOeNToDCLEzh4Z4krWwLU65DMPefMO9f4CmwyrqMhAHjIaWxrU0TEZHyU0gKc6ZoXpLTk+8/2FY9SWHG54Wf34PpT8ChXVZZ897WZpCNu9rbNhERqTCFpDBnoovO6vIUaPl/ONowE6Y8ALtWWNd1WsLgx62Va9oMUkSkWlNICnPFPUleVx7b8vIBDbeFhb3r4Pvx8Nu31nVcKpz1V+hxE0TH2ts2EREJCYWkMOco2lCysMDqRUpNiKFOonZktk3efpj5DCx6HXwecETB6TfAWfdBrTS7WyciIiGkkBTuYq3htniHteN2q/q1cGgYp+p53FYwmvkMFBy0yk4aam0GWf8kW5smIiKVQyEpzDlirJCUgBWSdLBtFTMGfv0apo6H/RussvRO1iG0rc+2t20iIlKpFJLCnDPWGm6LLwpJrTUfqers+MWalL1xtnVdq4G1nP/UP4Izyt62iYhIpVNICnNRRcNtCQ4XoOX/VSJ7B0x/HH5+HzDW8TC9/gx97oS4ZLtbJyIiVUQhKcw546xQFE8hAC21/L/yuHNh3ovWhpCFeVZZ58uto0RqZ9jaNBERqXoKSWHOWTQnKR4XDge0SFNICjmfD5Z/CD88BjnbrbKMM6xDaJueZm/bRETENgpJYa7kxO3GqQnEx2guTEhtnGsdQrvjZ+u6djMY+Ch0HK7NIEVEajiFpHBXtE9SvMOtnbZDaf8GmPoQrPnSuo5Nhn53wxm3QEy8vW0TEZGwoJAU7op+YSfg0sq2UMg/CLP+DgtfAV8hOJzQ/Rrofz8k1be7dSIiEkYUksJdzOEtALRH0gnwFsKS/8KPT0H+fqus9QDrENoG7W1tmoiIhCeFpHBXdHZbvMNN+0YpNjemGjIG1n0P3z8Ie3+zyuqfDIOfhLYD7W2biIiENYWkcFfUk9S2ThS1W9SxuTHVzK5V1maQG360rhPT4Oz7ods1EKVvfREROTb9pgh3RXOS6sR4tdoqWId2w49PwtK3wfggKhZ63gJ974b4VLtbJyIi1YRCUrgr6kmiMN/edlQHhfmw4GWY/Ty4D1llHS6GgY9A3ZZ2tkxERKohhaRwV7RPEh6FpDIZAys/gWmPQNYWq6xxNzh3AjTraWvTRESk+lJICndFE7fVk1SGLT9Zm0FuXWRdpzSxeo46XQZOp61NExGR6k0hKdyVHG4zRvOSih3YZPUcrfrUuo6pBX3+Ar1ug9hEW5smIiKRQSEp3BXv/my81l4/0bH2tsduBdkw53mY/zJ4XYADul4F5zwIyQ3tbp2IiEQQhaRwF1OiV6Qwr+aGJK8Hlr1jrVrL3WOVtexnHULbsLO9bRMRkYikkBTuomIBB2DAU2B3a+yxfrq139Hu1dZ1WhsY/AScdK6GH0VEpNIoJIU7h8PqTSrMtXqSapI9a62dstd9b13H14b+4+D06yEqxtamiYhI5FNIqg5iEopCUg3pScrdCzOehsVvWnOxnNHQ42bodw8k1rW7dSIiUkMoJFUHxXslRfo2AB4XLHwFZj0Lriyr7ORhMOgxSGttb9tERKTGUUiqDopD0qc3WpOVm/eG5r0gtam97QoVY2D1FzD1ITi4ySpreIo1KbtlX3vbJiIiNZZCUnVw8jBr2fv+9dbHkres8trNoNmZ0PxMKzilta5+E5m3LbEmZW+eb10nNYQBD0GXP4Azyt62iYhIjeYwxhi7G1FdZWdnk5qaSlZWFikpKZX7xXL3WUFi0zzYPA92/GId3lpSrfpWYCoOTukdwzdoZG2DHx6F5R9a19EJ0PsOOHMMxCXZ2zYREYlowf7+Vkg6AVUako7kyrGO5Ng0zwpPWxcXba5YQlyKdXZZs15WT1Pjrvbvs+Q6BHP/D+b96/B5dF2uhHPGQ2oTe9smIiI1gkJSFbA1JB2psAC2L7VC06Z5VoBy5wTWiY6HpqcXhaYzIaMHxNaqmvb5vPDLB/DD43Bop1XW7EwY8iQ06VY1bRAREUEhqUqEVUg6ktcDu1bApvmwaa7V25S3L7COIwoan3p4iK5Zz8pZYp85yzqEducK67pOCxj0OLS/oPrNoRIRkWpPIakKhHVIOpIxsPe3wz1Nm+ZB9taj6zXoUBSainqbUhpX/Gvu/d1asbb2a+s6LhXOuhd63ATRcRV/roiIyAlQSKoC1Soklebg5sCepr2/HV2nTgtrPlNxaKrb6vi9P3n7Ydbf4adXweexeqxOvx7OGgu10irlpYiIiARLIakKVPuQdKRDewJX0O1ccfQKuqT0w1sONOtl9Tw5ndbnPG5Y/Ia1W3bBQaus7RAY/DjUb1elL0VERKQsCklVIOJC0pEKsotW0BX1NG1bAl53YJ34VCssNe4KyydZ+zgBNOgIQ56A1udUfbtFRESOQSGpCkR8SDpSYT5sK15BN9cKUIW5gXVq1YdzHoSuo8J3jyYREanRgv39rR23JXgxCdCit/XBvdYKup2/WPOati2xhtR63QZxyXa3VERE5IQpJEnFRUVDk+7Wh4iISIRx2t0AERERkXCkkCQiIiJSirAISTk5OWzcuJHCwsKQ3hNMnT179nDgwIFytVdEREQin60hyePxcPPNN1OvXj169OhBeno677333gnfE0ydV155hbZt29KxY0datmxJx44dmTVrVshfo4iIiFRPtoakp59+ms8++4wVK1awe/dunn32Wa6++mqWL19+Qvccr47X62XZsmV899137N69m7179zJo0CAuvPBC9u7dW+mvW0RERMKfrfskZWRkMGrUKJ566il/2cknn8ygQYP417/+VeF7KvLcHTt20LhxY7799lvOPffcoNpf4/ZJEhERiQDB/v62rSdp586dbN26lZ49ewaU9+rViyVLllT4noo8F2D16tUANG3atNyvRURERCKPbSFp3759ANSrVy+gvF69emUOeQVzT0Wem5OTw5gxYxg6dCidOnUqs80ul4vs7OyADxEREYlMtoWkqCjryAq3O/AsMJfLRXR06XtcBnNPeZ+bn5/PRRddhNPp5J133jlmmydMmEBqaqr/IyMj45j1RUREpPqyLSQ1adIEh8PBjh07Asp37txZ5pBXMPeU57kFBQVceOGF7Nq1i+nTp5OWlnbMNo8bN46srCz/x5YtW4J6rSIiIlL92BaSkpOT6d69O999952/zO12M23aNPr37+8v27lzJ5mZmUHfE+xziwPStm3bmD59Og0aNDhum+Pi4khJSQn4EBERkchk69ltjz76KBdeeCGnnHIKvXr14vnnnyc+Pp7Ro0f76zz44IMsWLCAlStXBn3P8ep4vV6GDx/OL7/8wqRJkzhw4IB/Q8lGjRqRmppahe+CiIiIhCNb90k677zz+Pzzz5kyZQq33HIL8fHxzJkzh7p16/rrNGrUiFatWpXrnuPVycnJITMzkzp16nDzzTdz8cUX+z+mTp1adW+AiIiIhC1b90mq7rKysqhduzZbtmzR0JuIiEg1kZ2dTUZGBgcPHjzm6JGtw23VXU5ODoBWuYmIiFRDOTk5xwxJ6kk6AT6fj+3bt5OcnIzD4QjZc4sTrnqoKpfe56qh97nq6L2uGnqfq0Zlvs/GGHJycmjcuDFOZ9kzj9STdAKcTmel7tCtFXRVQ+9z1dD7XHX0XlcNvc9Vo7Le52AWadk6cVtEREQkXCkkiYiIiJRCISkMxcXF8fDDDxMXF2d3UyKa3ueqofe56ui9rhp6n6tGOLzPmrgtIiIiUgr1JImIiIiUQiFJREREpBQKSSIiIiKlUEgKM1lZWSxevJgtW7bY3ZRqwRjDunXr+PXXX3G73WXW27lzJ4sWLWLfvn2VXifSLVq0iIULF5b6uZycHBYvXszGjRvLvD9UdSLZwYMHWbJkCVlZWaV+3uv1snz5clasWIHP56vUOpHK6/Wybt06li5dyv79+8ust2HDBpYsWUJubm6l14kUK1asKPNnBFgbMa9YsYLly5fj9Xptr3NMRsLGCy+8YBISEkz79u1NQkKCueSSS0xBQYHdzQpbL774osnIyDBt27Y1bdu2NfXq1TNvv/12QB2Px2Ouv/56Ex8fbzp06GDi4uLMQw89VCl1aoL333/fOJ1Ok5aWdtTnXnvtNZOYmGjatWtnatWqZYYOHWoOHTpUKXUildvtNrfeeqtJSEgw3bp1MxkZGebJJ58MqLN06VLTvHlz06RJE9OwYUPTunVrs2LFikqpE6lmzZplWrRoYZo2bWq6du1qEhISzHXXXWc8Ho+/zsGDB83ZZ59tkpOTzUknnWSSk5PNe++9F/CcUNWJFG+++aY59dRTTZ06dUr9GWGMMcuXLzetW7c2jRo1Mk2aNDHNmzc3S5cuta3O8SgkhYkFCxYYh8NhJk+ebIwxZtu2baZx48Zm3LhxNrcsfD3yyCNm27Zt/ut///vfJioqyqxatcpf9s9//tPUrl3brF271hhjzOzZs010dLT54osvQl4n0v3++++mSZMm5pZbbjnqB+Dy5cuN0+k077//vjHGmN27d5sWLVqYMWPGhLxOJBs9erTJyMgwv//+uzHGCuf/+c9//J93u92mVatW5uqrrzbGGOPz+czll19uTj75ZOP1ekNaJ5K1atXKjBo1yv9aV6xYYaKjo80777zjr3PNNdeYDh06mIMHDxpjrJ8vMTEx/j+bUNaJFGPHjjVLliwx//jHP0oNSV6v15x88slmxIgRxufzGWOMueqqq0yrVq1MYWFhldcJhkJSmLjpppvMqaeeGlD24IMPmvT0dJtaVP14PB4TFRVl3njjDX/ZKaecYkaPHh1Qb+DAgeaiiy4KeZ1I5nK5zGmnnWb++9//mr///e9H/QC86667TJs2bQLKnn76aZOamur/13mo6kSqzZs3G6fTeVRvaEnff/+9AQJ+wf78888GMLNnzw5pnUiWnJxsXnzxxYCyevXqmeeff94YY0xeXp6Jj48PCKher9ekp6ebhx9+OKR1IlFZIWnWrFkGMCtXrvSXrV271gBm6tSpVV4nGJqTFCaWLVtG9+7dA8p69OjBrl272LFjh02tql6WLVuG1+ulTZs2ABQWFrJq1apS39dly5aFtE6kGzduHC1btuTqq68u9fNlff9mZWWxYcOGkNaJVDNmzMDn8zFs2DA2b97Mzz//zKFDhwLqLFu2jNTUVFq3bu0v69KlC7Gxsf7vxVDViWRPPfUUzz33HO+++y5Tp07lpptuolGjRvzpT38CYM2aNRQUFAR8LzqdTrp37+5/f0JVpyZZtmwZcXFxdOzY0V920kknkZKSEvC9WVV1gqGQFCb2799PWlpaQFnx9bEmFYolNzeXG264gbPOOou+ffsC1iR4r9db6vta/J6Gqk4k+/bbb/noo4945ZVXyqwTzPdvqOpEqu3bt5OSksK9995L7969GTVqFA0aNGDChAn+OqW9PxD4vRiqOpFs2LBhtGrVivvuu497772XTz75hNtuu+2o77Vj/Z0PVZ2apCq/f0P1PR4ddE2pVDExMRQUFASU5efnAxAbG2tHk6qNgoICLr74YtxuN5MmTcLhcADWe1r8+ZLy8/P972mo6kQql8vF1VdfzZgxY1i1ahUAGzduxOPxMGfOHE466SQaNGgQ1PdvqOpEqpiYGLKzs4mJiWHTpk04nU6++eYbhg0bRo8ePRgwYECp7w8c/f0aijqRyuVycfbZZzN48GCmTJlCVFQUq1evpmfPnkRFRXHDDTfoZ0clqcrv31B9j6snKUw0b96cbdu2BZRt27YNp9NJ06ZNbWpV+HO5XFx88cVs2bKF6dOn06BBA//nUlNTqV27dqnva7NmzUJaJ1IVFhZy0kknMWXKFMaOHcvYsWP5+uuvyc3NZezYsSxZsgQo+/sX8L9HoaoTqVq0aAHATTfdhNNp/Wg+77zzyMjIYPbs2YD1/uzduzdgu4vc3FyysrIC3sNQ1IlUK1euZOPGjYwePZqoqCgAOnTowNlnn83kyZMB6/0Bjvl3PlR1apLmzZtz4MAB8vLy/GUul4t9+/YFvGdVVScYCklhYtCgQUybNi3gD/SLL76gd+/eJCQk2Niy8FUckDZu3MiPP/5Iw4YNj6ozcOBAvvzyS/+1x+Ph66+/ZtCgQSGvE4mSkpKYM2dOwMdtt91Gamoqc+bMYejQoYD1/Ttr1qyAfX2++OILunbt6u/yDlWdSNW/f39iY2MDfqHm5eVx4MAB6tevD8CAAQMoLCzku+++89eZPHkyTqeTc845J6R1IlXxe7l169aA8q1bt/o/16JFC9q0aeMPTQA7duzgp59+8v+dD1WdmuScc87B6XTy1Vdf+cu++eYbPB4PAwYMqPI6QQl6irdUquzsbNOqVSszePBg88UXX5j77rvPREdHm5kzZ9rdtLB1wQUXmOTkZPPRRx+Z2bNn+z82b97sr7N8+XKTmJhoRo8ebSZPnmwuvfRS06BBA7Njx46Q16kpSlvdlp+fbzp06GD69etnPv/8c/PQQw+ZqKgo8+2334a8TiR79NFHTfPmzc3bb79tvvrqKzN06FCTkZFh9u3b569zyy23mIYNG5q3337bvPXWWyYtLc3cddddAc8JVZ1IddFFF5mMjAzz1ltvmW+//dZcf/31Jjo62vz000/+Oh9//LGJjo42Tz75pPn0009Njx49TLdu3QKWj4eqTqRYtWqVmT17trn99ttNamqq/2dybm6uv85f/vIXU69ePfPWW2+Zt99+26Snp5tbb7014DlVWed4HMYYU6FIKCG3c+dOnn76aVasWEF6ejq33XYbvXv3trtZYat///54PJ6jym+66Sb/KhWAX375hX/84x9s3ryZdu3a8de//pWWLVsG3BOqOjXBxIkTeffddwP+hQawd+9ennnmGZYtW0ZaWhqjR4/m7LPPrpQ6kezdd9/lo48+orCwkC5dunDXXXf5ezjA2in63//+N19//TUOh4MLL7wwYIgulHUildvt5tVXX2XmzJlkZ2fTunVrbrnlFjp37hxQb8qUKbz++uscOHCA008/nfvuu4/atWtXSp1IcN999zF37tyjyt955x3/z0qfz8err77K5MmTMcZw/vnnc8stt/iHPqu6zvEoJImIiIiUIvL/ySAiIiJSAQpJIiIiIqVQSBIREREphUKSiIiISCkUkkRERERKoZAkIiIiUgqFJBEREZFSKCSJSMi43W4mTpzIwYMH7W4K69at47PPPmPKlClB1ff5fEycOJF9+/YBoXkt4fR+iEj5KSSJSLns2rWLadOm8f3337Nr166Az2VnZ3PllVeyceNGexpX5M033+T000/n3Xff5ccffwzqHrfbzZVXXsm6deuA8r+WgoICJk6cGHDuXLi8HyJSMdF2N0BEqo/x48fz3HPP0aNHD2rVqsWKFSvo168fr776KomJicTFxTFixAjq1Kljaztfe+017rvvPsaNG1fhZ5T3tRw8eJArr7ySFStWkJqaWqFniEh4UUgSkaDMmDGDJ554gjlz5vjPFPT5fHz44Ye4XC5/SLr44ov9IWHhwoVkZmYe9axevXrRvHlzwOptmT9/PgCnnnoq6enpx23Lzp07+emnn4iLi+PMM88kOTkZgMLCQj755BMyMzNZv349EydOpEuXLrRv377U56xbt47Vq1fTunVr2rRpE/C5I19LsZycHBYsWIAxhl69epGcnIwxhi+++AKA7777jpUrV1K/fn369u1b6jPKaj9Abm4uX375JcOGDWP37t2sWbOGpk2b0qVLl4BnTJo0CZ/PR1RUFM2bN6dr167ExMSU+pyNGzfy22+/0b17d37++Wc6dOhA27ZtA5732Wef0blz56PeB5EarVzH4YpIjfWvf/3LxMfHG5/PV2adPXv2GMAsW7bMGGPMyy+/bEaMGOH/GDx4sAHM+++/b4yxTkivU6eO6devnzn33HNNamqqefHFF4/bjoSEBNO/f3/TtWtXU7duXfPjjz8aY4zJzc01I0aMMElJSea0004zI0aMMF988UWpz3n66adNXFycGTBggOnUqZMZOnSoAcz8+fNLfS3GGPPRRx+Z1NRUc+qpp5rBgwebtm3bmgULFhiv12suuugiA5hzzz3XjBgxwjz88MOlPuNY7TfGmMzMTAOYCy64wHTo0MGcf/75JikpyYwZMyag/SNHjjQjRowwl156qWnbtq3p0KGD2bx581HPGTZsmGnXrp25/PLLzezZs80f//hHM3z48IBn/fLLLwYwq1evPuZ7L1LTKCSJSFAWLlxoHA6HGT16tFmxYkWpYam0UFDM4/GYAQMGmO7du5u8vDyzYcMGU6tWLTNjxgx/nUWLFpn4+HizZs2aUtuwbt06ExMTYyZOnOgvGzNmjGnRooUpKCjwl7Vu3dr8+9//LvO1/PbbbyYqKsp8+eWXxhhjfD6fufLKK48ZktatW2diY2PNP//5T/9zdu7c6a+/Y8cOA5gVK1aU+X4E0/7icHPdddf53+MZM2YYh8NhNm3aVOrr8Xq95tJLLzXXXHONv6z4OVdccYXxer3+8hkzZpiYmBize/duf9ntt99uevXqVeb7JVJTaeK2iASlR48efPDBB8ycOZPOnTuTmprKBRdcwNSpU4O6/6677mLlypV8/vnnJCQk8MEHH5CWlsaePXv46KOPmDRpEhs2bKBu3brMnj271Gd88sknZGRkMGLECH/ZAw88wMaNG1m4cGHQr+WTTz6hbdu2DBs2DACHw8G99957zHs++OADGjZsyO233+4vS09Pp2fPnuX6usG2/+abb8bhcADQp08fnE4nv/32W0Cd1atX89VXXzFp0iTq16/PTz/9dNTXvO2223A6D/+oP+uss2jRogXvvPMOYE1Yf++997juuuuCfh0iNYXmJIlI0EaMGMGIESPYtm0bCxYs4K233mLw4MH+uS9l+e9//8t//vMffvzxR5o2bQrAxo0bcbvdfPzxxwF1+/btS7169Up9zqZNm2jVqlVAWXp6OrVq1WLTpk1Bv47NmzfTokWLgLKWLVse9542bdr4g0tFlKf9devW9f9/VFQU0dHRFBQUAJCfn88FF1zAsmXLOP3000lNTWXLli3s3r37qK/ZqFGjo8quv/563nrrLe666y6++OILCgoKAoKbiFgUkkSk3Jo0acKll17KJZdcQqdOnXj//ffLDEkLFixg9OjRvPzyy5x55pn+8pSUFOrUqcPEiROD/rr16tU7qsfF5XKRl5dXZrAqTVpaGkuXLg0oO3DgwDHvqV27tn8PpYoKVfvfeecd1q1bx6ZNm0hKSgLgxRdf5JFHHjmqbmmh7pprrmH8+PH89NNPvPnmm1x22WUBk8dFxKLhNhEJyvbt23G73QFlPp8Pt9tN7dq1y7znkksu4eabb+b6668P+Ny5557LmjVrmDlzZkB5Tk4OOTk5pT6vT58+/PLLL6xfv95f9vHHHxMfH0+3bt2Cfi19+vRh6dKlbNmyxV/26aefHvOewYMHs3z5cn7++eeA8j179gD4w0pxb09ltn/nzp00adLE/zXBGsoLVnp6OsOGDeOJJ55g6tSpR/3ZiIhFPUkiEpSFCxdy9913c/HFF9O+fXsKCwuZNGkSe/bs4c9//nOp94wePRqPx8Ppp58e0GPUq1cvBg4cyE033cSwYcMYM2YMrVu3Zu3atXz22Wd8//33pfZsDB48mPPOO49BgwZx5513kpWVxTPPPMP48eOD2jqg2JAhQ+jXrx8DBw5kzJgx7Ny5k7feeuuY9wwaNIhRo0YxYMAA7rjjDho0aMDnn3/On/70J0aOHElSUhLt2rXjmWeeYfjw4aSnpx+1bD9U7R82bBiPP/44d955J506deKzzz7j559/JioqKuhn3HjjjZx33nm0bduWvn37Bn2fSE2ikCQiQRk+fDi9evXiww8/ZNGiRURHR3PxxRfz8ccf+4eKjtw8sUuXLiQmJvLVV18FPKtp06Y0b96cV155hUsuuYSvv/6aefPm0aFDB+bPn3/MoadPPvmEt99+m7lz5xIXF8eHH37I+eefH1Bn2LBhx93v58svv+Sll15iyZIltG7dmvnz5/PXv/61zNcC1tyqzz//nClTprB7927uvvtuBg0a5P/8V199xWuvvcY333xDmzZt6NGjx1HPOF77a9WqxYgRI44KiVdccQVNmjQBoFu3bsyePZt3332XuXPncv7553PPPffwwQcfHPc5xQYPHkxiYiLXXnvtMd8nkZrMYYwxdjdCRESq1vTp0zn33HPZtGlTqZO7RUQ9SSIiNcrOnTuZOnUqzzzzDNddd50CksgxaOK2iEgNsmvXLr799lsuv/xynn/+ebubIxLWNNwmIiIiUgr1JImIiIiUQiFJREREpBQKSSIiIiKlUEgSERERKYVCkoiIiEgpFJJERERESqGQJCIiIlIKhSQRERGRUigkiYiIiJTi/wHUgB0h7tyJ0AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -772,7 +811,7 @@ " Return a tuple of strings by splitting in_str at ','.\n", "\n", " \"\"\"\n", - " return rmisc.string_to_tuple(in_str)" + " return tuple(rmisc.string_to_tuple(in_str))" ] }, { @@ -805,6 +844,7 @@ " rust_object = rust_string_to_tuple(in_str)\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", + " assert python_object == rust_object\n", " sizeofarray.append(len(in_str))\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " i *= 10" @@ -817,7 +857,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -886,6 +926,9 @@ "metadata": {}, "outputs": [], "source": [ + "from pathlib import Path\n", + "\n", + "\n", "def save_qupath_json(save_path: Path, qupath_json: dict) -> Path:\n", " \"\"\"Saves QuPath JSON to disk.\"\"\"\n", " save_path = save_path.with_suffix(\".json\")\n", @@ -1058,7 +1101,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4affad18c9c449bb8824593dd2e7458b", + "model_id": "a98d8b62517d40619d38b795c0cb1952", "version_major": 2, "version_minor": 0 }, @@ -1072,7 +1115,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2323b765e2ac40ed990f9242565f4a99", + "model_id": "da3c34de48284a85a68f5f14addb14d7", "version_major": 2, "version_minor": 0 }, @@ -1086,7 +1129,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "741c1a5290b24cd0bb49543d15bb65d1", + "model_id": "9d99c31c4f614c50954acb545a980fda", "version_major": 2, "version_minor": 0 }, @@ -1100,7 +1143,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fe07bc47ec8340968c186aea4dadfcc4", + "model_id": "6dd5629582f54ce9933fc6d25ccad444", "version_major": 2, "version_minor": 0 }, @@ -1114,7 +1157,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "82aadc231baa4e4fa95eaf49bf1405ac", + "model_id": "3eeb405d27c34f9d840b96c5e9dc3ab9", "version_major": 2, "version_minor": 0 }, @@ -1128,119 +1171,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eb4cb11a38eb4fffa1a34d1bf0199401", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Converting outputs to QuPath JSON.: 0%| | 0/9 [00:00" ] diff --git a/benchmarks/example.txt b/benchmarks/example.txt new file mode 100644 index 000000000..10b7e8c35 --- /dev/null +++ b/benchmarks/example.txt @@ -0,0 +1,10002 @@ +{ + "0": 1, + "1": 1, + "10": 1, + "100": 1, + "1000": 1, + "1001": 1, + "1002": 1, + "1003": 1, + "1004": 1, + "1005": 1, + "1006": 1, + "1007": 1, + "1008": 1, + "1009": 1, + "101": 1, + "1010": 1, + "1011": 1, + "1012": 1, + "1013": 1, + "1014": 1, + "1015": 1, + "1016": 1, + "1017": 1, + "1018": 1, + "1019": 1, + "102": 1, + "1020": 1, + "1021": 1, + "1022": 1, + "1023": 1, + "1024": 1, + "1025": 1, + "1026": 1, + "1027": 1, + "1028": 1, + "1029": 1, + "103": 1, + "1030": 1, + "1031": 1, + "1032": 1, + "1033": 1, + "1034": 1, + "1035": 1, + "1036": 1, + "1037": 1, + "1038": 1, + "1039": 1, + "104": 1, + "1040": 1, + "1041": 1, + "1042": 1, + "1043": 1, + "1044": 1, + "1045": 1, + "1046": 1, + "1047": 1, + "1048": 1, + "1049": 1, + "105": 1, + "1050": 1, + "1051": 1, + "1052": 1, + "1053": 1, + "1054": 1, + "1055": 1, + "1056": 1, + "1057": 1, + "1058": 1, + "1059": 1, + "106": 1, + "1060": 1, + "1061": 1, + "1062": 1, + "1063": 1, + "1064": 1, + "1065": 1, + "1066": 1, + "1067": 1, + "1068": 1, + "1069": 1, + "107": 1, + "1070": 1, + "1071": 1, + "1072": 1, + "1073": 1, + "1074": 1, + "1075": 1, + "1076": 1, + "1077": 1, + "1078": 1, + "1079": 1, + "108": 1, + "1080": 1, + "1081": 1, + "1082": 1, + "1083": 1, + "1084": 1, + "1085": 1, + "1086": 1, + "1087": 1, + "1088": 1, + "1089": 1, + "109": 1, + "1090": 1, + "1091": 1, + "1092": 1, + "1093": 1, + "1094": 1, + "1095": 1, + "1096": 1, + "1097": 1, + "1098": 1, + "1099": 1, + "11": 1, + "110": 1, + "1100": 1, + "1101": 1, + "1102": 1, + "1103": 1, + "1104": 1, + "1105": 1, + "1106": 1, + "1107": 1, + "1108": 1, + "1109": 1, + "111": 1, + "1110": 1, + "1111": 1, + "1112": 1, + "1113": 1, + "1114": 1, + "1115": 1, + "1116": 1, + "1117": 1, + "1118": 1, + "1119": 1, + "112": 1, + "1120": 1, + "1121": 1, + "1122": 1, + "1123": 1, + "1124": 1, + "1125": 1, + "1126": 1, + "1127": 1, + "1128": 1, + "1129": 1, + "113": 1, + "1130": 1, + "1131": 1, + "1132": 1, + "1133": 1, + "1134": 1, + "1135": 1, + "1136": 1, + "1137": 1, + "1138": 1, + "1139": 1, + "114": 1, + "1140": 1, + "1141": 1, + "1142": 1, + "1143": 1, + "1144": 1, + "1145": 1, + "1146": 1, + "1147": 1, + "1148": 1, + "1149": 1, + "115": 1, + "1150": 1, + "1151": 1, + "1152": 1, + "1153": 1, + "1154": 1, + "1155": 1, + "1156": 1, + "1157": 1, + "1158": 1, + "1159": 1, + "116": 1, + "1160": 1, + "1161": 1, + "1162": 1, + "1163": 1, + "1164": 1, + "1165": 1, + "1166": 1, + "1167": 1, + "1168": 1, + "1169": 1, + "117": 1, + "1170": 1, + "1171": 1, + "1172": 1, + "1173": 1, + "1174": 1, + "1175": 1, + "1176": 1, + "1177": 1, + "1178": 1, + "1179": 1, + "118": 1, + "1180": 1, + "1181": 1, + "1182": 1, + "1183": 1, + "1184": 1, + "1185": 1, + "1186": 1, + "1187": 1, + "1188": 1, + "1189": 1, + "119": 1, + "1190": 1, + "1191": 1, + "1192": 1, + "1193": 1, + "1194": 1, + "1195": 1, + "1196": 1, + "1197": 1, + "1198": 1, + "1199": 1, + "12": 1, + "120": 1, + "1200": 1, + "1201": 1, + "1202": 1, + "1203": 1, + "1204": 1, + "1205": 1, + "1206": 1, + "1207": 1, + "1208": 1, + "1209": 1, + "121": 1, + "1210": 1, + "1211": 1, + "1212": 1, + "1213": 1, + "1214": 1, + "1215": 1, + "1216": 1, + "1217": 1, + "1218": 1, + "1219": 1, + "122": 1, + "1220": 1, + "1221": 1, + "1222": 1, + "1223": 1, + "1224": 1, + "1225": 1, + "1226": 1, + "1227": 1, + "1228": 1, + "1229": 1, + "123": 1, + "1230": 1, + "1231": 1, + "1232": 1, + "1233": 1, + "1234": 1, + "1235": 1, + "1236": 1, + "1237": 1, + "1238": 1, + "1239": 1, + "124": 1, + "1240": 1, + "1241": 1, + "1242": 1, + "1243": 1, + "1244": 1, + "1245": 1, + "1246": 1, + "1247": 1, + "1248": 1, + "1249": 1, + "125": 1, + "1250": 1, + "1251": 1, + "1252": 1, + "1253": 1, + "1254": 1, + "1255": 1, + "1256": 1, + "1257": 1, + "1258": 1, + "1259": 1, + "126": 1, + "1260": 1, + "1261": 1, + "1262": 1, + "1263": 1, + "1264": 1, + "1265": 1, + "1266": 1, + "1267": 1, + "1268": 1, + "1269": 1, + "127": 1, + "1270": 1, + "1271": 1, + "1272": 1, + "1273": 1, + "1274": 1, + "1275": 1, + "1276": 1, + "1277": 1, + "1278": 1, + "1279": 1, + "128": 1, + "1280": 1, + "1281": 1, + "1282": 1, + "1283": 1, + "1284": 1, + "1285": 1, + "1286": 1, + "1287": 1, + "1288": 1, + "1289": 1, + "129": 1, + "1290": 1, + "1291": 1, + "1292": 1, + "1293": 1, + "1294": 1, + "1295": 1, + "1296": 1, + "1297": 1, + "1298": 1, + "1299": 1, + "13": 1, + "130": 1, + "1300": 1, + "1301": 1, + "1302": 1, + "1303": 1, + "1304": 1, + "1305": 1, + "1306": 1, + "1307": 1, + "1308": 1, + "1309": 1, + "131": 1, + "1310": 1, + "1311": 1, + "1312": 1, + "1313": 1, + "1314": 1, + "1315": 1, + "1316": 1, + "1317": 1, + "1318": 1, + "1319": 1, + "132": 1, + "1320": 1, + "1321": 1, + "1322": 1, + "1323": 1, + "1324": 1, + "1325": 1, + "1326": 1, + "1327": 1, + "1328": 1, + "1329": 1, + "133": 1, + "1330": 1, + "1331": 1, + "1332": 1, + "1333": 1, + "1334": 1, + "1335": 1, + "1336": 1, + "1337": 1, + "1338": 1, + "1339": 1, + "134": 1, + "1340": 1, + "1341": 1, + "1342": 1, + "1343": 1, + "1344": 1, + "1345": 1, + "1346": 1, + "1347": 1, + "1348": 1, + "1349": 1, + "135": 1, + "1350": 1, + "1351": 1, + "1352": 1, + "1353": 1, + "1354": 1, + "1355": 1, + "1356": 1, + "1357": 1, + "1358": 1, + "1359": 1, + "136": 1, + "1360": 1, + "1361": 1, + "1362": 1, + "1363": 1, + "1364": 1, + "1365": 1, + "1366": 1, + "1367": 1, + "1368": 1, + "1369": 1, + "137": 1, + "1370": 1, + "1371": 1, + "1372": 1, + "1373": 1, + "1374": 1, + "1375": 1, + "1376": 1, + "1377": 1, + "1378": 1, + "1379": 1, + "138": 1, + "1380": 1, + "1381": 1, + "1382": 1, + "1383": 1, + "1384": 1, + "1385": 1, + "1386": 1, + "1387": 1, + "1388": 1, + "1389": 1, + "139": 1, + "1390": 1, + "1391": 1, + "1392": 1, + "1393": 1, + "1394": 1, + "1395": 1, + "1396": 1, + "1397": 1, + "1398": 1, + "1399": 1, + "14": 1, + "140": 1, + "1400": 1, + "1401": 1, + "1402": 1, + "1403": 1, + "1404": 1, + "1405": 1, + "1406": 1, + "1407": 1, + "1408": 1, + "1409": 1, + "141": 1, + "1410": 1, + "1411": 1, + "1412": 1, + "1413": 1, + "1414": 1, + "1415": 1, + "1416": 1, + "1417": 1, + "1418": 1, + "1419": 1, + "142": 1, + "1420": 1, + "1421": 1, + "1422": 1, + "1423": 1, + "1424": 1, + "1425": 1, + "1426": 1, + "1427": 1, + "1428": 1, + "1429": 1, + "143": 1, + "1430": 1, + "1431": 1, + "1432": 1, + "1433": 1, + "1434": 1, + "1435": 1, + "1436": 1, + "1437": 1, + "1438": 1, + "1439": 1, + "144": 1, + "1440": 1, + "1441": 1, + "1442": 1, + "1443": 1, + "1444": 1, + "1445": 1, + "1446": 1, + "1447": 1, + "1448": 1, + "1449": 1, + "145": 1, + "1450": 1, + "1451": 1, + "1452": 1, + "1453": 1, + "1454": 1, + "1455": 1, + "1456": 1, + "1457": 1, + "1458": 1, + "1459": 1, + "146": 1, + "1460": 1, + "1461": 1, + "1462": 1, + "1463": 1, + "1464": 1, + "1465": 1, + "1466": 1, + "1467": 1, + "1468": 1, + "1469": 1, + "147": 1, + "1470": 1, + "1471": 1, + "1472": 1, + "1473": 1, + "1474": 1, + "1475": 1, + "1476": 1, + "1477": 1, + "1478": 1, + "1479": 1, + "148": 1, + "1480": 1, + "1481": 1, + "1482": 1, + "1483": 1, + "1484": 1, + "1485": 1, + "1486": 1, + "1487": 1, + "1488": 1, + "1489": 1, + "149": 1, + "1490": 1, + "1491": 1, + "1492": 1, + "1493": 1, + "1494": 1, + "1495": 1, + "1496": 1, + "1497": 1, + "1498": 1, + "1499": 1, + "15": 1, + "150": 1, + "1500": 1, + "1501": 1, + "1502": 1, + "1503": 1, + "1504": 1, + "1505": 1, + "1506": 1, + "1507": 1, + "1508": 1, + "1509": 1, + "151": 1, + "1510": 1, + "1511": 1, + "1512": 1, + "1513": 1, + "1514": 1, + "1515": 1, + "1516": 1, + "1517": 1, + "1518": 1, + "1519": 1, + "152": 1, + "1520": 1, + "1521": 1, + "1522": 1, + "1523": 1, + "1524": 1, + "1525": 1, + "1526": 1, + "1527": 1, + "1528": 1, + "1529": 1, + "153": 1, + "1530": 1, + "1531": 1, + "1532": 1, + "1533": 1, + "1534": 1, + "1535": 1, + "1536": 1, + "1537": 1, + "1538": 1, + "1539": 1, + "154": 1, + "1540": 1, + "1541": 1, + "1542": 1, + "1543": 1, + "1544": 1, + "1545": 1, + "1546": 1, + "1547": 1, + "1548": 1, + "1549": 1, + "155": 1, + "1550": 1, + "1551": 1, + "1552": 1, + "1553": 1, + "1554": 1, + "1555": 1, + "1556": 1, + "1557": 1, + "1558": 1, + "1559": 1, + "156": 1, + "1560": 1, + "1561": 1, + "1562": 1, + "1563": 1, + "1564": 1, + "1565": 1, + "1566": 1, + "1567": 1, + "1568": 1, + "1569": 1, + "157": 1, + "1570": 1, + "1571": 1, + "1572": 1, + "1573": 1, + "1574": 1, + "1575": 1, + "1576": 1, + "1577": 1, + "1578": 1, + "1579": 1, + "158": 1, + "1580": 1, + "1581": 1, + "1582": 1, + "1583": 1, + "1584": 1, + "1585": 1, + "1586": 1, + "1587": 1, + "1588": 1, + "1589": 1, + "159": 1, + "1590": 1, + "1591": 1, + "1592": 1, + "1593": 1, + "1594": 1, + "1595": 1, + "1596": 1, + "1597": 1, + "1598": 1, + "1599": 1, + "16": 1, + "160": 1, + "1600": 1, + "1601": 1, + "1602": 1, + "1603": 1, + "1604": 1, + "1605": 1, + "1606": 1, + "1607": 1, + "1608": 1, + "1609": 1, + "161": 1, + "1610": 1, + "1611": 1, + "1612": 1, + "1613": 1, + "1614": 1, + "1615": 1, + "1616": 1, + "1617": 1, + "1618": 1, + "1619": 1, + "162": 1, + "1620": 1, + "1621": 1, + "1622": 1, + "1623": 1, + "1624": 1, + "1625": 1, + "1626": 1, + "1627": 1, + "1628": 1, + "1629": 1, + "163": 1, + "1630": 1, + "1631": 1, + "1632": 1, + "1633": 1, + "1634": 1, + "1635": 1, + "1636": 1, + "1637": 1, + "1638": 1, + "1639": 1, + "164": 1, + "1640": 1, + "1641": 1, + "1642": 1, + "1643": 1, + "1644": 1, + "1645": 1, + "1646": 1, + "1647": 1, + "1648": 1, + "1649": 1, + "165": 1, + "1650": 1, + "1651": 1, + "1652": 1, + "1653": 1, + "1654": 1, + "1655": 1, + "1656": 1, + "1657": 1, + "1658": 1, + "1659": 1, + "166": 1, + "1660": 1, + "1661": 1, + "1662": 1, + "1663": 1, + "1664": 1, + "1665": 1, + "1666": 1, + "1667": 1, + "1668": 1, + "1669": 1, + "167": 1, + "1670": 1, + "1671": 1, + "1672": 1, + "1673": 1, + "1674": 1, + "1675": 1, + "1676": 1, + "1677": 1, + "1678": 1, + "1679": 1, + "168": 1, + "1680": 1, + "1681": 1, + "1682": 1, + "1683": 1, + "1684": 1, + "1685": 1, + "1686": 1, + "1687": 1, + "1688": 1, + "1689": 1, + "169": 1, + "1690": 1, + "1691": 1, + "1692": 1, + "1693": 1, + "1694": 1, + "1695": 1, + "1696": 1, + "1697": 1, + "1698": 1, + "1699": 1, + "17": 1, + "170": 1, + "1700": 1, + "1701": 1, + "1702": 1, + "1703": 1, + "1704": 1, + "1705": 1, + "1706": 1, + "1707": 1, + "1708": 1, + "1709": 1, + "171": 1, + "1710": 1, + "1711": 1, + "1712": 1, + "1713": 1, + "1714": 1, + "1715": 1, + "1716": 1, + "1717": 1, + "1718": 1, + "1719": 1, + "172": 1, + "1720": 1, + "1721": 1, + "1722": 1, + "1723": 1, + "1724": 1, + "1725": 1, + "1726": 1, + "1727": 1, + "1728": 1, + "1729": 1, + "173": 1, + "1730": 1, + "1731": 1, + "1732": 1, + "1733": 1, + "1734": 1, + "1735": 1, + "1736": 1, + "1737": 1, + "1738": 1, + "1739": 1, + "174": 1, + "1740": 1, + "1741": 1, + "1742": 1, + "1743": 1, + "1744": 1, + "1745": 1, + "1746": 1, + "1747": 1, + "1748": 1, + "1749": 1, + "175": 1, + "1750": 1, + "1751": 1, + "1752": 1, + "1753": 1, + "1754": 1, + "1755": 1, + "1756": 1, + "1757": 1, + "1758": 1, + "1759": 1, + "176": 1, + "1760": 1, + "1761": 1, + "1762": 1, + "1763": 1, + "1764": 1, + "1765": 1, + "1766": 1, + "1767": 1, + "1768": 1, + "1769": 1, + "177": 1, + "1770": 1, + "1771": 1, + "1772": 1, + "1773": 1, + "1774": 1, + "1775": 1, + "1776": 1, + "1777": 1, + "1778": 1, + "1779": 1, + "178": 1, + "1780": 1, + "1781": 1, + "1782": 1, + "1783": 1, + "1784": 1, + "1785": 1, + "1786": 1, + "1787": 1, + "1788": 1, + "1789": 1, + "179": 1, + "1790": 1, + "1791": 1, + "1792": 1, + "1793": 1, + "1794": 1, + "1795": 1, + "1796": 1, + "1797": 1, + "1798": 1, + "1799": 1, + "18": 1, + "180": 1, + "1800": 1, + "1801": 1, + "1802": 1, + "1803": 1, + "1804": 1, + "1805": 1, + "1806": 1, + "1807": 1, + "1808": 1, + "1809": 1, + "181": 1, + "1810": 1, + "1811": 1, + "1812": 1, + "1813": 1, + "1814": 1, + "1815": 1, + "1816": 1, + "1817": 1, + "1818": 1, + "1819": 1, + "182": 1, + "1820": 1, + "1821": 1, + "1822": 1, + "1823": 1, + "1824": 1, + "1825": 1, + "1826": 1, + "1827": 1, + "1828": 1, + "1829": 1, + "183": 1, + "1830": 1, + "1831": 1, + "1832": 1, + "1833": 1, + "1834": 1, + "1835": 1, + "1836": 1, + "1837": 1, + "1838": 1, + "1839": 1, + "184": 1, + "1840": 1, + "1841": 1, + "1842": 1, + "1843": 1, + "1844": 1, + "1845": 1, + "1846": 1, + "1847": 1, + "1848": 1, + "1849": 1, + "185": 1, + "1850": 1, + "1851": 1, + "1852": 1, + "1853": 1, + "1854": 1, + "1855": 1, + "1856": 1, + "1857": 1, + "1858": 1, + "1859": 1, + "186": 1, + "1860": 1, + "1861": 1, + "1862": 1, + "1863": 1, + "1864": 1, + "1865": 1, + "1866": 1, + "1867": 1, + "1868": 1, + "1869": 1, + "187": 1, + "1870": 1, + "1871": 1, + "1872": 1, + "1873": 1, + "1874": 1, + "1875": 1, + "1876": 1, + "1877": 1, + "1878": 1, + "1879": 1, + "188": 1, + "1880": 1, + "1881": 1, + "1882": 1, + "1883": 1, + "1884": 1, + "1885": 1, + "1886": 1, + "1887": 1, + "1888": 1, + "1889": 1, + "189": 1, + "1890": 1, + "1891": 1, + "1892": 1, + "1893": 1, + "1894": 1, + "1895": 1, + "1896": 1, + "1897": 1, + "1898": 1, + "1899": 1, + "19": 1, + "190": 1, + "1900": 1, + "1901": 1, + "1902": 1, + "1903": 1, + "1904": 1, + "1905": 1, + "1906": 1, + "1907": 1, + "1908": 1, + "1909": 1, + "191": 1, + "1910": 1, + "1911": 1, + "1912": 1, + "1913": 1, + "1914": 1, + "1915": 1, + "1916": 1, + "1917": 1, + "1918": 1, + "1919": 1, + "192": 1, + "1920": 1, + "1921": 1, + "1922": 1, + "1923": 1, + "1924": 1, + "1925": 1, + "1926": 1, + "1927": 1, + "1928": 1, + "1929": 1, + "193": 1, + "1930": 1, + "1931": 1, + "1932": 1, + "1933": 1, + "1934": 1, + "1935": 1, + "1936": 1, + "1937": 1, + "1938": 1, + "1939": 1, + "194": 1, + "1940": 1, + "1941": 1, + "1942": 1, + "1943": 1, + "1944": 1, + "1945": 1, + "1946": 1, + "1947": 1, + "1948": 1, + "1949": 1, + "195": 1, + "1950": 1, + "1951": 1, + "1952": 1, + "1953": 1, + "1954": 1, + "1955": 1, + "1956": 1, + "1957": 1, + "1958": 1, + "1959": 1, + "196": 1, + "1960": 1, + "1961": 1, + "1962": 1, + "1963": 1, + "1964": 1, + "1965": 1, + "1966": 1, + "1967": 1, + "1968": 1, + "1969": 1, + "197": 1, + "1970": 1, + "1971": 1, + "1972": 1, + "1973": 1, + "1974": 1, + "1975": 1, + "1976": 1, + "1977": 1, + "1978": 1, + "1979": 1, + "198": 1, + "1980": 1, + "1981": 1, + "1982": 1, + "1983": 1, + "1984": 1, + "1985": 1, + "1986": 1, + "1987": 1, + "1988": 1, + "1989": 1, + "199": 1, + "1990": 1, + "1991": 1, + "1992": 1, + "1993": 1, + "1994": 1, + "1995": 1, + "1996": 1, + "1997": 1, + "1998": 1, + "1999": 1, + "2": 1, + "20": 1, + "200": 1, + "2000": 1, + "2001": 1, + "2002": 1, + "2003": 1, + "2004": 1, + "2005": 1, + "2006": 1, + "2007": 1, + "2008": 1, + "2009": 1, + "201": 1, + "2010": 1, + "2011": 1, + "2012": 1, + "2013": 1, + "2014": 1, + "2015": 1, + "2016": 1, + "2017": 1, + "2018": 1, + "2019": 1, + "202": 1, + "2020": 1, + "2021": 1, + "2022": 1, + "2023": 1, + "2024": 1, + "2025": 1, + "2026": 1, + "2027": 1, + "2028": 1, + "2029": 1, + "203": 1, + "2030": 1, + "2031": 1, + "2032": 1, + "2033": 1, + "2034": 1, + "2035": 1, + "2036": 1, + "2037": 1, + "2038": 1, + "2039": 1, + "204": 1, + "2040": 1, + "2041": 1, + "2042": 1, + "2043": 1, + "2044": 1, + "2045": 1, + "2046": 1, + "2047": 1, + "2048": 1, + "2049": 1, + "205": 1, + "2050": 1, + "2051": 1, + "2052": 1, + "2053": 1, + "2054": 1, + "2055": 1, + "2056": 1, + "2057": 1, + "2058": 1, + "2059": 1, + "206": 1, + "2060": 1, + "2061": 1, + "2062": 1, + "2063": 1, + "2064": 1, + "2065": 1, + "2066": 1, + "2067": 1, + "2068": 1, + "2069": 1, + "207": 1, + "2070": 1, + "2071": 1, + "2072": 1, + "2073": 1, + "2074": 1, + "2075": 1, + "2076": 1, + "2077": 1, + "2078": 1, + "2079": 1, + "208": 1, + "2080": 1, + "2081": 1, + "2082": 1, + "2083": 1, + "2084": 1, + "2085": 1, + "2086": 1, + "2087": 1, + "2088": 1, + "2089": 1, + "209": 1, + "2090": 1, + "2091": 1, + "2092": 1, + "2093": 1, + "2094": 1, + "2095": 1, + "2096": 1, + "2097": 1, + "2098": 1, + "2099": 1, + "21": 1, + "210": 1, + "2100": 1, + "2101": 1, + "2102": 1, + "2103": 1, + "2104": 1, + "2105": 1, + "2106": 1, + "2107": 1, + "2108": 1, + "2109": 1, + "211": 1, + "2110": 1, + "2111": 1, + "2112": 1, + "2113": 1, + "2114": 1, + "2115": 1, + "2116": 1, + "2117": 1, + "2118": 1, + "2119": 1, + "212": 1, + "2120": 1, + "2121": 1, + "2122": 1, + "2123": 1, + "2124": 1, + "2125": 1, + "2126": 1, + "2127": 1, + "2128": 1, + "2129": 1, + "213": 1, + "2130": 1, + "2131": 1, + "2132": 1, + "2133": 1, + "2134": 1, + "2135": 1, + "2136": 1, + "2137": 1, + "2138": 1, + "2139": 1, + "214": 1, + "2140": 1, + "2141": 1, + "2142": 1, + "2143": 1, + "2144": 1, + "2145": 1, + "2146": 1, + "2147": 1, + "2148": 1, + "2149": 1, + "215": 1, + "2150": 1, + "2151": 1, + "2152": 1, + "2153": 1, + "2154": 1, + "2155": 1, + "2156": 1, + "2157": 1, + "2158": 1, + "2159": 1, + "216": 1, + "2160": 1, + "2161": 1, + "2162": 1, + "2163": 1, + "2164": 1, + "2165": 1, + "2166": 1, + "2167": 1, + "2168": 1, + "2169": 1, + "217": 1, + "2170": 1, + "2171": 1, + "2172": 1, + "2173": 1, + "2174": 1, + "2175": 1, + "2176": 1, + "2177": 1, + "2178": 1, + "2179": 1, + "218": 1, + "2180": 1, + "2181": 1, + "2182": 1, + "2183": 1, + "2184": 1, + "2185": 1, + "2186": 1, + "2187": 1, + "2188": 1, + "2189": 1, + "219": 1, + "2190": 1, + "2191": 1, + "2192": 1, + "2193": 1, + "2194": 1, + "2195": 1, + "2196": 1, + "2197": 1, + "2198": 1, + "2199": 1, + "22": 1, + "220": 1, + "2200": 1, + "2201": 1, + "2202": 1, + "2203": 1, + "2204": 1, + "2205": 1, + "2206": 1, + "2207": 1, + "2208": 1, + "2209": 1, + "221": 1, + "2210": 1, + "2211": 1, + "2212": 1, + "2213": 1, + "2214": 1, + "2215": 1, + "2216": 1, + "2217": 1, + "2218": 1, + "2219": 1, + "222": 1, + "2220": 1, + "2221": 1, + "2222": 1, + "2223": 1, + "2224": 1, + "2225": 1, + "2226": 1, + "2227": 1, + "2228": 1, + "2229": 1, + "223": 1, + "2230": 1, + "2231": 1, + "2232": 1, + "2233": 1, + "2234": 1, + "2235": 1, + "2236": 1, + "2237": 1, + "2238": 1, + "2239": 1, + "224": 1, + "2240": 1, + "2241": 1, + "2242": 1, + "2243": 1, + "2244": 1, + "2245": 1, + "2246": 1, + "2247": 1, + "2248": 1, + "2249": 1, + "225": 1, + "2250": 1, + "2251": 1, + "2252": 1, + "2253": 1, + "2254": 1, + "2255": 1, + "2256": 1, + "2257": 1, + "2258": 1, + "2259": 1, + "226": 1, + "2260": 1, + "2261": 1, + "2262": 1, + "2263": 1, + "2264": 1, + "2265": 1, + "2266": 1, + "2267": 1, + "2268": 1, + "2269": 1, + "227": 1, + "2270": 1, + "2271": 1, + "2272": 1, + "2273": 1, + "2274": 1, + "2275": 1, + "2276": 1, + "2277": 1, + "2278": 1, + "2279": 1, + "228": 1, + "2280": 1, + "2281": 1, + "2282": 1, + "2283": 1, + "2284": 1, + "2285": 1, + "2286": 1, + "2287": 1, + "2288": 1, + "2289": 1, + "229": 1, + "2290": 1, + "2291": 1, + "2292": 1, + "2293": 1, + "2294": 1, + "2295": 1, + "2296": 1, + "2297": 1, + "2298": 1, + "2299": 1, + "23": 1, + "230": 1, + "2300": 1, + "2301": 1, + "2302": 1, + "2303": 1, + "2304": 1, + "2305": 1, + "2306": 1, + "2307": 1, + "2308": 1, + "2309": 1, + "231": 1, + "2310": 1, + "2311": 1, + "2312": 1, + "2313": 1, + "2314": 1, + "2315": 1, + "2316": 1, + "2317": 1, + "2318": 1, + "2319": 1, + "232": 1, + "2320": 1, + "2321": 1, + "2322": 1, + "2323": 1, + "2324": 1, + "2325": 1, + "2326": 1, + "2327": 1, + "2328": 1, + "2329": 1, + "233": 1, + "2330": 1, + "2331": 1, + "2332": 1, + "2333": 1, + "2334": 1, + "2335": 1, + "2336": 1, + "2337": 1, + "2338": 1, + "2339": 1, + "234": 1, + "2340": 1, + "2341": 1, + "2342": 1, + "2343": 1, + "2344": 1, + "2345": 1, + "2346": 1, + "2347": 1, + "2348": 1, + "2349": 1, + "235": 1, + "2350": 1, + "2351": 1, + "2352": 1, + "2353": 1, + "2354": 1, + "2355": 1, + "2356": 1, + "2357": 1, + "2358": 1, + "2359": 1, + "236": 1, + "2360": 1, + "2361": 1, + "2362": 1, + "2363": 1, + "2364": 1, + "2365": 1, + "2366": 1, + "2367": 1, + "2368": 1, + "2369": 1, + "237": 1, + "2370": 1, + "2371": 1, + "2372": 1, + "2373": 1, + "2374": 1, + "2375": 1, + "2376": 1, + "2377": 1, + "2378": 1, + "2379": 1, + "238": 1, + "2380": 1, + "2381": 1, + "2382": 1, + "2383": 1, + "2384": 1, + "2385": 1, + "2386": 1, + "2387": 1, + "2388": 1, + "2389": 1, + "239": 1, + "2390": 1, + "2391": 1, + "2392": 1, + "2393": 1, + "2394": 1, + "2395": 1, + "2396": 1, + "2397": 1, + "2398": 1, + "2399": 1, + "24": 1, + "240": 1, + "2400": 1, + "2401": 1, + "2402": 1, + "2403": 1, + "2404": 1, + "2405": 1, + "2406": 1, + "2407": 1, + "2408": 1, + "2409": 1, + "241": 1, + "2410": 1, + "2411": 1, + "2412": 1, + "2413": 1, + "2414": 1, + "2415": 1, + "2416": 1, + "2417": 1, + "2418": 1, + "2419": 1, + "242": 1, + "2420": 1, + "2421": 1, + "2422": 1, + "2423": 1, + "2424": 1, + "2425": 1, + "2426": 1, + "2427": 1, + "2428": 1, + "2429": 1, + "243": 1, + "2430": 1, + "2431": 1, + "2432": 1, + "2433": 1, + "2434": 1, + "2435": 1, + "2436": 1, + "2437": 1, + "2438": 1, + "2439": 1, + "244": 1, + "2440": 1, + "2441": 1, + "2442": 1, + "2443": 1, + "2444": 1, + "2445": 1, + "2446": 1, + "2447": 1, + "2448": 1, + "2449": 1, + "245": 1, + "2450": 1, + "2451": 1, + "2452": 1, + "2453": 1, + "2454": 1, + "2455": 1, + "2456": 1, + "2457": 1, + "2458": 1, + "2459": 1, + "246": 1, + "2460": 1, + "2461": 1, + "2462": 1, + "2463": 1, + "2464": 1, + "2465": 1, + "2466": 1, + "2467": 1, + "2468": 1, + "2469": 1, + "247": 1, + "2470": 1, + "2471": 1, + "2472": 1, + "2473": 1, + "2474": 1, + "2475": 1, + "2476": 1, + "2477": 1, + "2478": 1, + "2479": 1, + "248": 1, + "2480": 1, + "2481": 1, + "2482": 1, + "2483": 1, + "2484": 1, + "2485": 1, + "2486": 1, + "2487": 1, + "2488": 1, + "2489": 1, + "249": 1, + "2490": 1, + "2491": 1, + "2492": 1, + "2493": 1, + "2494": 1, + "2495": 1, + "2496": 1, + "2497": 1, + "2498": 1, + "2499": 1, + "25": 1, + "250": 1, + "2500": 1, + "2501": 1, + "2502": 1, + "2503": 1, + "2504": 1, + "2505": 1, + "2506": 1, + "2507": 1, + "2508": 1, + "2509": 1, + "251": 1, + "2510": 1, + "2511": 1, + "2512": 1, + "2513": 1, + "2514": 1, + "2515": 1, + "2516": 1, + "2517": 1, + "2518": 1, + "2519": 1, + "252": 1, + "2520": 1, + "2521": 1, + "2522": 1, + "2523": 1, + "2524": 1, + "2525": 1, + "2526": 1, + "2527": 1, + "2528": 1, + "2529": 1, + "253": 1, + "2530": 1, + "2531": 1, + "2532": 1, + "2533": 1, + "2534": 1, + "2535": 1, + "2536": 1, + "2537": 1, + "2538": 1, + "2539": 1, + "254": 1, + "2540": 1, + "2541": 1, + "2542": 1, + "2543": 1, + "2544": 1, + "2545": 1, + "2546": 1, + "2547": 1, + "2548": 1, + "2549": 1, + "255": 1, + "2550": 1, + "2551": 1, + "2552": 1, + "2553": 1, + "2554": 1, + "2555": 1, + "2556": 1, + "2557": 1, + "2558": 1, + "2559": 1, + "256": 1, + "2560": 1, + "2561": 1, + "2562": 1, + "2563": 1, + "2564": 1, + "2565": 1, + "2566": 1, + "2567": 1, + "2568": 1, + "2569": 1, + "257": 1, + "2570": 1, + "2571": 1, + "2572": 1, + "2573": 1, + "2574": 1, + "2575": 1, + "2576": 1, + "2577": 1, + "2578": 1, + "2579": 1, + "258": 1, + "2580": 1, + "2581": 1, + "2582": 1, + "2583": 1, + "2584": 1, + "2585": 1, + "2586": 1, + "2587": 1, + "2588": 1, + "2589": 1, + "259": 1, + "2590": 1, + "2591": 1, + "2592": 1, + "2593": 1, + "2594": 1, + "2595": 1, + "2596": 1, + "2597": 1, + "2598": 1, + "2599": 1, + "26": 1, + "260": 1, + "2600": 1, + "2601": 1, + "2602": 1, + "2603": 1, + "2604": 1, + "2605": 1, + "2606": 1, + "2607": 1, + "2608": 1, + "2609": 1, + "261": 1, + "2610": 1, + "2611": 1, + "2612": 1, + "2613": 1, + "2614": 1, + "2615": 1, + "2616": 1, + "2617": 1, + "2618": 1, + "2619": 1, + "262": 1, + "2620": 1, + "2621": 1, + "2622": 1, + "2623": 1, + "2624": 1, + "2625": 1, + "2626": 1, + "2627": 1, + "2628": 1, + "2629": 1, + "263": 1, + "2630": 1, + "2631": 1, + "2632": 1, + "2633": 1, + "2634": 1, + "2635": 1, + "2636": 1, + "2637": 1, + "2638": 1, + "2639": 1, + "264": 1, + "2640": 1, + "2641": 1, + "2642": 1, + "2643": 1, + "2644": 1, + "2645": 1, + "2646": 1, + "2647": 1, + "2648": 1, + "2649": 1, + "265": 1, + "2650": 1, + "2651": 1, + "2652": 1, + "2653": 1, + "2654": 1, + "2655": 1, + "2656": 1, + "2657": 1, + "2658": 1, + "2659": 1, + "266": 1, + "2660": 1, + "2661": 1, + "2662": 1, + "2663": 1, + "2664": 1, + "2665": 1, + "2666": 1, + "2667": 1, + "2668": 1, + "2669": 1, + "267": 1, + "2670": 1, + "2671": 1, + "2672": 1, + "2673": 1, + "2674": 1, + "2675": 1, + "2676": 1, + "2677": 1, + "2678": 1, + "2679": 1, + "268": 1, + "2680": 1, + "2681": 1, + "2682": 1, + "2683": 1, + "2684": 1, + "2685": 1, + "2686": 1, + "2687": 1, + "2688": 1, + "2689": 1, + "269": 1, + "2690": 1, + "2691": 1, + "2692": 1, + "2693": 1, + "2694": 1, + "2695": 1, + "2696": 1, + "2697": 1, + "2698": 1, + "2699": 1, + "27": 1, + "270": 1, + "2700": 1, + "2701": 1, + "2702": 1, + "2703": 1, + "2704": 1, + "2705": 1, + "2706": 1, + "2707": 1, + "2708": 1, + "2709": 1, + "271": 1, + "2710": 1, + "2711": 1, + "2712": 1, + "2713": 1, + "2714": 1, + "2715": 1, + "2716": 1, + "2717": 1, + "2718": 1, + "2719": 1, + "272": 1, + "2720": 1, + "2721": 1, + "2722": 1, + "2723": 1, + "2724": 1, + "2725": 1, + "2726": 1, + "2727": 1, + "2728": 1, + "2729": 1, + "273": 1, + "2730": 1, + "2731": 1, + "2732": 1, + "2733": 1, + "2734": 1, + "2735": 1, + "2736": 1, + "2737": 1, + "2738": 1, + "2739": 1, + "274": 1, + "2740": 1, + "2741": 1, + "2742": 1, + "2743": 1, + "2744": 1, + "2745": 1, + "2746": 1, + "2747": 1, + "2748": 1, + "2749": 1, + "275": 1, + "2750": 1, + "2751": 1, + "2752": 1, + "2753": 1, + "2754": 1, + "2755": 1, + "2756": 1, + "2757": 1, + "2758": 1, + "2759": 1, + "276": 1, + "2760": 1, + "2761": 1, + "2762": 1, + "2763": 1, + "2764": 1, + "2765": 1, + "2766": 1, + "2767": 1, + "2768": 1, + "2769": 1, + "277": 1, + "2770": 1, + "2771": 1, + "2772": 1, + "2773": 1, + "2774": 1, + "2775": 1, + "2776": 1, + "2777": 1, + "2778": 1, + "2779": 1, + "278": 1, + "2780": 1, + "2781": 1, + "2782": 1, + "2783": 1, + "2784": 1, + "2785": 1, + "2786": 1, + "2787": 1, + "2788": 1, + "2789": 1, + "279": 1, + "2790": 1, + "2791": 1, + "2792": 1, + "2793": 1, + "2794": 1, + "2795": 1, + "2796": 1, + "2797": 1, + "2798": 1, + "2799": 1, + "28": 1, + "280": 1, + "2800": 1, + "2801": 1, + "2802": 1, + "2803": 1, + "2804": 1, + "2805": 1, + "2806": 1, + "2807": 1, + "2808": 1, + "2809": 1, + "281": 1, + "2810": 1, + "2811": 1, + "2812": 1, + "2813": 1, + "2814": 1, + "2815": 1, + "2816": 1, + "2817": 1, + "2818": 1, + "2819": 1, + "282": 1, + "2820": 1, + "2821": 1, + "2822": 1, + "2823": 1, + "2824": 1, + "2825": 1, + "2826": 1, + "2827": 1, + "2828": 1, + "2829": 1, + "283": 1, + "2830": 1, + "2831": 1, + "2832": 1, + "2833": 1, + "2834": 1, + "2835": 1, + "2836": 1, + "2837": 1, + "2838": 1, + "2839": 1, + "284": 1, + "2840": 1, + "2841": 1, + "2842": 1, + "2843": 1, + "2844": 1, + "2845": 1, + "2846": 1, + "2847": 1, + "2848": 1, + "2849": 1, + "285": 1, + "2850": 1, + "2851": 1, + "2852": 1, + "2853": 1, + "2854": 1, + "2855": 1, + "2856": 1, + "2857": 1, + "2858": 1, + "2859": 1, + "286": 1, + "2860": 1, + "2861": 1, + "2862": 1, + "2863": 1, + "2864": 1, + "2865": 1, + "2866": 1, + "2867": 1, + "2868": 1, + "2869": 1, + "287": 1, + "2870": 1, + "2871": 1, + "2872": 1, + "2873": 1, + "2874": 1, + "2875": 1, + "2876": 1, + "2877": 1, + "2878": 1, + "2879": 1, + "288": 1, + "2880": 1, + "2881": 1, + "2882": 1, + "2883": 1, + "2884": 1, + "2885": 1, + "2886": 1, + "2887": 1, + "2888": 1, + "2889": 1, + "289": 1, + "2890": 1, + "2891": 1, + "2892": 1, + "2893": 1, + "2894": 1, + "2895": 1, + "2896": 1, + "2897": 1, + "2898": 1, + "2899": 1, + "29": 1, + "290": 1, + "2900": 1, + "2901": 1, + "2902": 1, + "2903": 1, + "2904": 1, + "2905": 1, + "2906": 1, + "2907": 1, + "2908": 1, + "2909": 1, + "291": 1, + "2910": 1, + "2911": 1, + "2912": 1, + "2913": 1, + "2914": 1, + "2915": 1, + "2916": 1, + "2917": 1, + "2918": 1, + "2919": 1, + "292": 1, + "2920": 1, + "2921": 1, + "2922": 1, + "2923": 1, + "2924": 1, + "2925": 1, + "2926": 1, + "2927": 1, + "2928": 1, + "2929": 1, + "293": 1, + "2930": 1, + "2931": 1, + "2932": 1, + "2933": 1, + "2934": 1, + "2935": 1, + "2936": 1, + "2937": 1, + "2938": 1, + "2939": 1, + "294": 1, + "2940": 1, + "2941": 1, + "2942": 1, + "2943": 1, + "2944": 1, + "2945": 1, + "2946": 1, + "2947": 1, + "2948": 1, + "2949": 1, + "295": 1, + "2950": 1, + "2951": 1, + "2952": 1, + "2953": 1, + "2954": 1, + "2955": 1, + "2956": 1, + "2957": 1, + "2958": 1, + "2959": 1, + "296": 1, + "2960": 1, + "2961": 1, + "2962": 1, + "2963": 1, + "2964": 1, + "2965": 1, + "2966": 1, + "2967": 1, + "2968": 1, + "2969": 1, + "297": 1, + "2970": 1, + "2971": 1, + "2972": 1, + "2973": 1, + "2974": 1, + "2975": 1, + "2976": 1, + "2977": 1, + "2978": 1, + "2979": 1, + "298": 1, + "2980": 1, + "2981": 1, + "2982": 1, + "2983": 1, + "2984": 1, + "2985": 1, + "2986": 1, + "2987": 1, + "2988": 1, + "2989": 1, + "299": 1, + "2990": 1, + "2991": 1, + "2992": 1, + "2993": 1, + "2994": 1, + "2995": 1, + "2996": 1, + "2997": 1, + "2998": 1, + "2999": 1, + "3": 1, + "30": 1, + "300": 1, + "3000": 1, + "3001": 1, + "3002": 1, + "3003": 1, + "3004": 1, + "3005": 1, + "3006": 1, + "3007": 1, + "3008": 1, + "3009": 1, + "301": 1, + "3010": 1, + "3011": 1, + "3012": 1, + "3013": 1, + "3014": 1, + "3015": 1, + "3016": 1, + "3017": 1, + "3018": 1, + "3019": 1, + "302": 1, + "3020": 1, + "3021": 1, + "3022": 1, + "3023": 1, + "3024": 1, + "3025": 1, + "3026": 1, + "3027": 1, + "3028": 1, + "3029": 1, + "303": 1, + "3030": 1, + "3031": 1, + "3032": 1, + "3033": 1, + "3034": 1, + "3035": 1, + "3036": 1, + "3037": 1, + "3038": 1, + "3039": 1, + "304": 1, + "3040": 1, + "3041": 1, + "3042": 1, + "3043": 1, + "3044": 1, + "3045": 1, + "3046": 1, + "3047": 1, + "3048": 1, + "3049": 1, + "305": 1, + "3050": 1, + "3051": 1, + "3052": 1, + "3053": 1, + "3054": 1, + "3055": 1, + "3056": 1, + "3057": 1, + "3058": 1, + "3059": 1, + "306": 1, + "3060": 1, + "3061": 1, + "3062": 1, + "3063": 1, + "3064": 1, + "3065": 1, + "3066": 1, + "3067": 1, + "3068": 1, + "3069": 1, + "307": 1, + "3070": 1, + "3071": 1, + "3072": 1, + "3073": 1, + "3074": 1, + "3075": 1, + "3076": 1, + "3077": 1, + "3078": 1, + "3079": 1, + "308": 1, + "3080": 1, + "3081": 1, + "3082": 1, + "3083": 1, + "3084": 1, + "3085": 1, + "3086": 1, + "3087": 1, + "3088": 1, + "3089": 1, + "309": 1, + "3090": 1, + "3091": 1, + "3092": 1, + "3093": 1, + "3094": 1, + "3095": 1, + "3096": 1, + "3097": 1, + "3098": 1, + "3099": 1, + "31": 1, + "310": 1, + "3100": 1, + "3101": 1, + "3102": 1, + "3103": 1, + "3104": 1, + "3105": 1, + "3106": 1, + "3107": 1, + "3108": 1, + "3109": 1, + "311": 1, + "3110": 1, + "3111": 1, + "3112": 1, + "3113": 1, + "3114": 1, + "3115": 1, + "3116": 1, + "3117": 1, + "3118": 1, + "3119": 1, + "312": 1, + "3120": 1, + "3121": 1, + "3122": 1, + "3123": 1, + "3124": 1, + "3125": 1, + "3126": 1, + "3127": 1, + "3128": 1, + "3129": 1, + "313": 1, + "3130": 1, + "3131": 1, + "3132": 1, + "3133": 1, + "3134": 1, + "3135": 1, + "3136": 1, + "3137": 1, + "3138": 1, + "3139": 1, + "314": 1, + "3140": 1, + "3141": 1, + "3142": 1, + "3143": 1, + "3144": 1, + "3145": 1, + "3146": 1, + "3147": 1, + "3148": 1, + "3149": 1, + "315": 1, + "3150": 1, + "3151": 1, + "3152": 1, + "3153": 1, + "3154": 1, + "3155": 1, + "3156": 1, + "3157": 1, + "3158": 1, + "3159": 1, + "316": 1, + "3160": 1, + "3161": 1, + "3162": 1, + "3163": 1, + "3164": 1, + "3165": 1, + "3166": 1, + "3167": 1, + "3168": 1, + "3169": 1, + "317": 1, + "3170": 1, + "3171": 1, + "3172": 1, + "3173": 1, + "3174": 1, + "3175": 1, + "3176": 1, + "3177": 1, + "3178": 1, + "3179": 1, + "318": 1, + "3180": 1, + "3181": 1, + "3182": 1, + "3183": 1, + "3184": 1, + "3185": 1, + "3186": 1, + "3187": 1, + "3188": 1, + "3189": 1, + "319": 1, + "3190": 1, + "3191": 1, + "3192": 1, + "3193": 1, + "3194": 1, + "3195": 1, + "3196": 1, + "3197": 1, + "3198": 1, + "3199": 1, + "32": 1, + "320": 1, + "3200": 1, + "3201": 1, + "3202": 1, + "3203": 1, + "3204": 1, + "3205": 1, + "3206": 1, + "3207": 1, + "3208": 1, + "3209": 1, + "321": 1, + "3210": 1, + "3211": 1, + "3212": 1, + "3213": 1, + "3214": 1, + "3215": 1, + "3216": 1, + "3217": 1, + "3218": 1, + "3219": 1, + "322": 1, + "3220": 1, + "3221": 1, + "3222": 1, + "3223": 1, + "3224": 1, + "3225": 1, + "3226": 1, + "3227": 1, + "3228": 1, + "3229": 1, + "323": 1, + "3230": 1, + "3231": 1, + "3232": 1, + "3233": 1, + "3234": 1, + "3235": 1, + "3236": 1, + "3237": 1, + "3238": 1, + "3239": 1, + "324": 1, + "3240": 1, + "3241": 1, + "3242": 1, + "3243": 1, + "3244": 1, + "3245": 1, + "3246": 1, + "3247": 1, + "3248": 1, + "3249": 1, + "325": 1, + "3250": 1, + "3251": 1, + "3252": 1, + "3253": 1, + "3254": 1, + "3255": 1, + "3256": 1, + "3257": 1, + "3258": 1, + "3259": 1, + "326": 1, + "3260": 1, + "3261": 1, + "3262": 1, + "3263": 1, + "3264": 1, + "3265": 1, + "3266": 1, + "3267": 1, + "3268": 1, + "3269": 1, + "327": 1, + "3270": 1, + "3271": 1, + "3272": 1, + "3273": 1, + "3274": 1, + "3275": 1, + "3276": 1, + "3277": 1, + "3278": 1, + "3279": 1, + "328": 1, + "3280": 1, + "3281": 1, + "3282": 1, + "3283": 1, + "3284": 1, + "3285": 1, + "3286": 1, + "3287": 1, + "3288": 1, + "3289": 1, + "329": 1, + "3290": 1, + "3291": 1, + "3292": 1, + "3293": 1, + "3294": 1, + "3295": 1, + "3296": 1, + "3297": 1, + "3298": 1, + "3299": 1, + "33": 1, + "330": 1, + "3300": 1, + "3301": 1, + "3302": 1, + "3303": 1, + "3304": 1, + "3305": 1, + "3306": 1, + "3307": 1, + "3308": 1, + "3309": 1, + "331": 1, + "3310": 1, + "3311": 1, + "3312": 1, + "3313": 1, + "3314": 1, + "3315": 1, + "3316": 1, + "3317": 1, + "3318": 1, + "3319": 1, + "332": 1, + "3320": 1, + "3321": 1, + "3322": 1, + "3323": 1, + "3324": 1, + "3325": 1, + "3326": 1, + "3327": 1, + "3328": 1, + "3329": 1, + "333": 1, + "3330": 1, + "3331": 1, + "3332": 1, + "3333": 1, + "3334": 1, + "3335": 1, + "3336": 1, + "3337": 1, + "3338": 1, + "3339": 1, + "334": 1, + "3340": 1, + "3341": 1, + "3342": 1, + "3343": 1, + "3344": 1, + "3345": 1, + "3346": 1, + "3347": 1, + "3348": 1, + "3349": 1, + "335": 1, + "3350": 1, + "3351": 1, + "3352": 1, + "3353": 1, + "3354": 1, + "3355": 1, + "3356": 1, + "3357": 1, + "3358": 1, + "3359": 1, + "336": 1, + "3360": 1, + "3361": 1, + "3362": 1, + "3363": 1, + "3364": 1, + "3365": 1, + "3366": 1, + "3367": 1, + "3368": 1, + "3369": 1, + "337": 1, + "3370": 1, + "3371": 1, + "3372": 1, + "3373": 1, + "3374": 1, + "3375": 1, + "3376": 1, + "3377": 1, + "3378": 1, + "3379": 1, + "338": 1, + "3380": 1, + "3381": 1, + "3382": 1, + "3383": 1, + "3384": 1, + "3385": 1, + "3386": 1, + "3387": 1, + "3388": 1, + "3389": 1, + "339": 1, + "3390": 1, + "3391": 1, + "3392": 1, + "3393": 1, + "3394": 1, + "3395": 1, + "3396": 1, + "3397": 1, + "3398": 1, + "3399": 1, + "34": 1, + "340": 1, + "3400": 1, + "3401": 1, + "3402": 1, + "3403": 1, + "3404": 1, + "3405": 1, + "3406": 1, + "3407": 1, + "3408": 1, + "3409": 1, + "341": 1, + "3410": 1, + "3411": 1, + "3412": 1, + "3413": 1, + "3414": 1, + "3415": 1, + "3416": 1, + "3417": 1, + "3418": 1, + "3419": 1, + "342": 1, + "3420": 1, + "3421": 1, + "3422": 1, + "3423": 1, + "3424": 1, + "3425": 1, + "3426": 1, + "3427": 1, + "3428": 1, + "3429": 1, + "343": 1, + "3430": 1, + "3431": 1, + "3432": 1, + "3433": 1, + "3434": 1, + "3435": 1, + "3436": 1, + "3437": 1, + "3438": 1, + "3439": 1, + "344": 1, + "3440": 1, + "3441": 1, + "3442": 1, + "3443": 1, + "3444": 1, + "3445": 1, + "3446": 1, + "3447": 1, + "3448": 1, + "3449": 1, + "345": 1, + "3450": 1, + "3451": 1, + "3452": 1, + "3453": 1, + "3454": 1, + "3455": 1, + "3456": 1, + "3457": 1, + "3458": 1, + "3459": 1, + "346": 1, + "3460": 1, + "3461": 1, + "3462": 1, + "3463": 1, + "3464": 1, + "3465": 1, + "3466": 1, + "3467": 1, + "3468": 1, + "3469": 1, + "347": 1, + "3470": 1, + "3471": 1, + "3472": 1, + "3473": 1, + "3474": 1, + "3475": 1, + "3476": 1, + "3477": 1, + "3478": 1, + "3479": 1, + "348": 1, + "3480": 1, + "3481": 1, + "3482": 1, + "3483": 1, + "3484": 1, + "3485": 1, + "3486": 1, + "3487": 1, + "3488": 1, + "3489": 1, + "349": 1, + "3490": 1, + "3491": 1, + "3492": 1, + "3493": 1, + "3494": 1, + "3495": 1, + "3496": 1, + "3497": 1, + "3498": 1, + "3499": 1, + "35": 1, + "350": 1, + "3500": 1, + "3501": 1, + "3502": 1, + "3503": 1, + "3504": 1, + "3505": 1, + "3506": 1, + "3507": 1, + "3508": 1, + "3509": 1, + "351": 1, + "3510": 1, + "3511": 1, + "3512": 1, + "3513": 1, + "3514": 1, + "3515": 1, + "3516": 1, + "3517": 1, + "3518": 1, + "3519": 1, + "352": 1, + "3520": 1, + "3521": 1, + "3522": 1, + "3523": 1, + "3524": 1, + "3525": 1, + "3526": 1, + "3527": 1, + "3528": 1, + "3529": 1, + "353": 1, + "3530": 1, + "3531": 1, + "3532": 1, + "3533": 1, + "3534": 1, + "3535": 1, + "3536": 1, + "3537": 1, + "3538": 1, + "3539": 1, + "354": 1, + "3540": 1, + "3541": 1, + "3542": 1, + "3543": 1, + "3544": 1, + "3545": 1, + "3546": 1, + "3547": 1, + "3548": 1, + "3549": 1, + "355": 1, + "3550": 1, + "3551": 1, + "3552": 1, + "3553": 1, + "3554": 1, + "3555": 1, + "3556": 1, + "3557": 1, + "3558": 1, + "3559": 1, + "356": 1, + "3560": 1, + "3561": 1, + "3562": 1, + "3563": 1, + "3564": 1, + "3565": 1, + "3566": 1, + "3567": 1, + "3568": 1, + "3569": 1, + "357": 1, + "3570": 1, + "3571": 1, + "3572": 1, + "3573": 1, + "3574": 1, + "3575": 1, + "3576": 1, + "3577": 1, + "3578": 1, + "3579": 1, + "358": 1, + "3580": 1, + "3581": 1, + "3582": 1, + "3583": 1, + "3584": 1, + "3585": 1, + "3586": 1, + "3587": 1, + "3588": 1, + "3589": 1, + "359": 1, + "3590": 1, + "3591": 1, + "3592": 1, + "3593": 1, + "3594": 1, + "3595": 1, + "3596": 1, + "3597": 1, + "3598": 1, + "3599": 1, + "36": 1, + "360": 1, + "3600": 1, + "3601": 1, + "3602": 1, + "3603": 1, + "3604": 1, + "3605": 1, + "3606": 1, + "3607": 1, + "3608": 1, + "3609": 1, + "361": 1, + "3610": 1, + "3611": 1, + "3612": 1, + "3613": 1, + "3614": 1, + "3615": 1, + "3616": 1, + "3617": 1, + "3618": 1, + "3619": 1, + "362": 1, + "3620": 1, + "3621": 1, + "3622": 1, + "3623": 1, + "3624": 1, + "3625": 1, + "3626": 1, + "3627": 1, + "3628": 1, + "3629": 1, + "363": 1, + "3630": 1, + "3631": 1, + "3632": 1, + "3633": 1, + "3634": 1, + "3635": 1, + "3636": 1, + "3637": 1, + "3638": 1, + "3639": 1, + "364": 1, + "3640": 1, + "3641": 1, + "3642": 1, + "3643": 1, + "3644": 1, + "3645": 1, + "3646": 1, + "3647": 1, + "3648": 1, + "3649": 1, + "365": 1, + "3650": 1, + "3651": 1, + "3652": 1, + "3653": 1, + "3654": 1, + "3655": 1, + "3656": 1, + "3657": 1, + "3658": 1, + "3659": 1, + "366": 1, + "3660": 1, + "3661": 1, + "3662": 1, + "3663": 1, + "3664": 1, + "3665": 1, + "3666": 1, + "3667": 1, + "3668": 1, + "3669": 1, + "367": 1, + "3670": 1, + "3671": 1, + "3672": 1, + "3673": 1, + "3674": 1, + "3675": 1, + "3676": 1, + "3677": 1, + "3678": 1, + "3679": 1, + "368": 1, + "3680": 1, + "3681": 1, + "3682": 1, + "3683": 1, + "3684": 1, + "3685": 1, + "3686": 1, + "3687": 1, + "3688": 1, + "3689": 1, + "369": 1, + "3690": 1, + "3691": 1, + "3692": 1, + "3693": 1, + "3694": 1, + "3695": 1, + "3696": 1, + "3697": 1, + "3698": 1, + "3699": 1, + "37": 1, + "370": 1, + "3700": 1, + "3701": 1, + "3702": 1, + "3703": 1, + "3704": 1, + "3705": 1, + "3706": 1, + "3707": 1, + "3708": 1, + "3709": 1, + "371": 1, + "3710": 1, + "3711": 1, + "3712": 1, + "3713": 1, + "3714": 1, + "3715": 1, + "3716": 1, + "3717": 1, + "3718": 1, + "3719": 1, + "372": 1, + "3720": 1, + "3721": 1, + "3722": 1, + "3723": 1, + "3724": 1, + "3725": 1, + "3726": 1, + "3727": 1, + "3728": 1, + "3729": 1, + "373": 1, + "3730": 1, + "3731": 1, + "3732": 1, + "3733": 1, + "3734": 1, + "3735": 1, + "3736": 1, + "3737": 1, + "3738": 1, + "3739": 1, + "374": 1, + "3740": 1, + "3741": 1, + "3742": 1, + "3743": 1, + "3744": 1, + "3745": 1, + "3746": 1, + "3747": 1, + "3748": 1, + "3749": 1, + "375": 1, + "3750": 1, + "3751": 1, + "3752": 1, + "3753": 1, + "3754": 1, + "3755": 1, + "3756": 1, + "3757": 1, + "3758": 1, + "3759": 1, + "376": 1, + "3760": 1, + "3761": 1, + "3762": 1, + "3763": 1, + "3764": 1, + "3765": 1, + "3766": 1, + "3767": 1, + "3768": 1, + "3769": 1, + "377": 1, + "3770": 1, + "3771": 1, + "3772": 1, + "3773": 1, + "3774": 1, + "3775": 1, + "3776": 1, + "3777": 1, + "3778": 1, + "3779": 1, + "378": 1, + "3780": 1, + "3781": 1, + "3782": 1, + "3783": 1, + "3784": 1, + "3785": 1, + "3786": 1, + "3787": 1, + "3788": 1, + "3789": 1, + "379": 1, + "3790": 1, + "3791": 1, + "3792": 1, + "3793": 1, + "3794": 1, + "3795": 1, + "3796": 1, + "3797": 1, + "3798": 1, + "3799": 1, + "38": 1, + "380": 1, + "3800": 1, + "3801": 1, + "3802": 1, + "3803": 1, + "3804": 1, + "3805": 1, + "3806": 1, + "3807": 1, + "3808": 1, + "3809": 1, + "381": 1, + "3810": 1, + "3811": 1, + "3812": 1, + "3813": 1, + "3814": 1, + "3815": 1, + "3816": 1, + "3817": 1, + "3818": 1, + "3819": 1, + "382": 1, + "3820": 1, + "3821": 1, + "3822": 1, + "3823": 1, + "3824": 1, + "3825": 1, + "3826": 1, + "3827": 1, + "3828": 1, + "3829": 1, + "383": 1, + "3830": 1, + "3831": 1, + "3832": 1, + "3833": 1, + "3834": 1, + "3835": 1, + "3836": 1, + "3837": 1, + "3838": 1, + "3839": 1, + "384": 1, + "3840": 1, + "3841": 1, + "3842": 1, + "3843": 1, + "3844": 1, + "3845": 1, + "3846": 1, + "3847": 1, + "3848": 1, + "3849": 1, + "385": 1, + "3850": 1, + "3851": 1, + "3852": 1, + "3853": 1, + "3854": 1, + "3855": 1, + "3856": 1, + "3857": 1, + "3858": 1, + "3859": 1, + "386": 1, + "3860": 1, + "3861": 1, + "3862": 1, + "3863": 1, + "3864": 1, + "3865": 1, + "3866": 1, + "3867": 1, + "3868": 1, + "3869": 1, + "387": 1, + "3870": 1, + "3871": 1, + "3872": 1, + "3873": 1, + "3874": 1, + "3875": 1, + "3876": 1, + "3877": 1, + "3878": 1, + "3879": 1, + "388": 1, + "3880": 1, + "3881": 1, + "3882": 1, + "3883": 1, + "3884": 1, + "3885": 1, + "3886": 1, + "3887": 1, + "3888": 1, + "3889": 1, + "389": 1, + "3890": 1, + "3891": 1, + "3892": 1, + "3893": 1, + "3894": 1, + "3895": 1, + "3896": 1, + "3897": 1, + "3898": 1, + "3899": 1, + "39": 1, + "390": 1, + "3900": 1, + "3901": 1, + "3902": 1, + "3903": 1, + "3904": 1, + "3905": 1, + "3906": 1, + "3907": 1, + "3908": 1, + "3909": 1, + "391": 1, + "3910": 1, + "3911": 1, + "3912": 1, + "3913": 1, + "3914": 1, + "3915": 1, + "3916": 1, + "3917": 1, + "3918": 1, + "3919": 1, + "392": 1, + "3920": 1, + "3921": 1, + "3922": 1, + "3923": 1, + "3924": 1, + "3925": 1, + "3926": 1, + "3927": 1, + "3928": 1, + "3929": 1, + "393": 1, + "3930": 1, + "3931": 1, + "3932": 1, + "3933": 1, + "3934": 1, + "3935": 1, + "3936": 1, + "3937": 1, + "3938": 1, + "3939": 1, + "394": 1, + "3940": 1, + "3941": 1, + "3942": 1, + "3943": 1, + "3944": 1, + "3945": 1, + "3946": 1, + "3947": 1, + "3948": 1, + "3949": 1, + "395": 1, + "3950": 1, + "3951": 1, + "3952": 1, + "3953": 1, + "3954": 1, + "3955": 1, + "3956": 1, + "3957": 1, + "3958": 1, + "3959": 1, + "396": 1, + "3960": 1, + "3961": 1, + "3962": 1, + "3963": 1, + "3964": 1, + "3965": 1, + "3966": 1, + "3967": 1, + "3968": 1, + "3969": 1, + "397": 1, + "3970": 1, + "3971": 1, + "3972": 1, + "3973": 1, + "3974": 1, + "3975": 1, + "3976": 1, + "3977": 1, + "3978": 1, + "3979": 1, + "398": 1, + "3980": 1, + "3981": 1, + "3982": 1, + "3983": 1, + "3984": 1, + "3985": 1, + "3986": 1, + "3987": 1, + "3988": 1, + "3989": 1, + "399": 1, + "3990": 1, + "3991": 1, + "3992": 1, + "3993": 1, + "3994": 1, + "3995": 1, + "3996": 1, + "3997": 1, + "3998": 1, + "3999": 1, + "4": 1, + "40": 1, + "400": 1, + "4000": 1, + "4001": 1, + "4002": 1, + "4003": 1, + "4004": 1, + "4005": 1, + "4006": 1, + "4007": 1, + "4008": 1, + "4009": 1, + "401": 1, + "4010": 1, + "4011": 1, + "4012": 1, + "4013": 1, + "4014": 1, + "4015": 1, + "4016": 1, + "4017": 1, + "4018": 1, + "4019": 1, + "402": 1, + "4020": 1, + "4021": 1, + "4022": 1, + "4023": 1, + "4024": 1, + "4025": 1, + "4026": 1, + "4027": 1, + "4028": 1, + "4029": 1, + "403": 1, + "4030": 1, + "4031": 1, + "4032": 1, + "4033": 1, + "4034": 1, + "4035": 1, + "4036": 1, + "4037": 1, + "4038": 1, + "4039": 1, + "404": 1, + "4040": 1, + "4041": 1, + "4042": 1, + "4043": 1, + "4044": 1, + "4045": 1, + "4046": 1, + "4047": 1, + "4048": 1, + "4049": 1, + "405": 1, + "4050": 1, + "4051": 1, + "4052": 1, + "4053": 1, + "4054": 1, + "4055": 1, + "4056": 1, + "4057": 1, + "4058": 1, + "4059": 1, + "406": 1, + "4060": 1, + "4061": 1, + "4062": 1, + "4063": 1, + "4064": 1, + "4065": 1, + "4066": 1, + "4067": 1, + "4068": 1, + "4069": 1, + "407": 1, + "4070": 1, + "4071": 1, + "4072": 1, + "4073": 1, + "4074": 1, + "4075": 1, + "4076": 1, + "4077": 1, + "4078": 1, + "4079": 1, + "408": 1, + "4080": 1, + "4081": 1, + "4082": 1, + "4083": 1, + "4084": 1, + "4085": 1, + "4086": 1, + "4087": 1, + "4088": 1, + "4089": 1, + "409": 1, + "4090": 1, + "4091": 1, + "4092": 1, + "4093": 1, + "4094": 1, + "4095": 1, + "4096": 1, + "4097": 1, + "4098": 1, + "4099": 1, + "41": 1, + "410": 1, + "4100": 1, + "4101": 1, + "4102": 1, + "4103": 1, + "4104": 1, + "4105": 1, + "4106": 1, + "4107": 1, + "4108": 1, + "4109": 1, + "411": 1, + "4110": 1, + "4111": 1, + "4112": 1, + "4113": 1, + "4114": 1, + "4115": 1, + "4116": 1, + "4117": 1, + "4118": 1, + "4119": 1, + "412": 1, + "4120": 1, + "4121": 1, + "4122": 1, + "4123": 1, + "4124": 1, + "4125": 1, + "4126": 1, + "4127": 1, + "4128": 1, + "4129": 1, + "413": 1, + "4130": 1, + "4131": 1, + "4132": 1, + "4133": 1, + "4134": 1, + "4135": 1, + "4136": 1, + "4137": 1, + "4138": 1, + "4139": 1, + "414": 1, + "4140": 1, + "4141": 1, + "4142": 1, + "4143": 1, + "4144": 1, + "4145": 1, + "4146": 1, + "4147": 1, + "4148": 1, + "4149": 1, + "415": 1, + "4150": 1, + "4151": 1, + "4152": 1, + "4153": 1, + "4154": 1, + "4155": 1, + "4156": 1, + "4157": 1, + "4158": 1, + "4159": 1, + "416": 1, + "4160": 1, + "4161": 1, + "4162": 1, + "4163": 1, + "4164": 1, + "4165": 1, + "4166": 1, + "4167": 1, + "4168": 1, + "4169": 1, + "417": 1, + "4170": 1, + "4171": 1, + "4172": 1, + "4173": 1, + "4174": 1, + "4175": 1, + "4176": 1, + "4177": 1, + "4178": 1, + "4179": 1, + "418": 1, + "4180": 1, + "4181": 1, + "4182": 1, + "4183": 1, + "4184": 1, + "4185": 1, + "4186": 1, + "4187": 1, + "4188": 1, + "4189": 1, + "419": 1, + "4190": 1, + "4191": 1, + "4192": 1, + "4193": 1, + "4194": 1, + "4195": 1, + "4196": 1, + "4197": 1, + "4198": 1, + "4199": 1, + "42": 1, + "420": 1, + "4200": 1, + "4201": 1, + "4202": 1, + "4203": 1, + "4204": 1, + "4205": 1, + "4206": 1, + "4207": 1, + "4208": 1, + "4209": 1, + "421": 1, + "4210": 1, + "4211": 1, + "4212": 1, + "4213": 1, + "4214": 1, + "4215": 1, + "4216": 1, + "4217": 1, + "4218": 1, + "4219": 1, + "422": 1, + "4220": 1, + "4221": 1, + "4222": 1, + "4223": 1, + "4224": 1, + "4225": 1, + "4226": 1, + "4227": 1, + "4228": 1, + "4229": 1, + "423": 1, + "4230": 1, + "4231": 1, + "4232": 1, + "4233": 1, + "4234": 1, + "4235": 1, + "4236": 1, + "4237": 1, + "4238": 1, + "4239": 1, + "424": 1, + "4240": 1, + "4241": 1, + "4242": 1, + "4243": 1, + "4244": 1, + "4245": 1, + "4246": 1, + "4247": 1, + "4248": 1, + "4249": 1, + "425": 1, + "4250": 1, + "4251": 1, + "4252": 1, + "4253": 1, + "4254": 1, + "4255": 1, + "4256": 1, + "4257": 1, + "4258": 1, + "4259": 1, + "426": 1, + "4260": 1, + "4261": 1, + "4262": 1, + "4263": 1, + "4264": 1, + "4265": 1, + "4266": 1, + "4267": 1, + "4268": 1, + "4269": 1, + "427": 1, + "4270": 1, + "4271": 1, + "4272": 1, + "4273": 1, + "4274": 1, + "4275": 1, + "4276": 1, + "4277": 1, + "4278": 1, + "4279": 1, + "428": 1, + "4280": 1, + "4281": 1, + "4282": 1, + "4283": 1, + "4284": 1, + "4285": 1, + "4286": 1, + "4287": 1, + "4288": 1, + "4289": 1, + "429": 1, + "4290": 1, + "4291": 1, + "4292": 1, + "4293": 1, + "4294": 1, + "4295": 1, + "4296": 1, + "4297": 1, + "4298": 1, + "4299": 1, + "43": 1, + "430": 1, + "4300": 1, + "4301": 1, + "4302": 1, + "4303": 1, + "4304": 1, + "4305": 1, + "4306": 1, + "4307": 1, + "4308": 1, + "4309": 1, + "431": 1, + "4310": 1, + "4311": 1, + "4312": 1, + "4313": 1, + "4314": 1, + "4315": 1, + "4316": 1, + "4317": 1, + "4318": 1, + "4319": 1, + "432": 1, + "4320": 1, + "4321": 1, + "4322": 1, + "4323": 1, + "4324": 1, + "4325": 1, + "4326": 1, + "4327": 1, + "4328": 1, + "4329": 1, + "433": 1, + "4330": 1, + "4331": 1, + "4332": 1, + "4333": 1, + "4334": 1, + "4335": 1, + "4336": 1, + "4337": 1, + "4338": 1, + "4339": 1, + "434": 1, + "4340": 1, + "4341": 1, + "4342": 1, + "4343": 1, + "4344": 1, + "4345": 1, + "4346": 1, + "4347": 1, + "4348": 1, + "4349": 1, + "435": 1, + "4350": 1, + "4351": 1, + "4352": 1, + "4353": 1, + "4354": 1, + "4355": 1, + "4356": 1, + "4357": 1, + "4358": 1, + "4359": 1, + "436": 1, + "4360": 1, + "4361": 1, + "4362": 1, + "4363": 1, + "4364": 1, + "4365": 1, + "4366": 1, + "4367": 1, + "4368": 1, + "4369": 1, + "437": 1, + "4370": 1, + "4371": 1, + "4372": 1, + "4373": 1, + "4374": 1, + "4375": 1, + "4376": 1, + "4377": 1, + "4378": 1, + "4379": 1, + "438": 1, + "4380": 1, + "4381": 1, + "4382": 1, + "4383": 1, + "4384": 1, + "4385": 1, + "4386": 1, + "4387": 1, + "4388": 1, + "4389": 1, + "439": 1, + "4390": 1, + "4391": 1, + "4392": 1, + "4393": 1, + "4394": 1, + "4395": 1, + "4396": 1, + "4397": 1, + "4398": 1, + "4399": 1, + "44": 1, + "440": 1, + "4400": 1, + "4401": 1, + "4402": 1, + "4403": 1, + "4404": 1, + "4405": 1, + "4406": 1, + "4407": 1, + "4408": 1, + "4409": 1, + "441": 1, + "4410": 1, + "4411": 1, + "4412": 1, + "4413": 1, + "4414": 1, + "4415": 1, + "4416": 1, + "4417": 1, + "4418": 1, + "4419": 1, + "442": 1, + "4420": 1, + "4421": 1, + "4422": 1, + "4423": 1, + "4424": 1, + "4425": 1, + "4426": 1, + "4427": 1, + "4428": 1, + "4429": 1, + "443": 1, + "4430": 1, + "4431": 1, + "4432": 1, + "4433": 1, + "4434": 1, + "4435": 1, + "4436": 1, + "4437": 1, + "4438": 1, + "4439": 1, + "444": 1, + "4440": 1, + "4441": 1, + "4442": 1, + "4443": 1, + "4444": 1, + "4445": 1, + "4446": 1, + "4447": 1, + "4448": 1, + "4449": 1, + "445": 1, + "4450": 1, + "4451": 1, + "4452": 1, + "4453": 1, + "4454": 1, + "4455": 1, + "4456": 1, + "4457": 1, + "4458": 1, + "4459": 1, + "446": 1, + "4460": 1, + "4461": 1, + "4462": 1, + "4463": 1, + "4464": 1, + "4465": 1, + "4466": 1, + "4467": 1, + "4468": 1, + "4469": 1, + "447": 1, + "4470": 1, + "4471": 1, + "4472": 1, + "4473": 1, + "4474": 1, + "4475": 1, + "4476": 1, + "4477": 1, + "4478": 1, + "4479": 1, + "448": 1, + "4480": 1, + "4481": 1, + "4482": 1, + "4483": 1, + "4484": 1, + "4485": 1, + "4486": 1, + "4487": 1, + "4488": 1, + "4489": 1, + "449": 1, + "4490": 1, + "4491": 1, + "4492": 1, + "4493": 1, + "4494": 1, + "4495": 1, + "4496": 1, + "4497": 1, + "4498": 1, + "4499": 1, + "45": 1, + "450": 1, + "4500": 1, + "4501": 1, + "4502": 1, + "4503": 1, + "4504": 1, + "4505": 1, + "4506": 1, + "4507": 1, + "4508": 1, + "4509": 1, + "451": 1, + "4510": 1, + "4511": 1, + "4512": 1, + "4513": 1, + "4514": 1, + "4515": 1, + "4516": 1, + "4517": 1, + "4518": 1, + "4519": 1, + "452": 1, + "4520": 1, + "4521": 1, + "4522": 1, + "4523": 1, + "4524": 1, + "4525": 1, + "4526": 1, + "4527": 1, + "4528": 1, + "4529": 1, + "453": 1, + "4530": 1, + "4531": 1, + "4532": 1, + "4533": 1, + "4534": 1, + "4535": 1, + "4536": 1, + "4537": 1, + "4538": 1, + "4539": 1, + "454": 1, + "4540": 1, + "4541": 1, + "4542": 1, + "4543": 1, + "4544": 1, + "4545": 1, + "4546": 1, + "4547": 1, + "4548": 1, + "4549": 1, + "455": 1, + "4550": 1, + "4551": 1, + "4552": 1, + "4553": 1, + "4554": 1, + "4555": 1, + "4556": 1, + "4557": 1, + "4558": 1, + "4559": 1, + "456": 1, + "4560": 1, + "4561": 1, + "4562": 1, + "4563": 1, + "4564": 1, + "4565": 1, + "4566": 1, + "4567": 1, + "4568": 1, + "4569": 1, + "457": 1, + "4570": 1, + "4571": 1, + "4572": 1, + "4573": 1, + "4574": 1, + "4575": 1, + "4576": 1, + "4577": 1, + "4578": 1, + "4579": 1, + "458": 1, + "4580": 1, + "4581": 1, + "4582": 1, + "4583": 1, + "4584": 1, + "4585": 1, + "4586": 1, + "4587": 1, + "4588": 1, + "4589": 1, + "459": 1, + "4590": 1, + "4591": 1, + "4592": 1, + "4593": 1, + "4594": 1, + "4595": 1, + "4596": 1, + "4597": 1, + "4598": 1, + "4599": 1, + "46": 1, + "460": 1, + "4600": 1, + "4601": 1, + "4602": 1, + "4603": 1, + "4604": 1, + "4605": 1, + "4606": 1, + "4607": 1, + "4608": 1, + "4609": 1, + "461": 1, + "4610": 1, + "4611": 1, + "4612": 1, + "4613": 1, + "4614": 1, + "4615": 1, + "4616": 1, + "4617": 1, + "4618": 1, + "4619": 1, + "462": 1, + "4620": 1, + "4621": 1, + "4622": 1, + "4623": 1, + "4624": 1, + "4625": 1, + "4626": 1, + "4627": 1, + "4628": 1, + "4629": 1, + "463": 1, + "4630": 1, + "4631": 1, + "4632": 1, + "4633": 1, + "4634": 1, + "4635": 1, + "4636": 1, + "4637": 1, + "4638": 1, + "4639": 1, + "464": 1, + "4640": 1, + "4641": 1, + "4642": 1, + "4643": 1, + "4644": 1, + "4645": 1, + "4646": 1, + "4647": 1, + "4648": 1, + "4649": 1, + "465": 1, + "4650": 1, + "4651": 1, + "4652": 1, + "4653": 1, + "4654": 1, + "4655": 1, + "4656": 1, + "4657": 1, + "4658": 1, + "4659": 1, + "466": 1, + "4660": 1, + "4661": 1, + "4662": 1, + "4663": 1, + "4664": 1, + "4665": 1, + "4666": 1, + "4667": 1, + "4668": 1, + "4669": 1, + "467": 1, + "4670": 1, + "4671": 1, + "4672": 1, + "4673": 1, + "4674": 1, + "4675": 1, + "4676": 1, + "4677": 1, + "4678": 1, + "4679": 1, + "468": 1, + "4680": 1, + "4681": 1, + "4682": 1, + "4683": 1, + "4684": 1, + "4685": 1, + "4686": 1, + "4687": 1, + "4688": 1, + "4689": 1, + "469": 1, + "4690": 1, + "4691": 1, + "4692": 1, + "4693": 1, + "4694": 1, + "4695": 1, + "4696": 1, + "4697": 1, + "4698": 1, + "4699": 1, + "47": 1, + "470": 1, + "4700": 1, + "4701": 1, + "4702": 1, + "4703": 1, + "4704": 1, + "4705": 1, + "4706": 1, + "4707": 1, + "4708": 1, + "4709": 1, + "471": 1, + "4710": 1, + "4711": 1, + "4712": 1, + "4713": 1, + "4714": 1, + "4715": 1, + "4716": 1, + "4717": 1, + "4718": 1, + "4719": 1, + "472": 1, + "4720": 1, + "4721": 1, + "4722": 1, + "4723": 1, + "4724": 1, + "4725": 1, + "4726": 1, + "4727": 1, + "4728": 1, + "4729": 1, + "473": 1, + "4730": 1, + "4731": 1, + "4732": 1, + "4733": 1, + "4734": 1, + "4735": 1, + "4736": 1, + "4737": 1, + "4738": 1, + "4739": 1, + "474": 1, + "4740": 1, + "4741": 1, + "4742": 1, + "4743": 1, + "4744": 1, + "4745": 1, + "4746": 1, + "4747": 1, + "4748": 1, + "4749": 1, + "475": 1, + "4750": 1, + "4751": 1, + "4752": 1, + "4753": 1, + "4754": 1, + "4755": 1, + "4756": 1, + "4757": 1, + "4758": 1, + "4759": 1, + "476": 1, + "4760": 1, + "4761": 1, + "4762": 1, + "4763": 1, + "4764": 1, + "4765": 1, + "4766": 1, + "4767": 1, + "4768": 1, + "4769": 1, + "477": 1, + "4770": 1, + "4771": 1, + "4772": 1, + "4773": 1, + "4774": 1, + "4775": 1, + "4776": 1, + "4777": 1, + "4778": 1, + "4779": 1, + "478": 1, + "4780": 1, + "4781": 1, + "4782": 1, + "4783": 1, + "4784": 1, + "4785": 1, + "4786": 1, + "4787": 1, + "4788": 1, + "4789": 1, + "479": 1, + "4790": 1, + "4791": 1, + "4792": 1, + "4793": 1, + "4794": 1, + "4795": 1, + "4796": 1, + "4797": 1, + "4798": 1, + "4799": 1, + "48": 1, + "480": 1, + "4800": 1, + "4801": 1, + "4802": 1, + "4803": 1, + "4804": 1, + "4805": 1, + "4806": 1, + "4807": 1, + "4808": 1, + "4809": 1, + "481": 1, + "4810": 1, + "4811": 1, + "4812": 1, + "4813": 1, + "4814": 1, + "4815": 1, + "4816": 1, + "4817": 1, + "4818": 1, + "4819": 1, + "482": 1, + "4820": 1, + "4821": 1, + "4822": 1, + "4823": 1, + "4824": 1, + "4825": 1, + "4826": 1, + "4827": 1, + "4828": 1, + "4829": 1, + "483": 1, + "4830": 1, + "4831": 1, + "4832": 1, + "4833": 1, + "4834": 1, + "4835": 1, + "4836": 1, + "4837": 1, + "4838": 1, + "4839": 1, + "484": 1, + "4840": 1, + "4841": 1, + "4842": 1, + "4843": 1, + "4844": 1, + "4845": 1, + "4846": 1, + "4847": 1, + "4848": 1, + "4849": 1, + "485": 1, + "4850": 1, + "4851": 1, + "4852": 1, + "4853": 1, + "4854": 1, + "4855": 1, + "4856": 1, + "4857": 1, + "4858": 1, + "4859": 1, + "486": 1, + "4860": 1, + "4861": 1, + "4862": 1, + "4863": 1, + "4864": 1, + "4865": 1, + "4866": 1, + "4867": 1, + "4868": 1, + "4869": 1, + "487": 1, + "4870": 1, + "4871": 1, + "4872": 1, + "4873": 1, + "4874": 1, + "4875": 1, + "4876": 1, + "4877": 1, + "4878": 1, + "4879": 1, + "488": 1, + "4880": 1, + "4881": 1, + "4882": 1, + "4883": 1, + "4884": 1, + "4885": 1, + "4886": 1, + "4887": 1, + "4888": 1, + "4889": 1, + "489": 1, + "4890": 1, + "4891": 1, + "4892": 1, + "4893": 1, + "4894": 1, + "4895": 1, + "4896": 1, + "4897": 1, + "4898": 1, + "4899": 1, + "49": 1, + "490": 1, + "4900": 1, + "4901": 1, + "4902": 1, + "4903": 1, + "4904": 1, + "4905": 1, + "4906": 1, + "4907": 1, + "4908": 1, + "4909": 1, + "491": 1, + "4910": 1, + "4911": 1, + "4912": 1, + "4913": 1, + "4914": 1, + "4915": 1, + "4916": 1, + "4917": 1, + "4918": 1, + "4919": 1, + "492": 1, + "4920": 1, + "4921": 1, + "4922": 1, + "4923": 1, + "4924": 1, + "4925": 1, + "4926": 1, + "4927": 1, + "4928": 1, + "4929": 1, + "493": 1, + "4930": 1, + "4931": 1, + "4932": 1, + "4933": 1, + "4934": 1, + "4935": 1, + "4936": 1, + "4937": 1, + "4938": 1, + "4939": 1, + "494": 1, + "4940": 1, + "4941": 1, + "4942": 1, + "4943": 1, + "4944": 1, + "4945": 1, + "4946": 1, + "4947": 1, + "4948": 1, + "4949": 1, + "495": 1, + "4950": 1, + "4951": 1, + "4952": 1, + "4953": 1, + "4954": 1, + "4955": 1, + "4956": 1, + "4957": 1, + "4958": 1, + "4959": 1, + "496": 1, + "4960": 1, + "4961": 1, + "4962": 1, + "4963": 1, + "4964": 1, + "4965": 1, + "4966": 1, + "4967": 1, + "4968": 1, + "4969": 1, + "497": 1, + "4970": 1, + "4971": 1, + "4972": 1, + "4973": 1, + "4974": 1, + "4975": 1, + "4976": 1, + "4977": 1, + "4978": 1, + "4979": 1, + "498": 1, + "4980": 1, + "4981": 1, + "4982": 1, + "4983": 1, + "4984": 1, + "4985": 1, + "4986": 1, + "4987": 1, + "4988": 1, + "4989": 1, + "499": 1, + "4990": 1, + "4991": 1, + "4992": 1, + "4993": 1, + "4994": 1, + "4995": 1, + "4996": 1, + "4997": 1, + "4998": 1, + "4999": 1, + "5": 1, + "50": 1, + "500": 1, + "5000": 1, + "5001": 1, + "5002": 1, + "5003": 1, + "5004": 1, + "5005": 1, + "5006": 1, + "5007": 1, + "5008": 1, + "5009": 1, + "501": 1, + "5010": 1, + "5011": 1, + "5012": 1, + "5013": 1, + "5014": 1, + "5015": 1, + "5016": 1, + "5017": 1, + "5018": 1, + "5019": 1, + "502": 1, + "5020": 1, + "5021": 1, + "5022": 1, + "5023": 1, + "5024": 1, + "5025": 1, + "5026": 1, + "5027": 1, + "5028": 1, + "5029": 1, + "503": 1, + "5030": 1, + "5031": 1, + "5032": 1, + "5033": 1, + "5034": 1, + "5035": 1, + "5036": 1, + "5037": 1, + "5038": 1, + "5039": 1, + "504": 1, + "5040": 1, + "5041": 1, + "5042": 1, + "5043": 1, + "5044": 1, + "5045": 1, + "5046": 1, + "5047": 1, + "5048": 1, + "5049": 1, + "505": 1, + "5050": 1, + "5051": 1, + "5052": 1, + "5053": 1, + "5054": 1, + "5055": 1, + "5056": 1, + "5057": 1, + "5058": 1, + "5059": 1, + "506": 1, + "5060": 1, + "5061": 1, + "5062": 1, + "5063": 1, + "5064": 1, + "5065": 1, + "5066": 1, + "5067": 1, + "5068": 1, + "5069": 1, + "507": 1, + "5070": 1, + "5071": 1, + "5072": 1, + "5073": 1, + "5074": 1, + "5075": 1, + "5076": 1, + "5077": 1, + "5078": 1, + "5079": 1, + "508": 1, + "5080": 1, + "5081": 1, + "5082": 1, + "5083": 1, + "5084": 1, + "5085": 1, + "5086": 1, + "5087": 1, + "5088": 1, + "5089": 1, + "509": 1, + "5090": 1, + "5091": 1, + "5092": 1, + "5093": 1, + "5094": 1, + "5095": 1, + "5096": 1, + "5097": 1, + "5098": 1, + "5099": 1, + "51": 1, + "510": 1, + "5100": 1, + "5101": 1, + "5102": 1, + "5103": 1, + "5104": 1, + "5105": 1, + "5106": 1, + "5107": 1, + "5108": 1, + "5109": 1, + "511": 1, + "5110": 1, + "5111": 1, + "5112": 1, + "5113": 1, + "5114": 1, + "5115": 1, + "5116": 1, + "5117": 1, + "5118": 1, + "5119": 1, + "512": 1, + "5120": 1, + "5121": 1, + "5122": 1, + "5123": 1, + "5124": 1, + "5125": 1, + "5126": 1, + "5127": 1, + "5128": 1, + "5129": 1, + "513": 1, + "5130": 1, + "5131": 1, + "5132": 1, + "5133": 1, + "5134": 1, + "5135": 1, + "5136": 1, + "5137": 1, + "5138": 1, + "5139": 1, + "514": 1, + "5140": 1, + "5141": 1, + "5142": 1, + "5143": 1, + "5144": 1, + "5145": 1, + "5146": 1, + "5147": 1, + "5148": 1, + "5149": 1, + "515": 1, + "5150": 1, + "5151": 1, + "5152": 1, + "5153": 1, + "5154": 1, + "5155": 1, + "5156": 1, + "5157": 1, + "5158": 1, + "5159": 1, + "516": 1, + "5160": 1, + "5161": 1, + "5162": 1, + "5163": 1, + "5164": 1, + "5165": 1, + "5166": 1, + "5167": 1, + "5168": 1, + "5169": 1, + "517": 1, + "5170": 1, + "5171": 1, + "5172": 1, + "5173": 1, + "5174": 1, + "5175": 1, + "5176": 1, + "5177": 1, + "5178": 1, + "5179": 1, + "518": 1, + "5180": 1, + "5181": 1, + "5182": 1, + "5183": 1, + "5184": 1, + "5185": 1, + "5186": 1, + "5187": 1, + "5188": 1, + "5189": 1, + "519": 1, + "5190": 1, + "5191": 1, + "5192": 1, + "5193": 1, + "5194": 1, + "5195": 1, + "5196": 1, + "5197": 1, + "5198": 1, + "5199": 1, + "52": 1, + "520": 1, + "5200": 1, + "5201": 1, + "5202": 1, + "5203": 1, + "5204": 1, + "5205": 1, + "5206": 1, + "5207": 1, + "5208": 1, + "5209": 1, + "521": 1, + "5210": 1, + "5211": 1, + "5212": 1, + "5213": 1, + "5214": 1, + "5215": 1, + "5216": 1, + "5217": 1, + "5218": 1, + "5219": 1, + "522": 1, + "5220": 1, + "5221": 1, + "5222": 1, + "5223": 1, + "5224": 1, + "5225": 1, + "5226": 1, + "5227": 1, + "5228": 1, + "5229": 1, + "523": 1, + "5230": 1, + "5231": 1, + "5232": 1, + "5233": 1, + "5234": 1, + "5235": 1, + "5236": 1, + "5237": 1, + "5238": 1, + "5239": 1, + "524": 1, + "5240": 1, + "5241": 1, + "5242": 1, + "5243": 1, + "5244": 1, + "5245": 1, + "5246": 1, + "5247": 1, + "5248": 1, + "5249": 1, + "525": 1, + "5250": 1, + "5251": 1, + "5252": 1, + "5253": 1, + "5254": 1, + "5255": 1, + "5256": 1, + "5257": 1, + "5258": 1, + "5259": 1, + "526": 1, + "5260": 1, + "5261": 1, + "5262": 1, + "5263": 1, + "5264": 1, + "5265": 1, + "5266": 1, + "5267": 1, + "5268": 1, + "5269": 1, + "527": 1, + "5270": 1, + "5271": 1, + "5272": 1, + "5273": 1, + "5274": 1, + "5275": 1, + "5276": 1, + "5277": 1, + "5278": 1, + "5279": 1, + "528": 1, + "5280": 1, + "5281": 1, + "5282": 1, + "5283": 1, + "5284": 1, + "5285": 1, + "5286": 1, + "5287": 1, + "5288": 1, + "5289": 1, + "529": 1, + "5290": 1, + "5291": 1, + "5292": 1, + "5293": 1, + "5294": 1, + "5295": 1, + "5296": 1, + "5297": 1, + "5298": 1, + "5299": 1, + "53": 1, + "530": 1, + "5300": 1, + "5301": 1, + "5302": 1, + "5303": 1, + "5304": 1, + "5305": 1, + "5306": 1, + "5307": 1, + "5308": 1, + "5309": 1, + "531": 1, + "5310": 1, + "5311": 1, + "5312": 1, + "5313": 1, + "5314": 1, + "5315": 1, + "5316": 1, + "5317": 1, + "5318": 1, + "5319": 1, + "532": 1, + "5320": 1, + "5321": 1, + "5322": 1, + "5323": 1, + "5324": 1, + "5325": 1, + "5326": 1, + "5327": 1, + "5328": 1, + "5329": 1, + "533": 1, + "5330": 1, + "5331": 1, + "5332": 1, + "5333": 1, + "5334": 1, + "5335": 1, + "5336": 1, + "5337": 1, + "5338": 1, + "5339": 1, + "534": 1, + "5340": 1, + "5341": 1, + "5342": 1, + "5343": 1, + "5344": 1, + "5345": 1, + "5346": 1, + "5347": 1, + "5348": 1, + "5349": 1, + "535": 1, + "5350": 1, + "5351": 1, + "5352": 1, + "5353": 1, + "5354": 1, + "5355": 1, + "5356": 1, + "5357": 1, + "5358": 1, + "5359": 1, + "536": 1, + "5360": 1, + "5361": 1, + "5362": 1, + "5363": 1, + "5364": 1, + "5365": 1, + "5366": 1, + "5367": 1, + "5368": 1, + "5369": 1, + "537": 1, + "5370": 1, + "5371": 1, + "5372": 1, + "5373": 1, + "5374": 1, + "5375": 1, + "5376": 1, + "5377": 1, + "5378": 1, + "5379": 1, + "538": 1, + "5380": 1, + "5381": 1, + "5382": 1, + "5383": 1, + "5384": 1, + "5385": 1, + "5386": 1, + "5387": 1, + "5388": 1, + "5389": 1, + "539": 1, + "5390": 1, + "5391": 1, + "5392": 1, + "5393": 1, + "5394": 1, + "5395": 1, + "5396": 1, + "5397": 1, + "5398": 1, + "5399": 1, + "54": 1, + "540": 1, + "5400": 1, + "5401": 1, + "5402": 1, + "5403": 1, + "5404": 1, + "5405": 1, + "5406": 1, + "5407": 1, + "5408": 1, + "5409": 1, + "541": 1, + "5410": 1, + "5411": 1, + "5412": 1, + "5413": 1, + "5414": 1, + "5415": 1, + "5416": 1, + "5417": 1, + "5418": 1, + "5419": 1, + "542": 1, + "5420": 1, + "5421": 1, + "5422": 1, + "5423": 1, + "5424": 1, + "5425": 1, + "5426": 1, + "5427": 1, + "5428": 1, + "5429": 1, + "543": 1, + "5430": 1, + "5431": 1, + "5432": 1, + "5433": 1, + "5434": 1, + "5435": 1, + "5436": 1, + "5437": 1, + "5438": 1, + "5439": 1, + "544": 1, + "5440": 1, + "5441": 1, + "5442": 1, + "5443": 1, + "5444": 1, + "5445": 1, + "5446": 1, + "5447": 1, + "5448": 1, + "5449": 1, + "545": 1, + "5450": 1, + "5451": 1, + "5452": 1, + "5453": 1, + "5454": 1, + "5455": 1, + "5456": 1, + "5457": 1, + "5458": 1, + "5459": 1, + "546": 1, + "5460": 1, + "5461": 1, + "5462": 1, + "5463": 1, + "5464": 1, + "5465": 1, + "5466": 1, + "5467": 1, + "5468": 1, + "5469": 1, + "547": 1, + "5470": 1, + "5471": 1, + "5472": 1, + "5473": 1, + "5474": 1, + "5475": 1, + "5476": 1, + "5477": 1, + "5478": 1, + "5479": 1, + "548": 1, + "5480": 1, + "5481": 1, + "5482": 1, + "5483": 1, + "5484": 1, + "5485": 1, + "5486": 1, + "5487": 1, + "5488": 1, + "5489": 1, + "549": 1, + "5490": 1, + "5491": 1, + "5492": 1, + "5493": 1, + "5494": 1, + "5495": 1, + "5496": 1, + "5497": 1, + "5498": 1, + "5499": 1, + "55": 1, + "550": 1, + "5500": 1, + "5501": 1, + "5502": 1, + "5503": 1, + "5504": 1, + "5505": 1, + "5506": 1, + "5507": 1, + "5508": 1, + "5509": 1, + "551": 1, + "5510": 1, + "5511": 1, + "5512": 1, + "5513": 1, + "5514": 1, + "5515": 1, + "5516": 1, + "5517": 1, + "5518": 1, + "5519": 1, + "552": 1, + "5520": 1, + "5521": 1, + "5522": 1, + "5523": 1, + "5524": 1, + "5525": 1, + "5526": 1, + "5527": 1, + "5528": 1, + "5529": 1, + "553": 1, + "5530": 1, + "5531": 1, + "5532": 1, + "5533": 1, + "5534": 1, + "5535": 1, + "5536": 1, + "5537": 1, + "5538": 1, + "5539": 1, + "554": 1, + "5540": 1, + "5541": 1, + "5542": 1, + "5543": 1, + "5544": 1, + "5545": 1, + "5546": 1, + "5547": 1, + "5548": 1, + "5549": 1, + "555": 1, + "5550": 1, + "5551": 1, + "5552": 1, + "5553": 1, + "5554": 1, + "5555": 1, + "5556": 1, + "5557": 1, + "5558": 1, + "5559": 1, + "556": 1, + "5560": 1, + "5561": 1, + "5562": 1, + "5563": 1, + "5564": 1, + "5565": 1, + "5566": 1, + "5567": 1, + "5568": 1, + "5569": 1, + "557": 1, + "5570": 1, + "5571": 1, + "5572": 1, + "5573": 1, + "5574": 1, + "5575": 1, + "5576": 1, + "5577": 1, + "5578": 1, + "5579": 1, + "558": 1, + "5580": 1, + "5581": 1, + "5582": 1, + "5583": 1, + "5584": 1, + "5585": 1, + "5586": 1, + "5587": 1, + "5588": 1, + "5589": 1, + "559": 1, + "5590": 1, + "5591": 1, + "5592": 1, + "5593": 1, + "5594": 1, + "5595": 1, + "5596": 1, + "5597": 1, + "5598": 1, + "5599": 1, + "56": 1, + "560": 1, + "5600": 1, + "5601": 1, + "5602": 1, + "5603": 1, + "5604": 1, + "5605": 1, + "5606": 1, + "5607": 1, + "5608": 1, + "5609": 1, + "561": 1, + "5610": 1, + "5611": 1, + "5612": 1, + "5613": 1, + "5614": 1, + "5615": 1, + "5616": 1, + "5617": 1, + "5618": 1, + "5619": 1, + "562": 1, + "5620": 1, + "5621": 1, + "5622": 1, + "5623": 1, + "5624": 1, + "5625": 1, + "5626": 1, + "5627": 1, + "5628": 1, + "5629": 1, + "563": 1, + "5630": 1, + "5631": 1, + "5632": 1, + "5633": 1, + "5634": 1, + "5635": 1, + "5636": 1, + "5637": 1, + "5638": 1, + "5639": 1, + "564": 1, + "5640": 1, + "5641": 1, + "5642": 1, + "5643": 1, + "5644": 1, + "5645": 1, + "5646": 1, + "5647": 1, + "5648": 1, + "5649": 1, + "565": 1, + "5650": 1, + "5651": 1, + "5652": 1, + "5653": 1, + "5654": 1, + "5655": 1, + "5656": 1, + "5657": 1, + "5658": 1, + "5659": 1, + "566": 1, + "5660": 1, + "5661": 1, + "5662": 1, + "5663": 1, + "5664": 1, + "5665": 1, + "5666": 1, + "5667": 1, + "5668": 1, + "5669": 1, + "567": 1, + "5670": 1, + "5671": 1, + "5672": 1, + "5673": 1, + "5674": 1, + "5675": 1, + "5676": 1, + "5677": 1, + "5678": 1, + "5679": 1, + "568": 1, + "5680": 1, + "5681": 1, + "5682": 1, + "5683": 1, + "5684": 1, + "5685": 1, + "5686": 1, + "5687": 1, + "5688": 1, + "5689": 1, + "569": 1, + "5690": 1, + "5691": 1, + "5692": 1, + "5693": 1, + "5694": 1, + "5695": 1, + "5696": 1, + "5697": 1, + "5698": 1, + "5699": 1, + "57": 1, + "570": 1, + "5700": 1, + "5701": 1, + "5702": 1, + "5703": 1, + "5704": 1, + "5705": 1, + "5706": 1, + "5707": 1, + "5708": 1, + "5709": 1, + "571": 1, + "5710": 1, + "5711": 1, + "5712": 1, + "5713": 1, + "5714": 1, + "5715": 1, + "5716": 1, + "5717": 1, + "5718": 1, + "5719": 1, + "572": 1, + "5720": 1, + "5721": 1, + "5722": 1, + "5723": 1, + "5724": 1, + "5725": 1, + "5726": 1, + "5727": 1, + "5728": 1, + "5729": 1, + "573": 1, + "5730": 1, + "5731": 1, + "5732": 1, + "5733": 1, + "5734": 1, + "5735": 1, + "5736": 1, + "5737": 1, + "5738": 1, + "5739": 1, + "574": 1, + "5740": 1, + "5741": 1, + "5742": 1, + "5743": 1, + "5744": 1, + "5745": 1, + "5746": 1, + "5747": 1, + "5748": 1, + "5749": 1, + "575": 1, + "5750": 1, + "5751": 1, + "5752": 1, + "5753": 1, + "5754": 1, + "5755": 1, + "5756": 1, + "5757": 1, + "5758": 1, + "5759": 1, + "576": 1, + "5760": 1, + "5761": 1, + "5762": 1, + "5763": 1, + "5764": 1, + "5765": 1, + "5766": 1, + "5767": 1, + "5768": 1, + "5769": 1, + "577": 1, + "5770": 1, + "5771": 1, + "5772": 1, + "5773": 1, + "5774": 1, + "5775": 1, + "5776": 1, + "5777": 1, + "5778": 1, + "5779": 1, + "578": 1, + "5780": 1, + "5781": 1, + "5782": 1, + "5783": 1, + "5784": 1, + "5785": 1, + "5786": 1, + "5787": 1, + "5788": 1, + "5789": 1, + "579": 1, + "5790": 1, + "5791": 1, + "5792": 1, + "5793": 1, + "5794": 1, + "5795": 1, + "5796": 1, + "5797": 1, + "5798": 1, + "5799": 1, + "58": 1, + "580": 1, + "5800": 1, + "5801": 1, + "5802": 1, + "5803": 1, + "5804": 1, + "5805": 1, + "5806": 1, + "5807": 1, + "5808": 1, + "5809": 1, + "581": 1, + "5810": 1, + "5811": 1, + "5812": 1, + "5813": 1, + "5814": 1, + "5815": 1, + "5816": 1, + "5817": 1, + "5818": 1, + "5819": 1, + "582": 1, + "5820": 1, + "5821": 1, + "5822": 1, + "5823": 1, + "5824": 1, + "5825": 1, + "5826": 1, + "5827": 1, + "5828": 1, + "5829": 1, + "583": 1, + "5830": 1, + "5831": 1, + "5832": 1, + "5833": 1, + "5834": 1, + "5835": 1, + "5836": 1, + "5837": 1, + "5838": 1, + "5839": 1, + "584": 1, + "5840": 1, + "5841": 1, + "5842": 1, + "5843": 1, + "5844": 1, + "5845": 1, + "5846": 1, + "5847": 1, + "5848": 1, + "5849": 1, + "585": 1, + "5850": 1, + "5851": 1, + "5852": 1, + "5853": 1, + "5854": 1, + "5855": 1, + "5856": 1, + "5857": 1, + "5858": 1, + "5859": 1, + "586": 1, + "5860": 1, + "5861": 1, + "5862": 1, + "5863": 1, + "5864": 1, + "5865": 1, + "5866": 1, + "5867": 1, + "5868": 1, + "5869": 1, + "587": 1, + "5870": 1, + "5871": 1, + "5872": 1, + "5873": 1, + "5874": 1, + "5875": 1, + "5876": 1, + "5877": 1, + "5878": 1, + "5879": 1, + "588": 1, + "5880": 1, + "5881": 1, + "5882": 1, + "5883": 1, + "5884": 1, + "5885": 1, + "5886": 1, + "5887": 1, + "5888": 1, + "5889": 1, + "589": 1, + "5890": 1, + "5891": 1, + "5892": 1, + "5893": 1, + "5894": 1, + "5895": 1, + "5896": 1, + "5897": 1, + "5898": 1, + "5899": 1, + "59": 1, + "590": 1, + "5900": 1, + "5901": 1, + "5902": 1, + "5903": 1, + "5904": 1, + "5905": 1, + "5906": 1, + "5907": 1, + "5908": 1, + "5909": 1, + "591": 1, + "5910": 1, + "5911": 1, + "5912": 1, + "5913": 1, + "5914": 1, + "5915": 1, + "5916": 1, + "5917": 1, + "5918": 1, + "5919": 1, + "592": 1, + "5920": 1, + "5921": 1, + "5922": 1, + "5923": 1, + "5924": 1, + "5925": 1, + "5926": 1, + "5927": 1, + "5928": 1, + "5929": 1, + "593": 1, + "5930": 1, + "5931": 1, + "5932": 1, + "5933": 1, + "5934": 1, + "5935": 1, + "5936": 1, + "5937": 1, + "5938": 1, + "5939": 1, + "594": 1, + "5940": 1, + "5941": 1, + "5942": 1, + "5943": 1, + "5944": 1, + "5945": 1, + "5946": 1, + "5947": 1, + "5948": 1, + "5949": 1, + "595": 1, + "5950": 1, + "5951": 1, + "5952": 1, + "5953": 1, + "5954": 1, + "5955": 1, + "5956": 1, + "5957": 1, + "5958": 1, + "5959": 1, + "596": 1, + "5960": 1, + "5961": 1, + "5962": 1, + "5963": 1, + "5964": 1, + "5965": 1, + "5966": 1, + "5967": 1, + "5968": 1, + "5969": 1, + "597": 1, + "5970": 1, + "5971": 1, + "5972": 1, + "5973": 1, + "5974": 1, + "5975": 1, + "5976": 1, + "5977": 1, + "5978": 1, + "5979": 1, + "598": 1, + "5980": 1, + "5981": 1, + "5982": 1, + "5983": 1, + "5984": 1, + "5985": 1, + "5986": 1, + "5987": 1, + "5988": 1, + "5989": 1, + "599": 1, + "5990": 1, + "5991": 1, + "5992": 1, + "5993": 1, + "5994": 1, + "5995": 1, + "5996": 1, + "5997": 1, + "5998": 1, + "5999": 1, + "6": 1, + "60": 1, + "600": 1, + "6000": 1, + "6001": 1, + "6002": 1, + "6003": 1, + "6004": 1, + "6005": 1, + "6006": 1, + "6007": 1, + "6008": 1, + "6009": 1, + "601": 1, + "6010": 1, + "6011": 1, + "6012": 1, + "6013": 1, + "6014": 1, + "6015": 1, + "6016": 1, + "6017": 1, + "6018": 1, + "6019": 1, + "602": 1, + "6020": 1, + "6021": 1, + "6022": 1, + "6023": 1, + "6024": 1, + "6025": 1, + "6026": 1, + "6027": 1, + "6028": 1, + "6029": 1, + "603": 1, + "6030": 1, + "6031": 1, + "6032": 1, + "6033": 1, + "6034": 1, + "6035": 1, + "6036": 1, + "6037": 1, + "6038": 1, + "6039": 1, + "604": 1, + "6040": 1, + "6041": 1, + "6042": 1, + "6043": 1, + "6044": 1, + "6045": 1, + "6046": 1, + "6047": 1, + "6048": 1, + "6049": 1, + "605": 1, + "6050": 1, + "6051": 1, + "6052": 1, + "6053": 1, + "6054": 1, + "6055": 1, + "6056": 1, + "6057": 1, + "6058": 1, + "6059": 1, + "606": 1, + "6060": 1, + "6061": 1, + "6062": 1, + "6063": 1, + "6064": 1, + "6065": 1, + "6066": 1, + "6067": 1, + "6068": 1, + "6069": 1, + "607": 1, + "6070": 1, + "6071": 1, + "6072": 1, + "6073": 1, + "6074": 1, + "6075": 1, + "6076": 1, + "6077": 1, + "6078": 1, + "6079": 1, + "608": 1, + "6080": 1, + "6081": 1, + "6082": 1, + "6083": 1, + "6084": 1, + "6085": 1, + "6086": 1, + "6087": 1, + "6088": 1, + "6089": 1, + "609": 1, + "6090": 1, + "6091": 1, + "6092": 1, + "6093": 1, + "6094": 1, + "6095": 1, + "6096": 1, + "6097": 1, + "6098": 1, + "6099": 1, + "61": 1, + "610": 1, + "6100": 1, + "6101": 1, + "6102": 1, + "6103": 1, + "6104": 1, + "6105": 1, + "6106": 1, + "6107": 1, + "6108": 1, + "6109": 1, + "611": 1, + "6110": 1, + "6111": 1, + "6112": 1, + "6113": 1, + "6114": 1, + "6115": 1, + "6116": 1, + "6117": 1, + "6118": 1, + "6119": 1, + "612": 1, + "6120": 1, + "6121": 1, + "6122": 1, + "6123": 1, + "6124": 1, + "6125": 1, + "6126": 1, + "6127": 1, + "6128": 1, + "6129": 1, + "613": 1, + "6130": 1, + "6131": 1, + "6132": 1, + "6133": 1, + "6134": 1, + "6135": 1, + "6136": 1, + "6137": 1, + "6138": 1, + "6139": 1, + "614": 1, + "6140": 1, + "6141": 1, + "6142": 1, + "6143": 1, + "6144": 1, + "6145": 1, + "6146": 1, + "6147": 1, + "6148": 1, + "6149": 1, + "615": 1, + "6150": 1, + "6151": 1, + "6152": 1, + "6153": 1, + "6154": 1, + "6155": 1, + "6156": 1, + "6157": 1, + "6158": 1, + "6159": 1, + "616": 1, + "6160": 1, + "6161": 1, + "6162": 1, + "6163": 1, + "6164": 1, + "6165": 1, + "6166": 1, + "6167": 1, + "6168": 1, + "6169": 1, + "617": 1, + "6170": 1, + "6171": 1, + "6172": 1, + "6173": 1, + "6174": 1, + "6175": 1, + "6176": 1, + "6177": 1, + "6178": 1, + "6179": 1, + "618": 1, + "6180": 1, + "6181": 1, + "6182": 1, + "6183": 1, + "6184": 1, + "6185": 1, + "6186": 1, + "6187": 1, + "6188": 1, + "6189": 1, + "619": 1, + "6190": 1, + "6191": 1, + "6192": 1, + "6193": 1, + "6194": 1, + "6195": 1, + "6196": 1, + "6197": 1, + "6198": 1, + "6199": 1, + "62": 1, + "620": 1, + "6200": 1, + "6201": 1, + "6202": 1, + "6203": 1, + "6204": 1, + "6205": 1, + "6206": 1, + "6207": 1, + "6208": 1, + "6209": 1, + "621": 1, + "6210": 1, + "6211": 1, + "6212": 1, + "6213": 1, + "6214": 1, + "6215": 1, + "6216": 1, + "6217": 1, + "6218": 1, + "6219": 1, + "622": 1, + "6220": 1, + "6221": 1, + "6222": 1, + "6223": 1, + "6224": 1, + "6225": 1, + "6226": 1, + "6227": 1, + "6228": 1, + "6229": 1, + "623": 1, + "6230": 1, + "6231": 1, + "6232": 1, + "6233": 1, + "6234": 1, + "6235": 1, + "6236": 1, + "6237": 1, + "6238": 1, + "6239": 1, + "624": 1, + "6240": 1, + "6241": 1, + "6242": 1, + "6243": 1, + "6244": 1, + "6245": 1, + "6246": 1, + "6247": 1, + "6248": 1, + "6249": 1, + "625": 1, + "6250": 1, + "6251": 1, + "6252": 1, + "6253": 1, + "6254": 1, + "6255": 1, + "6256": 1, + "6257": 1, + "6258": 1, + "6259": 1, + "626": 1, + "6260": 1, + "6261": 1, + "6262": 1, + "6263": 1, + "6264": 1, + "6265": 1, + "6266": 1, + "6267": 1, + "6268": 1, + "6269": 1, + "627": 1, + "6270": 1, + "6271": 1, + "6272": 1, + "6273": 1, + "6274": 1, + "6275": 1, + "6276": 1, + "6277": 1, + "6278": 1, + "6279": 1, + "628": 1, + "6280": 1, + "6281": 1, + "6282": 1, + "6283": 1, + "6284": 1, + "6285": 1, + "6286": 1, + "6287": 1, + "6288": 1, + "6289": 1, + "629": 1, + "6290": 1, + "6291": 1, + "6292": 1, + "6293": 1, + "6294": 1, + "6295": 1, + "6296": 1, + "6297": 1, + "6298": 1, + "6299": 1, + "63": 1, + "630": 1, + "6300": 1, + "6301": 1, + "6302": 1, + "6303": 1, + "6304": 1, + "6305": 1, + "6306": 1, + "6307": 1, + "6308": 1, + "6309": 1, + "631": 1, + "6310": 1, + "6311": 1, + "6312": 1, + "6313": 1, + "6314": 1, + "6315": 1, + "6316": 1, + "6317": 1, + "6318": 1, + "6319": 1, + "632": 1, + "6320": 1, + "6321": 1, + "6322": 1, + "6323": 1, + "6324": 1, + "6325": 1, + "6326": 1, + "6327": 1, + "6328": 1, + "6329": 1, + "633": 1, + "6330": 1, + "6331": 1, + "6332": 1, + "6333": 1, + "6334": 1, + "6335": 1, + "6336": 1, + "6337": 1, + "6338": 1, + "6339": 1, + "634": 1, + "6340": 1, + "6341": 1, + "6342": 1, + "6343": 1, + "6344": 1, + "6345": 1, + "6346": 1, + "6347": 1, + "6348": 1, + "6349": 1, + "635": 1, + "6350": 1, + "6351": 1, + "6352": 1, + "6353": 1, + "6354": 1, + "6355": 1, + "6356": 1, + "6357": 1, + "6358": 1, + "6359": 1, + "636": 1, + "6360": 1, + "6361": 1, + "6362": 1, + "6363": 1, + "6364": 1, + "6365": 1, + "6366": 1, + "6367": 1, + "6368": 1, + "6369": 1, + "637": 1, + "6370": 1, + "6371": 1, + "6372": 1, + "6373": 1, + "6374": 1, + "6375": 1, + "6376": 1, + "6377": 1, + "6378": 1, + "6379": 1, + "638": 1, + "6380": 1, + "6381": 1, + "6382": 1, + "6383": 1, + "6384": 1, + "6385": 1, + "6386": 1, + "6387": 1, + "6388": 1, + "6389": 1, + "639": 1, + "6390": 1, + "6391": 1, + "6392": 1, + "6393": 1, + "6394": 1, + "6395": 1, + "6396": 1, + "6397": 1, + "6398": 1, + "6399": 1, + "64": 1, + "640": 1, + "6400": 1, + "6401": 1, + "6402": 1, + "6403": 1, + "6404": 1, + "6405": 1, + "6406": 1, + "6407": 1, + "6408": 1, + "6409": 1, + "641": 1, + "6410": 1, + "6411": 1, + "6412": 1, + "6413": 1, + "6414": 1, + "6415": 1, + "6416": 1, + "6417": 1, + "6418": 1, + "6419": 1, + "642": 1, + "6420": 1, + "6421": 1, + "6422": 1, + "6423": 1, + "6424": 1, + "6425": 1, + "6426": 1, + "6427": 1, + "6428": 1, + "6429": 1, + "643": 1, + "6430": 1, + "6431": 1, + "6432": 1, + "6433": 1, + "6434": 1, + "6435": 1, + "6436": 1, + "6437": 1, + "6438": 1, + "6439": 1, + "644": 1, + "6440": 1, + "6441": 1, + "6442": 1, + "6443": 1, + "6444": 1, + "6445": 1, + "6446": 1, + "6447": 1, + "6448": 1, + "6449": 1, + "645": 1, + "6450": 1, + "6451": 1, + "6452": 1, + "6453": 1, + "6454": 1, + "6455": 1, + "6456": 1, + "6457": 1, + "6458": 1, + "6459": 1, + "646": 1, + "6460": 1, + "6461": 1, + "6462": 1, + "6463": 1, + "6464": 1, + "6465": 1, + "6466": 1, + "6467": 1, + "6468": 1, + "6469": 1, + "647": 1, + "6470": 1, + "6471": 1, + "6472": 1, + "6473": 1, + "6474": 1, + "6475": 1, + "6476": 1, + "6477": 1, + "6478": 1, + "6479": 1, + "648": 1, + "6480": 1, + "6481": 1, + "6482": 1, + "6483": 1, + "6484": 1, + "6485": 1, + "6486": 1, + "6487": 1, + "6488": 1, + "6489": 1, + "649": 1, + "6490": 1, + "6491": 1, + "6492": 1, + "6493": 1, + "6494": 1, + "6495": 1, + "6496": 1, + "6497": 1, + "6498": 1, + "6499": 1, + "65": 1, + "650": 1, + "6500": 1, + "6501": 1, + "6502": 1, + "6503": 1, + "6504": 1, + "6505": 1, + "6506": 1, + "6507": 1, + "6508": 1, + "6509": 1, + "651": 1, + "6510": 1, + "6511": 1, + "6512": 1, + "6513": 1, + "6514": 1, + "6515": 1, + "6516": 1, + "6517": 1, + "6518": 1, + "6519": 1, + "652": 1, + "6520": 1, + "6521": 1, + "6522": 1, + "6523": 1, + "6524": 1, + "6525": 1, + "6526": 1, + "6527": 1, + "6528": 1, + "6529": 1, + "653": 1, + "6530": 1, + "6531": 1, + "6532": 1, + "6533": 1, + "6534": 1, + "6535": 1, + "6536": 1, + "6537": 1, + "6538": 1, + "6539": 1, + "654": 1, + "6540": 1, + "6541": 1, + "6542": 1, + "6543": 1, + "6544": 1, + "6545": 1, + "6546": 1, + "6547": 1, + "6548": 1, + "6549": 1, + "655": 1, + "6550": 1, + "6551": 1, + "6552": 1, + "6553": 1, + "6554": 1, + "6555": 1, + "6556": 1, + "6557": 1, + "6558": 1, + "6559": 1, + "656": 1, + "6560": 1, + "6561": 1, + "6562": 1, + "6563": 1, + "6564": 1, + "6565": 1, + "6566": 1, + "6567": 1, + "6568": 1, + "6569": 1, + "657": 1, + "6570": 1, + "6571": 1, + "6572": 1, + "6573": 1, + "6574": 1, + "6575": 1, + "6576": 1, + "6577": 1, + "6578": 1, + "6579": 1, + "658": 1, + "6580": 1, + "6581": 1, + "6582": 1, + "6583": 1, + "6584": 1, + "6585": 1, + "6586": 1, + "6587": 1, + "6588": 1, + "6589": 1, + "659": 1, + "6590": 1, + "6591": 1, + "6592": 1, + "6593": 1, + "6594": 1, + "6595": 1, + "6596": 1, + "6597": 1, + "6598": 1, + "6599": 1, + "66": 1, + "660": 1, + "6600": 1, + "6601": 1, + "6602": 1, + "6603": 1, + "6604": 1, + "6605": 1, + "6606": 1, + "6607": 1, + "6608": 1, + "6609": 1, + "661": 1, + "6610": 1, + "6611": 1, + "6612": 1, + "6613": 1, + "6614": 1, + "6615": 1, + "6616": 1, + "6617": 1, + "6618": 1, + "6619": 1, + "662": 1, + "6620": 1, + "6621": 1, + "6622": 1, + "6623": 1, + "6624": 1, + "6625": 1, + "6626": 1, + "6627": 1, + "6628": 1, + "6629": 1, + "663": 1, + "6630": 1, + "6631": 1, + "6632": 1, + "6633": 1, + "6634": 1, + "6635": 1, + "6636": 1, + "6637": 1, + "6638": 1, + "6639": 1, + "664": 1, + "6640": 1, + "6641": 1, + "6642": 1, + "6643": 1, + "6644": 1, + "6645": 1, + "6646": 1, + "6647": 1, + "6648": 1, + "6649": 1, + "665": 1, + "6650": 1, + "6651": 1, + "6652": 1, + "6653": 1, + "6654": 1, + "6655": 1, + "6656": 1, + "6657": 1, + "6658": 1, + "6659": 1, + "666": 1, + "6660": 1, + "6661": 1, + "6662": 1, + "6663": 1, + "6664": 1, + "6665": 1, + "6666": 1, + "6667": 1, + "6668": 1, + "6669": 1, + "667": 1, + "6670": 1, + "6671": 1, + "6672": 1, + "6673": 1, + "6674": 1, + "6675": 1, + "6676": 1, + "6677": 1, + "6678": 1, + "6679": 1, + "668": 1, + "6680": 1, + "6681": 1, + "6682": 1, + "6683": 1, + "6684": 1, + "6685": 1, + "6686": 1, + "6687": 1, + "6688": 1, + "6689": 1, + "669": 1, + "6690": 1, + "6691": 1, + "6692": 1, + "6693": 1, + "6694": 1, + "6695": 1, + "6696": 1, + "6697": 1, + "6698": 1, + "6699": 1, + "67": 1, + "670": 1, + "6700": 1, + "6701": 1, + "6702": 1, + "6703": 1, + "6704": 1, + "6705": 1, + "6706": 1, + "6707": 1, + "6708": 1, + "6709": 1, + "671": 1, + "6710": 1, + "6711": 1, + "6712": 1, + "6713": 1, + "6714": 1, + "6715": 1, + "6716": 1, + "6717": 1, + "6718": 1, + "6719": 1, + "672": 1, + "6720": 1, + "6721": 1, + "6722": 1, + "6723": 1, + "6724": 1, + "6725": 1, + "6726": 1, + "6727": 1, + "6728": 1, + "6729": 1, + "673": 1, + "6730": 1, + "6731": 1, + "6732": 1, + "6733": 1, + "6734": 1, + "6735": 1, + "6736": 1, + "6737": 1, + "6738": 1, + "6739": 1, + "674": 1, + "6740": 1, + "6741": 1, + "6742": 1, + "6743": 1, + "6744": 1, + "6745": 1, + "6746": 1, + "6747": 1, + "6748": 1, + "6749": 1, + "675": 1, + "6750": 1, + "6751": 1, + "6752": 1, + "6753": 1, + "6754": 1, + "6755": 1, + "6756": 1, + "6757": 1, + "6758": 1, + "6759": 1, + "676": 1, + "6760": 1, + "6761": 1, + "6762": 1, + "6763": 1, + "6764": 1, + "6765": 1, + "6766": 1, + "6767": 1, + "6768": 1, + "6769": 1, + "677": 1, + "6770": 1, + "6771": 1, + "6772": 1, + "6773": 1, + "6774": 1, + "6775": 1, + "6776": 1, + "6777": 1, + "6778": 1, + "6779": 1, + "678": 1, + "6780": 1, + "6781": 1, + "6782": 1, + "6783": 1, + "6784": 1, + "6785": 1, + "6786": 1, + "6787": 1, + "6788": 1, + "6789": 1, + "679": 1, + "6790": 1, + "6791": 1, + "6792": 1, + "6793": 1, + "6794": 1, + "6795": 1, + "6796": 1, + "6797": 1, + "6798": 1, + "6799": 1, + "68": 1, + "680": 1, + "6800": 1, + "6801": 1, + "6802": 1, + "6803": 1, + "6804": 1, + "6805": 1, + "6806": 1, + "6807": 1, + "6808": 1, + "6809": 1, + "681": 1, + "6810": 1, + "6811": 1, + "6812": 1, + "6813": 1, + "6814": 1, + "6815": 1, + "6816": 1, + "6817": 1, + "6818": 1, + "6819": 1, + "682": 1, + "6820": 1, + "6821": 1, + "6822": 1, + "6823": 1, + "6824": 1, + "6825": 1, + "6826": 1, + "6827": 1, + "6828": 1, + "6829": 1, + "683": 1, + "6830": 1, + "6831": 1, + "6832": 1, + "6833": 1, + "6834": 1, + "6835": 1, + "6836": 1, + "6837": 1, + "6838": 1, + "6839": 1, + "684": 1, + "6840": 1, + "6841": 1, + "6842": 1, + "6843": 1, + "6844": 1, + "6845": 1, + "6846": 1, + "6847": 1, + "6848": 1, + "6849": 1, + "685": 1, + "6850": 1, + "6851": 1, + "6852": 1, + "6853": 1, + "6854": 1, + "6855": 1, + "6856": 1, + "6857": 1, + "6858": 1, + "6859": 1, + "686": 1, + "6860": 1, + "6861": 1, + "6862": 1, + "6863": 1, + "6864": 1, + "6865": 1, + "6866": 1, + "6867": 1, + "6868": 1, + "6869": 1, + "687": 1, + "6870": 1, + "6871": 1, + "6872": 1, + "6873": 1, + "6874": 1, + "6875": 1, + "6876": 1, + "6877": 1, + "6878": 1, + "6879": 1, + "688": 1, + "6880": 1, + "6881": 1, + "6882": 1, + "6883": 1, + "6884": 1, + "6885": 1, + "6886": 1, + "6887": 1, + "6888": 1, + "6889": 1, + "689": 1, + "6890": 1, + "6891": 1, + "6892": 1, + "6893": 1, + "6894": 1, + "6895": 1, + "6896": 1, + "6897": 1, + "6898": 1, + "6899": 1, + "69": 1, + "690": 1, + "6900": 1, + "6901": 1, + "6902": 1, + "6903": 1, + "6904": 1, + "6905": 1, + "6906": 1, + "6907": 1, + "6908": 1, + "6909": 1, + "691": 1, + "6910": 1, + "6911": 1, + "6912": 1, + "6913": 1, + "6914": 1, + "6915": 1, + "6916": 1, + "6917": 1, + "6918": 1, + "6919": 1, + "692": 1, + "6920": 1, + "6921": 1, + "6922": 1, + "6923": 1, + "6924": 1, + "6925": 1, + "6926": 1, + "6927": 1, + "6928": 1, + "6929": 1, + "693": 1, + "6930": 1, + "6931": 1, + "6932": 1, + "6933": 1, + "6934": 1, + "6935": 1, + "6936": 1, + "6937": 1, + "6938": 1, + "6939": 1, + "694": 1, + "6940": 1, + "6941": 1, + "6942": 1, + "6943": 1, + "6944": 1, + "6945": 1, + "6946": 1, + "6947": 1, + "6948": 1, + "6949": 1, + "695": 1, + "6950": 1, + "6951": 1, + "6952": 1, + "6953": 1, + "6954": 1, + "6955": 1, + "6956": 1, + "6957": 1, + "6958": 1, + "6959": 1, + "696": 1, + "6960": 1, + "6961": 1, + "6962": 1, + "6963": 1, + "6964": 1, + "6965": 1, + "6966": 1, + "6967": 1, + "6968": 1, + "6969": 1, + "697": 1, + "6970": 1, + "6971": 1, + "6972": 1, + "6973": 1, + "6974": 1, + "6975": 1, + "6976": 1, + "6977": 1, + "6978": 1, + "6979": 1, + "698": 1, + "6980": 1, + "6981": 1, + "6982": 1, + "6983": 1, + "6984": 1, + "6985": 1, + "6986": 1, + "6987": 1, + "6988": 1, + "6989": 1, + "699": 1, + "6990": 1, + "6991": 1, + "6992": 1, + "6993": 1, + "6994": 1, + "6995": 1, + "6996": 1, + "6997": 1, + "6998": 1, + "6999": 1, + "7": 1, + "70": 1, + "700": 1, + "7000": 1, + "7001": 1, + "7002": 1, + "7003": 1, + "7004": 1, + "7005": 1, + "7006": 1, + "7007": 1, + "7008": 1, + "7009": 1, + "701": 1, + "7010": 1, + "7011": 1, + "7012": 1, + "7013": 1, + "7014": 1, + "7015": 1, + "7016": 1, + "7017": 1, + "7018": 1, + "7019": 1, + "702": 1, + "7020": 1, + "7021": 1, + "7022": 1, + "7023": 1, + "7024": 1, + "7025": 1, + "7026": 1, + "7027": 1, + "7028": 1, + "7029": 1, + "703": 1, + "7030": 1, + "7031": 1, + "7032": 1, + "7033": 1, + "7034": 1, + "7035": 1, + "7036": 1, + "7037": 1, + "7038": 1, + "7039": 1, + "704": 1, + "7040": 1, + "7041": 1, + "7042": 1, + "7043": 1, + "7044": 1, + "7045": 1, + "7046": 1, + "7047": 1, + "7048": 1, + "7049": 1, + "705": 1, + "7050": 1, + "7051": 1, + "7052": 1, + "7053": 1, + "7054": 1, + "7055": 1, + "7056": 1, + "7057": 1, + "7058": 1, + "7059": 1, + "706": 1, + "7060": 1, + "7061": 1, + "7062": 1, + "7063": 1, + "7064": 1, + "7065": 1, + "7066": 1, + "7067": 1, + "7068": 1, + "7069": 1, + "707": 1, + "7070": 1, + "7071": 1, + "7072": 1, + "7073": 1, + "7074": 1, + "7075": 1, + "7076": 1, + "7077": 1, + "7078": 1, + "7079": 1, + "708": 1, + "7080": 1, + "7081": 1, + "7082": 1, + "7083": 1, + "7084": 1, + "7085": 1, + "7086": 1, + "7087": 1, + "7088": 1, + "7089": 1, + "709": 1, + "7090": 1, + "7091": 1, + "7092": 1, + "7093": 1, + "7094": 1, + "7095": 1, + "7096": 1, + "7097": 1, + "7098": 1, + "7099": 1, + "71": 1, + "710": 1, + "7100": 1, + "7101": 1, + "7102": 1, + "7103": 1, + "7104": 1, + "7105": 1, + "7106": 1, + "7107": 1, + "7108": 1, + "7109": 1, + "711": 1, + "7110": 1, + "7111": 1, + "7112": 1, + "7113": 1, + "7114": 1, + "7115": 1, + "7116": 1, + "7117": 1, + "7118": 1, + "7119": 1, + "712": 1, + "7120": 1, + "7121": 1, + "7122": 1, + "7123": 1, + "7124": 1, + "7125": 1, + "7126": 1, + "7127": 1, + "7128": 1, + "7129": 1, + "713": 1, + "7130": 1, + "7131": 1, + "7132": 1, + "7133": 1, + "7134": 1, + "7135": 1, + "7136": 1, + "7137": 1, + "7138": 1, + "7139": 1, + "714": 1, + "7140": 1, + "7141": 1, + "7142": 1, + "7143": 1, + "7144": 1, + "7145": 1, + "7146": 1, + "7147": 1, + "7148": 1, + "7149": 1, + "715": 1, + "7150": 1, + "7151": 1, + "7152": 1, + "7153": 1, + "7154": 1, + "7155": 1, + "7156": 1, + "7157": 1, + "7158": 1, + "7159": 1, + "716": 1, + "7160": 1, + "7161": 1, + "7162": 1, + "7163": 1, + "7164": 1, + "7165": 1, + "7166": 1, + "7167": 1, + "7168": 1, + "7169": 1, + "717": 1, + "7170": 1, + "7171": 1, + "7172": 1, + "7173": 1, + "7174": 1, + "7175": 1, + "7176": 1, + "7177": 1, + "7178": 1, + "7179": 1, + "718": 1, + "7180": 1, + "7181": 1, + "7182": 1, + "7183": 1, + "7184": 1, + "7185": 1, + "7186": 1, + "7187": 1, + "7188": 1, + "7189": 1, + "719": 1, + "7190": 1, + "7191": 1, + "7192": 1, + "7193": 1, + "7194": 1, + "7195": 1, + "7196": 1, + "7197": 1, + "7198": 1, + "7199": 1, + "72": 1, + "720": 1, + "7200": 1, + "7201": 1, + "7202": 1, + "7203": 1, + "7204": 1, + "7205": 1, + "7206": 1, + "7207": 1, + "7208": 1, + "7209": 1, + "721": 1, + "7210": 1, + "7211": 1, + "7212": 1, + "7213": 1, + "7214": 1, + "7215": 1, + "7216": 1, + "7217": 1, + "7218": 1, + "7219": 1, + "722": 1, + "7220": 1, + "7221": 1, + "7222": 1, + "7223": 1, + "7224": 1, + "7225": 1, + "7226": 1, + "7227": 1, + "7228": 1, + "7229": 1, + "723": 1, + "7230": 1, + "7231": 1, + "7232": 1, + "7233": 1, + "7234": 1, + "7235": 1, + "7236": 1, + "7237": 1, + "7238": 1, + "7239": 1, + "724": 1, + "7240": 1, + "7241": 1, + "7242": 1, + "7243": 1, + "7244": 1, + "7245": 1, + "7246": 1, + "7247": 1, + "7248": 1, + "7249": 1, + "725": 1, + "7250": 1, + "7251": 1, + "7252": 1, + "7253": 1, + "7254": 1, + "7255": 1, + "7256": 1, + "7257": 1, + "7258": 1, + "7259": 1, + "726": 1, + "7260": 1, + "7261": 1, + "7262": 1, + "7263": 1, + "7264": 1, + "7265": 1, + "7266": 1, + "7267": 1, + "7268": 1, + "7269": 1, + "727": 1, + "7270": 1, + "7271": 1, + "7272": 1, + "7273": 1, + "7274": 1, + "7275": 1, + "7276": 1, + "7277": 1, + "7278": 1, + "7279": 1, + "728": 1, + "7280": 1, + "7281": 1, + "7282": 1, + "7283": 1, + "7284": 1, + "7285": 1, + "7286": 1, + "7287": 1, + "7288": 1, + "7289": 1, + "729": 1, + "7290": 1, + "7291": 1, + "7292": 1, + "7293": 1, + "7294": 1, + "7295": 1, + "7296": 1, + "7297": 1, + "7298": 1, + "7299": 1, + "73": 1, + "730": 1, + "7300": 1, + "7301": 1, + "7302": 1, + "7303": 1, + "7304": 1, + "7305": 1, + "7306": 1, + "7307": 1, + "7308": 1, + "7309": 1, + "731": 1, + "7310": 1, + "7311": 1, + "7312": 1, + "7313": 1, + "7314": 1, + "7315": 1, + "7316": 1, + "7317": 1, + "7318": 1, + "7319": 1, + "732": 1, + "7320": 1, + "7321": 1, + "7322": 1, + "7323": 1, + "7324": 1, + "7325": 1, + "7326": 1, + "7327": 1, + "7328": 1, + "7329": 1, + "733": 1, + "7330": 1, + "7331": 1, + "7332": 1, + "7333": 1, + "7334": 1, + "7335": 1, + "7336": 1, + "7337": 1, + "7338": 1, + "7339": 1, + "734": 1, + "7340": 1, + "7341": 1, + "7342": 1, + "7343": 1, + "7344": 1, + "7345": 1, + "7346": 1, + "7347": 1, + "7348": 1, + "7349": 1, + "735": 1, + "7350": 1, + "7351": 1, + "7352": 1, + "7353": 1, + "7354": 1, + "7355": 1, + "7356": 1, + "7357": 1, + "7358": 1, + "7359": 1, + "736": 1, + "7360": 1, + "7361": 1, + "7362": 1, + "7363": 1, + "7364": 1, + "7365": 1, + "7366": 1, + "7367": 1, + "7368": 1, + "7369": 1, + "737": 1, + "7370": 1, + "7371": 1, + "7372": 1, + "7373": 1, + "7374": 1, + "7375": 1, + "7376": 1, + "7377": 1, + "7378": 1, + "7379": 1, + "738": 1, + "7380": 1, + "7381": 1, + "7382": 1, + "7383": 1, + "7384": 1, + "7385": 1, + "7386": 1, + "7387": 1, + "7388": 1, + "7389": 1, + "739": 1, + "7390": 1, + "7391": 1, + "7392": 1, + "7393": 1, + "7394": 1, + "7395": 1, + "7396": 1, + "7397": 1, + "7398": 1, + "7399": 1, + "74": 1, + "740": 1, + "7400": 1, + "7401": 1, + "7402": 1, + "7403": 1, + "7404": 1, + "7405": 1, + "7406": 1, + "7407": 1, + "7408": 1, + "7409": 1, + "741": 1, + "7410": 1, + "7411": 1, + "7412": 1, + "7413": 1, + "7414": 1, + "7415": 1, + "7416": 1, + "7417": 1, + "7418": 1, + "7419": 1, + "742": 1, + "7420": 1, + "7421": 1, + "7422": 1, + "7423": 1, + "7424": 1, + "7425": 1, + "7426": 1, + "7427": 1, + "7428": 1, + "7429": 1, + "743": 1, + "7430": 1, + "7431": 1, + "7432": 1, + "7433": 1, + "7434": 1, + "7435": 1, + "7436": 1, + "7437": 1, + "7438": 1, + "7439": 1, + "744": 1, + "7440": 1, + "7441": 1, + "7442": 1, + "7443": 1, + "7444": 1, + "7445": 1, + "7446": 1, + "7447": 1, + "7448": 1, + "7449": 1, + "745": 1, + "7450": 1, + "7451": 1, + "7452": 1, + "7453": 1, + "7454": 1, + "7455": 1, + "7456": 1, + "7457": 1, + "7458": 1, + "7459": 1, + "746": 1, + "7460": 1, + "7461": 1, + "7462": 1, + "7463": 1, + "7464": 1, + "7465": 1, + "7466": 1, + "7467": 1, + "7468": 1, + "7469": 1, + "747": 1, + "7470": 1, + "7471": 1, + "7472": 1, + "7473": 1, + "7474": 1, + "7475": 1, + "7476": 1, + "7477": 1, + "7478": 1, + "7479": 1, + "748": 1, + "7480": 1, + "7481": 1, + "7482": 1, + "7483": 1, + "7484": 1, + "7485": 1, + "7486": 1, + "7487": 1, + "7488": 1, + "7489": 1, + "749": 1, + "7490": 1, + "7491": 1, + "7492": 1, + "7493": 1, + "7494": 1, + "7495": 1, + "7496": 1, + "7497": 1, + "7498": 1, + "7499": 1, + "75": 1, + "750": 1, + "7500": 1, + "7501": 1, + "7502": 1, + "7503": 1, + "7504": 1, + "7505": 1, + "7506": 1, + "7507": 1, + "7508": 1, + "7509": 1, + "751": 1, + "7510": 1, + "7511": 1, + "7512": 1, + "7513": 1, + "7514": 1, + "7515": 1, + "7516": 1, + "7517": 1, + "7518": 1, + "7519": 1, + "752": 1, + "7520": 1, + "7521": 1, + "7522": 1, + "7523": 1, + "7524": 1, + "7525": 1, + "7526": 1, + "7527": 1, + "7528": 1, + "7529": 1, + "753": 1, + "7530": 1, + "7531": 1, + "7532": 1, + "7533": 1, + "7534": 1, + "7535": 1, + "7536": 1, + "7537": 1, + "7538": 1, + "7539": 1, + "754": 1, + "7540": 1, + "7541": 1, + "7542": 1, + "7543": 1, + "7544": 1, + "7545": 1, + "7546": 1, + "7547": 1, + "7548": 1, + "7549": 1, + "755": 1, + "7550": 1, + "7551": 1, + "7552": 1, + "7553": 1, + "7554": 1, + "7555": 1, + "7556": 1, + "7557": 1, + "7558": 1, + "7559": 1, + "756": 1, + "7560": 1, + "7561": 1, + "7562": 1, + "7563": 1, + "7564": 1, + "7565": 1, + "7566": 1, + "7567": 1, + "7568": 1, + "7569": 1, + "757": 1, + "7570": 1, + "7571": 1, + "7572": 1, + "7573": 1, + "7574": 1, + "7575": 1, + "7576": 1, + "7577": 1, + "7578": 1, + "7579": 1, + "758": 1, + "7580": 1, + "7581": 1, + "7582": 1, + "7583": 1, + "7584": 1, + "7585": 1, + "7586": 1, + "7587": 1, + "7588": 1, + "7589": 1, + "759": 1, + "7590": 1, + "7591": 1, + "7592": 1, + "7593": 1, + "7594": 1, + "7595": 1, + "7596": 1, + "7597": 1, + "7598": 1, + "7599": 1, + "76": 1, + "760": 1, + "7600": 1, + "7601": 1, + "7602": 1, + "7603": 1, + "7604": 1, + "7605": 1, + "7606": 1, + "7607": 1, + "7608": 1, + "7609": 1, + "761": 1, + "7610": 1, + "7611": 1, + "7612": 1, + "7613": 1, + "7614": 1, + "7615": 1, + "7616": 1, + "7617": 1, + "7618": 1, + "7619": 1, + "762": 1, + "7620": 1, + "7621": 1, + "7622": 1, + "7623": 1, + "7624": 1, + "7625": 1, + "7626": 1, + "7627": 1, + "7628": 1, + "7629": 1, + "763": 1, + "7630": 1, + "7631": 1, + "7632": 1, + "7633": 1, + "7634": 1, + "7635": 1, + "7636": 1, + "7637": 1, + "7638": 1, + "7639": 1, + "764": 1, + "7640": 1, + "7641": 1, + "7642": 1, + "7643": 1, + "7644": 1, + "7645": 1, + "7646": 1, + "7647": 1, + "7648": 1, + "7649": 1, + "765": 1, + "7650": 1, + "7651": 1, + "7652": 1, + "7653": 1, + "7654": 1, + "7655": 1, + "7656": 1, + "7657": 1, + "7658": 1, + "7659": 1, + "766": 1, + "7660": 1, + "7661": 1, + "7662": 1, + "7663": 1, + "7664": 1, + "7665": 1, + "7666": 1, + "7667": 1, + "7668": 1, + "7669": 1, + "767": 1, + "7670": 1, + "7671": 1, + "7672": 1, + "7673": 1, + "7674": 1, + "7675": 1, + "7676": 1, + "7677": 1, + "7678": 1, + "7679": 1, + "768": 1, + "7680": 1, + "7681": 1, + "7682": 1, + "7683": 1, + "7684": 1, + "7685": 1, + "7686": 1, + "7687": 1, + "7688": 1, + "7689": 1, + "769": 1, + "7690": 1, + "7691": 1, + "7692": 1, + "7693": 1, + "7694": 1, + "7695": 1, + "7696": 1, + "7697": 1, + "7698": 1, + "7699": 1, + "77": 1, + "770": 1, + "7700": 1, + "7701": 1, + "7702": 1, + "7703": 1, + "7704": 1, + "7705": 1, + "7706": 1, + "7707": 1, + "7708": 1, + "7709": 1, + "771": 1, + "7710": 1, + "7711": 1, + "7712": 1, + "7713": 1, + "7714": 1, + "7715": 1, + "7716": 1, + "7717": 1, + "7718": 1, + "7719": 1, + "772": 1, + "7720": 1, + "7721": 1, + "7722": 1, + "7723": 1, + "7724": 1, + "7725": 1, + "7726": 1, + "7727": 1, + "7728": 1, + "7729": 1, + "773": 1, + "7730": 1, + "7731": 1, + "7732": 1, + "7733": 1, + "7734": 1, + "7735": 1, + "7736": 1, + "7737": 1, + "7738": 1, + "7739": 1, + "774": 1, + "7740": 1, + "7741": 1, + "7742": 1, + "7743": 1, + "7744": 1, + "7745": 1, + "7746": 1, + "7747": 1, + "7748": 1, + "7749": 1, + "775": 1, + "7750": 1, + "7751": 1, + "7752": 1, + "7753": 1, + "7754": 1, + "7755": 1, + "7756": 1, + "7757": 1, + "7758": 1, + "7759": 1, + "776": 1, + "7760": 1, + "7761": 1, + "7762": 1, + "7763": 1, + "7764": 1, + "7765": 1, + "7766": 1, + "7767": 1, + "7768": 1, + "7769": 1, + "777": 1, + "7770": 1, + "7771": 1, + "7772": 1, + "7773": 1, + "7774": 1, + "7775": 1, + "7776": 1, + "7777": 1, + "7778": 1, + "7779": 1, + "778": 1, + "7780": 1, + "7781": 1, + "7782": 1, + "7783": 1, + "7784": 1, + "7785": 1, + "7786": 1, + "7787": 1, + "7788": 1, + "7789": 1, + "779": 1, + "7790": 1, + "7791": 1, + "7792": 1, + "7793": 1, + "7794": 1, + "7795": 1, + "7796": 1, + "7797": 1, + "7798": 1, + "7799": 1, + "78": 1, + "780": 1, + "7800": 1, + "7801": 1, + "7802": 1, + "7803": 1, + "7804": 1, + "7805": 1, + "7806": 1, + "7807": 1, + "7808": 1, + "7809": 1, + "781": 1, + "7810": 1, + "7811": 1, + "7812": 1, + "7813": 1, + "7814": 1, + "7815": 1, + "7816": 1, + "7817": 1, + "7818": 1, + "7819": 1, + "782": 1, + "7820": 1, + "7821": 1, + "7822": 1, + "7823": 1, + "7824": 1, + "7825": 1, + "7826": 1, + "7827": 1, + "7828": 1, + "7829": 1, + "783": 1, + "7830": 1, + "7831": 1, + "7832": 1, + "7833": 1, + "7834": 1, + "7835": 1, + "7836": 1, + "7837": 1, + "7838": 1, + "7839": 1, + "784": 1, + "7840": 1, + "7841": 1, + "7842": 1, + "7843": 1, + "7844": 1, + "7845": 1, + "7846": 1, + "7847": 1, + "7848": 1, + "7849": 1, + "785": 1, + "7850": 1, + "7851": 1, + "7852": 1, + "7853": 1, + "7854": 1, + "7855": 1, + "7856": 1, + "7857": 1, + "7858": 1, + "7859": 1, + "786": 1, + "7860": 1, + "7861": 1, + "7862": 1, + "7863": 1, + "7864": 1, + "7865": 1, + "7866": 1, + "7867": 1, + "7868": 1, + "7869": 1, + "787": 1, + "7870": 1, + "7871": 1, + "7872": 1, + "7873": 1, + "7874": 1, + "7875": 1, + "7876": 1, + "7877": 1, + "7878": 1, + "7879": 1, + "788": 1, + "7880": 1, + "7881": 1, + "7882": 1, + "7883": 1, + "7884": 1, + "7885": 1, + "7886": 1, + "7887": 1, + "7888": 1, + "7889": 1, + "789": 1, + "7890": 1, + "7891": 1, + "7892": 1, + "7893": 1, + "7894": 1, + "7895": 1, + "7896": 1, + "7897": 1, + "7898": 1, + "7899": 1, + "79": 1, + "790": 1, + "7900": 1, + "7901": 1, + "7902": 1, + "7903": 1, + "7904": 1, + "7905": 1, + "7906": 1, + "7907": 1, + "7908": 1, + "7909": 1, + "791": 1, + "7910": 1, + "7911": 1, + "7912": 1, + "7913": 1, + "7914": 1, + "7915": 1, + "7916": 1, + "7917": 1, + "7918": 1, + "7919": 1, + "792": 1, + "7920": 1, + "7921": 1, + "7922": 1, + "7923": 1, + "7924": 1, + "7925": 1, + "7926": 1, + "7927": 1, + "7928": 1, + "7929": 1, + "793": 1, + "7930": 1, + "7931": 1, + "7932": 1, + "7933": 1, + "7934": 1, + "7935": 1, + "7936": 1, + "7937": 1, + "7938": 1, + "7939": 1, + "794": 1, + "7940": 1, + "7941": 1, + "7942": 1, + "7943": 1, + "7944": 1, + "7945": 1, + "7946": 1, + "7947": 1, + "7948": 1, + "7949": 1, + "795": 1, + "7950": 1, + "7951": 1, + "7952": 1, + "7953": 1, + "7954": 1, + "7955": 1, + "7956": 1, + "7957": 1, + "7958": 1, + "7959": 1, + "796": 1, + "7960": 1, + "7961": 1, + "7962": 1, + "7963": 1, + "7964": 1, + "7965": 1, + "7966": 1, + "7967": 1, + "7968": 1, + "7969": 1, + "797": 1, + "7970": 1, + "7971": 1, + "7972": 1, + "7973": 1, + "7974": 1, + "7975": 1, + "7976": 1, + "7977": 1, + "7978": 1, + "7979": 1, + "798": 1, + "7980": 1, + "7981": 1, + "7982": 1, + "7983": 1, + "7984": 1, + "7985": 1, + "7986": 1, + "7987": 1, + "7988": 1, + "7989": 1, + "799": 1, + "7990": 1, + "7991": 1, + "7992": 1, + "7993": 1, + "7994": 1, + "7995": 1, + "7996": 1, + "7997": 1, + "7998": 1, + "7999": 1, + "8": 1, + "80": 1, + "800": 1, + "8000": 1, + "8001": 1, + "8002": 1, + "8003": 1, + "8004": 1, + "8005": 1, + "8006": 1, + "8007": 1, + "8008": 1, + "8009": 1, + "801": 1, + "8010": 1, + "8011": 1, + "8012": 1, + "8013": 1, + "8014": 1, + "8015": 1, + "8016": 1, + "8017": 1, + "8018": 1, + "8019": 1, + "802": 1, + "8020": 1, + "8021": 1, + "8022": 1, + "8023": 1, + "8024": 1, + "8025": 1, + "8026": 1, + "8027": 1, + "8028": 1, + "8029": 1, + "803": 1, + "8030": 1, + "8031": 1, + "8032": 1, + "8033": 1, + "8034": 1, + "8035": 1, + "8036": 1, + "8037": 1, + "8038": 1, + "8039": 1, + "804": 1, + "8040": 1, + "8041": 1, + "8042": 1, + "8043": 1, + "8044": 1, + "8045": 1, + "8046": 1, + "8047": 1, + "8048": 1, + "8049": 1, + "805": 1, + "8050": 1, + "8051": 1, + "8052": 1, + "8053": 1, + "8054": 1, + "8055": 1, + "8056": 1, + "8057": 1, + "8058": 1, + "8059": 1, + "806": 1, + "8060": 1, + "8061": 1, + "8062": 1, + "8063": 1, + "8064": 1, + "8065": 1, + "8066": 1, + "8067": 1, + "8068": 1, + "8069": 1, + "807": 1, + "8070": 1, + "8071": 1, + "8072": 1, + "8073": 1, + "8074": 1, + "8075": 1, + "8076": 1, + "8077": 1, + "8078": 1, + "8079": 1, + "808": 1, + "8080": 1, + "8081": 1, + "8082": 1, + "8083": 1, + "8084": 1, + "8085": 1, + "8086": 1, + "8087": 1, + "8088": 1, + "8089": 1, + "809": 1, + "8090": 1, + "8091": 1, + "8092": 1, + "8093": 1, + "8094": 1, + "8095": 1, + "8096": 1, + "8097": 1, + "8098": 1, + "8099": 1, + "81": 1, + "810": 1, + "8100": 1, + "8101": 1, + "8102": 1, + "8103": 1, + "8104": 1, + "8105": 1, + "8106": 1, + "8107": 1, + "8108": 1, + "8109": 1, + "811": 1, + "8110": 1, + "8111": 1, + "8112": 1, + "8113": 1, + "8114": 1, + "8115": 1, + "8116": 1, + "8117": 1, + "8118": 1, + "8119": 1, + "812": 1, + "8120": 1, + "8121": 1, + "8122": 1, + "8123": 1, + "8124": 1, + "8125": 1, + "8126": 1, + "8127": 1, + "8128": 1, + "8129": 1, + "813": 1, + "8130": 1, + "8131": 1, + "8132": 1, + "8133": 1, + "8134": 1, + "8135": 1, + "8136": 1, + "8137": 1, + "8138": 1, + "8139": 1, + "814": 1, + "8140": 1, + "8141": 1, + "8142": 1, + "8143": 1, + "8144": 1, + "8145": 1, + "8146": 1, + "8147": 1, + "8148": 1, + "8149": 1, + "815": 1, + "8150": 1, + "8151": 1, + "8152": 1, + "8153": 1, + "8154": 1, + "8155": 1, + "8156": 1, + "8157": 1, + "8158": 1, + "8159": 1, + "816": 1, + "8160": 1, + "8161": 1, + "8162": 1, + "8163": 1, + "8164": 1, + "8165": 1, + "8166": 1, + "8167": 1, + "8168": 1, + "8169": 1, + "817": 1, + "8170": 1, + "8171": 1, + "8172": 1, + "8173": 1, + "8174": 1, + "8175": 1, + "8176": 1, + "8177": 1, + "8178": 1, + "8179": 1, + "818": 1, + "8180": 1, + "8181": 1, + "8182": 1, + "8183": 1, + "8184": 1, + "8185": 1, + "8186": 1, + "8187": 1, + "8188": 1, + "8189": 1, + "819": 1, + "8190": 1, + "8191": 1, + "8192": 1, + "8193": 1, + "8194": 1, + "8195": 1, + "8196": 1, + "8197": 1, + "8198": 1, + "8199": 1, + "82": 1, + "820": 1, + "8200": 1, + "8201": 1, + "8202": 1, + "8203": 1, + "8204": 1, + "8205": 1, + "8206": 1, + "8207": 1, + "8208": 1, + "8209": 1, + "821": 1, + "8210": 1, + "8211": 1, + "8212": 1, + "8213": 1, + "8214": 1, + "8215": 1, + "8216": 1, + "8217": 1, + "8218": 1, + "8219": 1, + "822": 1, + "8220": 1, + "8221": 1, + "8222": 1, + "8223": 1, + "8224": 1, + "8225": 1, + "8226": 1, + "8227": 1, + "8228": 1, + "8229": 1, + "823": 1, + "8230": 1, + "8231": 1, + "8232": 1, + "8233": 1, + "8234": 1, + "8235": 1, + "8236": 1, + "8237": 1, + "8238": 1, + "8239": 1, + "824": 1, + "8240": 1, + "8241": 1, + "8242": 1, + "8243": 1, + "8244": 1, + "8245": 1, + "8246": 1, + "8247": 1, + "8248": 1, + "8249": 1, + "825": 1, + "8250": 1, + "8251": 1, + "8252": 1, + "8253": 1, + "8254": 1, + "8255": 1, + "8256": 1, + "8257": 1, + "8258": 1, + "8259": 1, + "826": 1, + "8260": 1, + "8261": 1, + "8262": 1, + "8263": 1, + "8264": 1, + "8265": 1, + "8266": 1, + "8267": 1, + "8268": 1, + "8269": 1, + "827": 1, + "8270": 1, + "8271": 1, + "8272": 1, + "8273": 1, + "8274": 1, + "8275": 1, + "8276": 1, + "8277": 1, + "8278": 1, + "8279": 1, + "828": 1, + "8280": 1, + "8281": 1, + "8282": 1, + "8283": 1, + "8284": 1, + "8285": 1, + "8286": 1, + "8287": 1, + "8288": 1, + "8289": 1, + "829": 1, + "8290": 1, + "8291": 1, + "8292": 1, + "8293": 1, + "8294": 1, + "8295": 1, + "8296": 1, + "8297": 1, + "8298": 1, + "8299": 1, + "83": 1, + "830": 1, + "8300": 1, + "8301": 1, + "8302": 1, + "8303": 1, + "8304": 1, + "8305": 1, + "8306": 1, + "8307": 1, + "8308": 1, + "8309": 1, + "831": 1, + "8310": 1, + "8311": 1, + "8312": 1, + "8313": 1, + "8314": 1, + "8315": 1, + "8316": 1, + "8317": 1, + "8318": 1, + "8319": 1, + "832": 1, + "8320": 1, + "8321": 1, + "8322": 1, + "8323": 1, + "8324": 1, + "8325": 1, + "8326": 1, + "8327": 1, + "8328": 1, + "8329": 1, + "833": 1, + "8330": 1, + "8331": 1, + "8332": 1, + "8333": 1, + "8334": 1, + "8335": 1, + "8336": 1, + "8337": 1, + "8338": 1, + "8339": 1, + "834": 1, + "8340": 1, + "8341": 1, + "8342": 1, + "8343": 1, + "8344": 1, + "8345": 1, + "8346": 1, + "8347": 1, + "8348": 1, + "8349": 1, + "835": 1, + "8350": 1, + "8351": 1, + "8352": 1, + "8353": 1, + "8354": 1, + "8355": 1, + "8356": 1, + "8357": 1, + "8358": 1, + "8359": 1, + "836": 1, + "8360": 1, + "8361": 1, + "8362": 1, + "8363": 1, + "8364": 1, + "8365": 1, + "8366": 1, + "8367": 1, + "8368": 1, + "8369": 1, + "837": 1, + "8370": 1, + "8371": 1, + "8372": 1, + "8373": 1, + "8374": 1, + "8375": 1, + "8376": 1, + "8377": 1, + "8378": 1, + "8379": 1, + "838": 1, + "8380": 1, + "8381": 1, + "8382": 1, + "8383": 1, + "8384": 1, + "8385": 1, + "8386": 1, + "8387": 1, + "8388": 1, + "8389": 1, + "839": 1, + "8390": 1, + "8391": 1, + "8392": 1, + "8393": 1, + "8394": 1, + "8395": 1, + "8396": 1, + "8397": 1, + "8398": 1, + "8399": 1, + "84": 1, + "840": 1, + "8400": 1, + "8401": 1, + "8402": 1, + "8403": 1, + "8404": 1, + "8405": 1, + "8406": 1, + "8407": 1, + "8408": 1, + "8409": 1, + "841": 1, + "8410": 1, + "8411": 1, + "8412": 1, + "8413": 1, + "8414": 1, + "8415": 1, + "8416": 1, + "8417": 1, + "8418": 1, + "8419": 1, + "842": 1, + "8420": 1, + "8421": 1, + "8422": 1, + "8423": 1, + "8424": 1, + "8425": 1, + "8426": 1, + "8427": 1, + "8428": 1, + "8429": 1, + "843": 1, + "8430": 1, + "8431": 1, + "8432": 1, + "8433": 1, + "8434": 1, + "8435": 1, + "8436": 1, + "8437": 1, + "8438": 1, + "8439": 1, + "844": 1, + "8440": 1, + "8441": 1, + "8442": 1, + "8443": 1, + "8444": 1, + "8445": 1, + "8446": 1, + "8447": 1, + "8448": 1, + "8449": 1, + "845": 1, + "8450": 1, + "8451": 1, + "8452": 1, + "8453": 1, + "8454": 1, + "8455": 1, + "8456": 1, + "8457": 1, + "8458": 1, + "8459": 1, + "846": 1, + "8460": 1, + "8461": 1, + "8462": 1, + "8463": 1, + "8464": 1, + "8465": 1, + "8466": 1, + "8467": 1, + "8468": 1, + "8469": 1, + "847": 1, + "8470": 1, + "8471": 1, + "8472": 1, + "8473": 1, + "8474": 1, + "8475": 1, + "8476": 1, + "8477": 1, + "8478": 1, + "8479": 1, + "848": 1, + "8480": 1, + "8481": 1, + "8482": 1, + "8483": 1, + "8484": 1, + "8485": 1, + "8486": 1, + "8487": 1, + "8488": 1, + "8489": 1, + "849": 1, + "8490": 1, + "8491": 1, + "8492": 1, + "8493": 1, + "8494": 1, + "8495": 1, + "8496": 1, + "8497": 1, + "8498": 1, + "8499": 1, + "85": 1, + "850": 1, + "8500": 1, + "8501": 1, + "8502": 1, + "8503": 1, + "8504": 1, + "8505": 1, + "8506": 1, + "8507": 1, + "8508": 1, + "8509": 1, + "851": 1, + "8510": 1, + "8511": 1, + "8512": 1, + "8513": 1, + "8514": 1, + "8515": 1, + "8516": 1, + "8517": 1, + "8518": 1, + "8519": 1, + "852": 1, + "8520": 1, + "8521": 1, + "8522": 1, + "8523": 1, + "8524": 1, + "8525": 1, + "8526": 1, + "8527": 1, + "8528": 1, + "8529": 1, + "853": 1, + "8530": 1, + "8531": 1, + "8532": 1, + "8533": 1, + "8534": 1, + "8535": 1, + "8536": 1, + "8537": 1, + "8538": 1, + "8539": 1, + "854": 1, + "8540": 1, + "8541": 1, + "8542": 1, + "8543": 1, + "8544": 1, + "8545": 1, + "8546": 1, + "8547": 1, + "8548": 1, + "8549": 1, + "855": 1, + "8550": 1, + "8551": 1, + "8552": 1, + "8553": 1, + "8554": 1, + "8555": 1, + "8556": 1, + "8557": 1, + "8558": 1, + "8559": 1, + "856": 1, + "8560": 1, + "8561": 1, + "8562": 1, + "8563": 1, + "8564": 1, + "8565": 1, + "8566": 1, + "8567": 1, + "8568": 1, + "8569": 1, + "857": 1, + "8570": 1, + "8571": 1, + "8572": 1, + "8573": 1, + "8574": 1, + "8575": 1, + "8576": 1, + "8577": 1, + "8578": 1, + "8579": 1, + "858": 1, + "8580": 1, + "8581": 1, + "8582": 1, + "8583": 1, + "8584": 1, + "8585": 1, + "8586": 1, + "8587": 1, + "8588": 1, + "8589": 1, + "859": 1, + "8590": 1, + "8591": 1, + "8592": 1, + "8593": 1, + "8594": 1, + "8595": 1, + "8596": 1, + "8597": 1, + "8598": 1, + "8599": 1, + "86": 1, + "860": 1, + "8600": 1, + "8601": 1, + "8602": 1, + "8603": 1, + "8604": 1, + "8605": 1, + "8606": 1, + "8607": 1, + "8608": 1, + "8609": 1, + "861": 1, + "8610": 1, + "8611": 1, + "8612": 1, + "8613": 1, + "8614": 1, + "8615": 1, + "8616": 1, + "8617": 1, + "8618": 1, + "8619": 1, + "862": 1, + "8620": 1, + "8621": 1, + "8622": 1, + "8623": 1, + "8624": 1, + "8625": 1, + "8626": 1, + "8627": 1, + "8628": 1, + "8629": 1, + "863": 1, + "8630": 1, + "8631": 1, + "8632": 1, + "8633": 1, + "8634": 1, + "8635": 1, + "8636": 1, + "8637": 1, + "8638": 1, + "8639": 1, + "864": 1, + "8640": 1, + "8641": 1, + "8642": 1, + "8643": 1, + "8644": 1, + "8645": 1, + "8646": 1, + "8647": 1, + "8648": 1, + "8649": 1, + "865": 1, + "8650": 1, + "8651": 1, + "8652": 1, + "8653": 1, + "8654": 1, + "8655": 1, + "8656": 1, + "8657": 1, + "8658": 1, + "8659": 1, + "866": 1, + "8660": 1, + "8661": 1, + "8662": 1, + "8663": 1, + "8664": 1, + "8665": 1, + "8666": 1, + "8667": 1, + "8668": 1, + "8669": 1, + "867": 1, + "8670": 1, + "8671": 1, + "8672": 1, + "8673": 1, + "8674": 1, + "8675": 1, + "8676": 1, + "8677": 1, + "8678": 1, + "8679": 1, + "868": 1, + "8680": 1, + "8681": 1, + "8682": 1, + "8683": 1, + "8684": 1, + "8685": 1, + "8686": 1, + "8687": 1, + "8688": 1, + "8689": 1, + "869": 1, + "8690": 1, + "8691": 1, + "8692": 1, + "8693": 1, + "8694": 1, + "8695": 1, + "8696": 1, + "8697": 1, + "8698": 1, + "8699": 1, + "87": 1, + "870": 1, + "8700": 1, + "8701": 1, + "8702": 1, + "8703": 1, + "8704": 1, + "8705": 1, + "8706": 1, + "8707": 1, + "8708": 1, + "8709": 1, + "871": 1, + "8710": 1, + "8711": 1, + "8712": 1, + "8713": 1, + "8714": 1, + "8715": 1, + "8716": 1, + "8717": 1, + "8718": 1, + "8719": 1, + "872": 1, + "8720": 1, + "8721": 1, + "8722": 1, + "8723": 1, + "8724": 1, + "8725": 1, + "8726": 1, + "8727": 1, + "8728": 1, + "8729": 1, + "873": 1, + "8730": 1, + "8731": 1, + "8732": 1, + "8733": 1, + "8734": 1, + "8735": 1, + "8736": 1, + "8737": 1, + "8738": 1, + "8739": 1, + "874": 1, + "8740": 1, + "8741": 1, + "8742": 1, + "8743": 1, + "8744": 1, + "8745": 1, + "8746": 1, + "8747": 1, + "8748": 1, + "8749": 1, + "875": 1, + "8750": 1, + "8751": 1, + "8752": 1, + "8753": 1, + "8754": 1, + "8755": 1, + "8756": 1, + "8757": 1, + "8758": 1, + "8759": 1, + "876": 1, + "8760": 1, + "8761": 1, + "8762": 1, + "8763": 1, + "8764": 1, + "8765": 1, + "8766": 1, + "8767": 1, + "8768": 1, + "8769": 1, + "877": 1, + "8770": 1, + "8771": 1, + "8772": 1, + "8773": 1, + "8774": 1, + "8775": 1, + "8776": 1, + "8777": 1, + "8778": 1, + "8779": 1, + "878": 1, + "8780": 1, + "8781": 1, + "8782": 1, + "8783": 1, + "8784": 1, + "8785": 1, + "8786": 1, + "8787": 1, + "8788": 1, + "8789": 1, + "879": 1, + "8790": 1, + "8791": 1, + "8792": 1, + "8793": 1, + "8794": 1, + "8795": 1, + "8796": 1, + "8797": 1, + "8798": 1, + "8799": 1, + "88": 1, + "880": 1, + "8800": 1, + "8801": 1, + "8802": 1, + "8803": 1, + "8804": 1, + "8805": 1, + "8806": 1, + "8807": 1, + "8808": 1, + "8809": 1, + "881": 1, + "8810": 1, + "8811": 1, + "8812": 1, + "8813": 1, + "8814": 1, + "8815": 1, + "8816": 1, + "8817": 1, + "8818": 1, + "8819": 1, + "882": 1, + "8820": 1, + "8821": 1, + "8822": 1, + "8823": 1, + "8824": 1, + "8825": 1, + "8826": 1, + "8827": 1, + "8828": 1, + "8829": 1, + "883": 1, + "8830": 1, + "8831": 1, + "8832": 1, + "8833": 1, + "8834": 1, + "8835": 1, + "8836": 1, + "8837": 1, + "8838": 1, + "8839": 1, + "884": 1, + "8840": 1, + "8841": 1, + "8842": 1, + "8843": 1, + "8844": 1, + "8845": 1, + "8846": 1, + "8847": 1, + "8848": 1, + "8849": 1, + "885": 1, + "8850": 1, + "8851": 1, + "8852": 1, + "8853": 1, + "8854": 1, + "8855": 1, + "8856": 1, + "8857": 1, + "8858": 1, + "8859": 1, + "886": 1, + "8860": 1, + "8861": 1, + "8862": 1, + "8863": 1, + "8864": 1, + "8865": 1, + "8866": 1, + "8867": 1, + "8868": 1, + "8869": 1, + "887": 1, + "8870": 1, + "8871": 1, + "8872": 1, + "8873": 1, + "8874": 1, + "8875": 1, + "8876": 1, + "8877": 1, + "8878": 1, + "8879": 1, + "888": 1, + "8880": 1, + "8881": 1, + "8882": 1, + "8883": 1, + "8884": 1, + "8885": 1, + "8886": 1, + "8887": 1, + "8888": 1, + "8889": 1, + "889": 1, + "8890": 1, + "8891": 1, + "8892": 1, + "8893": 1, + "8894": 1, + "8895": 1, + "8896": 1, + "8897": 1, + "8898": 1, + "8899": 1, + "89": 1, + "890": 1, + "8900": 1, + "8901": 1, + "8902": 1, + "8903": 1, + "8904": 1, + "8905": 1, + "8906": 1, + "8907": 1, + "8908": 1, + "8909": 1, + "891": 1, + "8910": 1, + "8911": 1, + "8912": 1, + "8913": 1, + "8914": 1, + "8915": 1, + "8916": 1, + "8917": 1, + "8918": 1, + "8919": 1, + "892": 1, + "8920": 1, + "8921": 1, + "8922": 1, + "8923": 1, + "8924": 1, + "8925": 1, + "8926": 1, + "8927": 1, + "8928": 1, + "8929": 1, + "893": 1, + "8930": 1, + "8931": 1, + "8932": 1, + "8933": 1, + "8934": 1, + "8935": 1, + "8936": 1, + "8937": 1, + "8938": 1, + "8939": 1, + "894": 1, + "8940": 1, + "8941": 1, + "8942": 1, + "8943": 1, + "8944": 1, + "8945": 1, + "8946": 1, + "8947": 1, + "8948": 1, + "8949": 1, + "895": 1, + "8950": 1, + "8951": 1, + "8952": 1, + "8953": 1, + "8954": 1, + "8955": 1, + "8956": 1, + "8957": 1, + "8958": 1, + "8959": 1, + "896": 1, + "8960": 1, + "8961": 1, + "8962": 1, + "8963": 1, + "8964": 1, + "8965": 1, + "8966": 1, + "8967": 1, + "8968": 1, + "8969": 1, + "897": 1, + "8970": 1, + "8971": 1, + "8972": 1, + "8973": 1, + "8974": 1, + "8975": 1, + "8976": 1, + "8977": 1, + "8978": 1, + "8979": 1, + "898": 1, + "8980": 1, + "8981": 1, + "8982": 1, + "8983": 1, + "8984": 1, + "8985": 1, + "8986": 1, + "8987": 1, + "8988": 1, + "8989": 1, + "899": 1, + "8990": 1, + "8991": 1, + "8992": 1, + "8993": 1, + "8994": 1, + "8995": 1, + "8996": 1, + "8997": 1, + "8998": 1, + "8999": 1, + "9": 1, + "90": 1, + "900": 1, + "9000": 1, + "9001": 1, + "9002": 1, + "9003": 1, + "9004": 1, + "9005": 1, + "9006": 1, + "9007": 1, + "9008": 1, + "9009": 1, + "901": 1, + "9010": 1, + "9011": 1, + "9012": 1, + "9013": 1, + "9014": 1, + "9015": 1, + "9016": 1, + "9017": 1, + "9018": 1, + "9019": 1, + "902": 1, + "9020": 1, + "9021": 1, + "9022": 1, + "9023": 1, + "9024": 1, + "9025": 1, + "9026": 1, + "9027": 1, + "9028": 1, + "9029": 1, + "903": 1, + "9030": 1, + "9031": 1, + "9032": 1, + "9033": 1, + "9034": 1, + "9035": 1, + "9036": 1, + "9037": 1, + "9038": 1, + "9039": 1, + "904": 1, + "9040": 1, + "9041": 1, + "9042": 1, + "9043": 1, + "9044": 1, + "9045": 1, + "9046": 1, + "9047": 1, + "9048": 1, + "9049": 1, + "905": 1, + "9050": 1, + "9051": 1, + "9052": 1, + "9053": 1, + "9054": 1, + "9055": 1, + "9056": 1, + "9057": 1, + "9058": 1, + "9059": 1, + "906": 1, + "9060": 1, + "9061": 1, + "9062": 1, + "9063": 1, + "9064": 1, + "9065": 1, + "9066": 1, + "9067": 1, + "9068": 1, + "9069": 1, + "907": 1, + "9070": 1, + "9071": 1, + "9072": 1, + "9073": 1, + "9074": 1, + "9075": 1, + "9076": 1, + "9077": 1, + "9078": 1, + "9079": 1, + "908": 1, + "9080": 1, + "9081": 1, + "9082": 1, + "9083": 1, + "9084": 1, + "9085": 1, + "9086": 1, + "9087": 1, + "9088": 1, + "9089": 1, + "909": 1, + "9090": 1, + "9091": 1, + "9092": 1, + "9093": 1, + "9094": 1, + "9095": 1, + "9096": 1, + "9097": 1, + "9098": 1, + "9099": 1, + "91": 1, + "910": 1, + "9100": 1, + "9101": 1, + "9102": 1, + "9103": 1, + "9104": 1, + "9105": 1, + "9106": 1, + "9107": 1, + "9108": 1, + "9109": 1, + "911": 1, + "9110": 1, + "9111": 1, + "9112": 1, + "9113": 1, + "9114": 1, + "9115": 1, + "9116": 1, + "9117": 1, + "9118": 1, + "9119": 1, + "912": 1, + "9120": 1, + "9121": 1, + "9122": 1, + "9123": 1, + "9124": 1, + "9125": 1, + "9126": 1, + "9127": 1, + "9128": 1, + "9129": 1, + "913": 1, + "9130": 1, + "9131": 1, + "9132": 1, + "9133": 1, + "9134": 1, + "9135": 1, + "9136": 1, + "9137": 1, + "9138": 1, + "9139": 1, + "914": 1, + "9140": 1, + "9141": 1, + "9142": 1, + "9143": 1, + "9144": 1, + "9145": 1, + "9146": 1, + "9147": 1, + "9148": 1, + "9149": 1, + "915": 1, + "9150": 1, + "9151": 1, + "9152": 1, + "9153": 1, + "9154": 1, + "9155": 1, + "9156": 1, + "9157": 1, + "9158": 1, + "9159": 1, + "916": 1, + "9160": 1, + "9161": 1, + "9162": 1, + "9163": 1, + "9164": 1, + "9165": 1, + "9166": 1, + "9167": 1, + "9168": 1, + "9169": 1, + "917": 1, + "9170": 1, + "9171": 1, + "9172": 1, + "9173": 1, + "9174": 1, + "9175": 1, + "9176": 1, + "9177": 1, + "9178": 1, + "9179": 1, + "918": 1, + "9180": 1, + "9181": 1, + "9182": 1, + "9183": 1, + "9184": 1, + "9185": 1, + "9186": 1, + "9187": 1, + "9188": 1, + "9189": 1, + "919": 1, + "9190": 1, + "9191": 1, + "9192": 1, + "9193": 1, + "9194": 1, + "9195": 1, + "9196": 1, + "9197": 1, + "9198": 1, + "9199": 1, + "92": 1, + "920": 1, + "9200": 1, + "9201": 1, + "9202": 1, + "9203": 1, + "9204": 1, + "9205": 1, + "9206": 1, + "9207": 1, + "9208": 1, + "9209": 1, + "921": 1, + "9210": 1, + "9211": 1, + "9212": 1, + "9213": 1, + "9214": 1, + "9215": 1, + "9216": 1, + "9217": 1, + "9218": 1, + "9219": 1, + "922": 1, + "9220": 1, + "9221": 1, + "9222": 1, + "9223": 1, + "9224": 1, + "9225": 1, + "9226": 1, + "9227": 1, + "9228": 1, + "9229": 1, + "923": 1, + "9230": 1, + "9231": 1, + "9232": 1, + "9233": 1, + "9234": 1, + "9235": 1, + "9236": 1, + "9237": 1, + "9238": 1, + "9239": 1, + "924": 1, + "9240": 1, + "9241": 1, + "9242": 1, + "9243": 1, + "9244": 1, + "9245": 1, + "9246": 1, + "9247": 1, + "9248": 1, + "9249": 1, + "925": 1, + "9250": 1, + "9251": 1, + "9252": 1, + "9253": 1, + "9254": 1, + "9255": 1, + "9256": 1, + "9257": 1, + "9258": 1, + "9259": 1, + "926": 1, + "9260": 1, + "9261": 1, + "9262": 1, + "9263": 1, + "9264": 1, + "9265": 1, + "9266": 1, + "9267": 1, + "9268": 1, + "9269": 1, + "927": 1, + "9270": 1, + "9271": 1, + "9272": 1, + "9273": 1, + "9274": 1, + "9275": 1, + "9276": 1, + "9277": 1, + "9278": 1, + "9279": 1, + "928": 1, + "9280": 1, + "9281": 1, + "9282": 1, + "9283": 1, + "9284": 1, + "9285": 1, + "9286": 1, + "9287": 1, + "9288": 1, + "9289": 1, + "929": 1, + "9290": 1, + "9291": 1, + "9292": 1, + "9293": 1, + "9294": 1, + "9295": 1, + "9296": 1, + "9297": 1, + "9298": 1, + "9299": 1, + "93": 1, + "930": 1, + "9300": 1, + "9301": 1, + "9302": 1, + "9303": 1, + "9304": 1, + "9305": 1, + "9306": 1, + "9307": 1, + "9308": 1, + "9309": 1, + "931": 1, + "9310": 1, + "9311": 1, + "9312": 1, + "9313": 1, + "9314": 1, + "9315": 1, + "9316": 1, + "9317": 1, + "9318": 1, + "9319": 1, + "932": 1, + "9320": 1, + "9321": 1, + "9322": 1, + "9323": 1, + "9324": 1, + "9325": 1, + "9326": 1, + "9327": 1, + "9328": 1, + "9329": 1, + "933": 1, + "9330": 1, + "9331": 1, + "9332": 1, + "9333": 1, + "9334": 1, + "9335": 1, + "9336": 1, + "9337": 1, + "9338": 1, + "9339": 1, + "934": 1, + "9340": 1, + "9341": 1, + "9342": 1, + "9343": 1, + "9344": 1, + "9345": 1, + "9346": 1, + "9347": 1, + "9348": 1, + "9349": 1, + "935": 1, + "9350": 1, + "9351": 1, + "9352": 1, + "9353": 1, + "9354": 1, + "9355": 1, + "9356": 1, + "9357": 1, + "9358": 1, + "9359": 1, + "936": 1, + "9360": 1, + "9361": 1, + "9362": 1, + "9363": 1, + "9364": 1, + "9365": 1, + "9366": 1, + "9367": 1, + "9368": 1, + "9369": 1, + "937": 1, + "9370": 1, + "9371": 1, + "9372": 1, + "9373": 1, + "9374": 1, + "9375": 1, + "9376": 1, + "9377": 1, + "9378": 1, + "9379": 1, + "938": 1, + "9380": 1, + "9381": 1, + "9382": 1, + "9383": 1, + "9384": 1, + "9385": 1, + "9386": 1, + "9387": 1, + "9388": 1, + "9389": 1, + "939": 1, + "9390": 1, + "9391": 1, + "9392": 1, + "9393": 1, + "9394": 1, + "9395": 1, + "9396": 1, + "9397": 1, + "9398": 1, + "9399": 1, + "94": 1, + "940": 1, + "9400": 1, + "9401": 1, + "9402": 1, + "9403": 1, + "9404": 1, + "9405": 1, + "9406": 1, + "9407": 1, + "9408": 1, + "9409": 1, + "941": 1, + "9410": 1, + "9411": 1, + "9412": 1, + "9413": 1, + "9414": 1, + "9415": 1, + "9416": 1, + "9417": 1, + "9418": 1, + "9419": 1, + "942": 1, + "9420": 1, + "9421": 1, + "9422": 1, + "9423": 1, + "9424": 1, + "9425": 1, + "9426": 1, + "9427": 1, + "9428": 1, + "9429": 1, + "943": 1, + "9430": 1, + "9431": 1, + "9432": 1, + "9433": 1, + "9434": 1, + "9435": 1, + "9436": 1, + "9437": 1, + "9438": 1, + "9439": 1, + "944": 1, + "9440": 1, + "9441": 1, + "9442": 1, + "9443": 1, + "9444": 1, + "9445": 1, + "9446": 1, + "9447": 1, + "9448": 1, + "9449": 1, + "945": 1, + "9450": 1, + "9451": 1, + "9452": 1, + "9453": 1, + "9454": 1, + "9455": 1, + "9456": 1, + "9457": 1, + "9458": 1, + "9459": 1, + "946": 1, + "9460": 1, + "9461": 1, + "9462": 1, + "9463": 1, + "9464": 1, + "9465": 1, + "9466": 1, + "9467": 1, + "9468": 1, + "9469": 1, + "947": 1, + "9470": 1, + "9471": 1, + "9472": 1, + "9473": 1, + "9474": 1, + "9475": 1, + "9476": 1, + "9477": 1, + "9478": 1, + "9479": 1, + "948": 1, + "9480": 1, + "9481": 1, + "9482": 1, + "9483": 1, + "9484": 1, + "9485": 1, + "9486": 1, + "9487": 1, + "9488": 1, + "9489": 1, + "949": 1, + "9490": 1, + "9491": 1, + "9492": 1, + "9493": 1, + "9494": 1, + "9495": 1, + "9496": 1, + "9497": 1, + "9498": 1, + "9499": 1, + "95": 1, + "950": 1, + "9500": 1, + "9501": 1, + "9502": 1, + "9503": 1, + "9504": 1, + "9505": 1, + "9506": 1, + "9507": 1, + "9508": 1, + "9509": 1, + "951": 1, + "9510": 1, + "9511": 1, + "9512": 1, + "9513": 1, + "9514": 1, + "9515": 1, + "9516": 1, + "9517": 1, + "9518": 1, + "9519": 1, + "952": 1, + "9520": 1, + "9521": 1, + "9522": 1, + "9523": 1, + "9524": 1, + "9525": 1, + "9526": 1, + "9527": 1, + "9528": 1, + "9529": 1, + "953": 1, + "9530": 1, + "9531": 1, + "9532": 1, + "9533": 1, + "9534": 1, + "9535": 1, + "9536": 1, + "9537": 1, + "9538": 1, + "9539": 1, + "954": 1, + "9540": 1, + "9541": 1, + "9542": 1, + "9543": 1, + "9544": 1, + "9545": 1, + "9546": 1, + "9547": 1, + "9548": 1, + "9549": 1, + "955": 1, + "9550": 1, + "9551": 1, + "9552": 1, + "9553": 1, + "9554": 1, + "9555": 1, + "9556": 1, + "9557": 1, + "9558": 1, + "9559": 1, + "956": 1, + "9560": 1, + "9561": 1, + "9562": 1, + "9563": 1, + "9564": 1, + "9565": 1, + "9566": 1, + "9567": 1, + "9568": 1, + "9569": 1, + "957": 1, + "9570": 1, + "9571": 1, + "9572": 1, + "9573": 1, + "9574": 1, + "9575": 1, + "9576": 1, + "9577": 1, + "9578": 1, + "9579": 1, + "958": 1, + "9580": 1, + "9581": 1, + "9582": 1, + "9583": 1, + "9584": 1, + "9585": 1, + "9586": 1, + "9587": 1, + "9588": 1, + "9589": 1, + "959": 1, + "9590": 1, + "9591": 1, + "9592": 1, + "9593": 1, + "9594": 1, + "9595": 1, + "9596": 1, + "9597": 1, + "9598": 1, + "9599": 1, + "96": 1, + "960": 1, + "9600": 1, + "9601": 1, + "9602": 1, + "9603": 1, + "9604": 1, + "9605": 1, + "9606": 1, + "9607": 1, + "9608": 1, + "9609": 1, + "961": 1, + "9610": 1, + "9611": 1, + "9612": 1, + "9613": 1, + "9614": 1, + "9615": 1, + "9616": 1, + "9617": 1, + "9618": 1, + "9619": 1, + "962": 1, + "9620": 1, + "9621": 1, + "9622": 1, + "9623": 1, + "9624": 1, + "9625": 1, + "9626": 1, + "9627": 1, + "9628": 1, + "9629": 1, + "963": 1, + "9630": 1, + "9631": 1, + "9632": 1, + "9633": 1, + "9634": 1, + "9635": 1, + "9636": 1, + "9637": 1, + "9638": 1, + "9639": 1, + "964": 1, + "9640": 1, + "9641": 1, + "9642": 1, + "9643": 1, + "9644": 1, + "9645": 1, + "9646": 1, + "9647": 1, + "9648": 1, + "9649": 1, + "965": 1, + "9650": 1, + "9651": 1, + "9652": 1, + "9653": 1, + "9654": 1, + "9655": 1, + "9656": 1, + "9657": 1, + "9658": 1, + "9659": 1, + "966": 1, + "9660": 1, + "9661": 1, + "9662": 1, + "9663": 1, + "9664": 1, + "9665": 1, + "9666": 1, + "9667": 1, + "9668": 1, + "9669": 1, + "967": 1, + "9670": 1, + "9671": 1, + "9672": 1, + "9673": 1, + "9674": 1, + "9675": 1, + "9676": 1, + "9677": 1, + "9678": 1, + "9679": 1, + "968": 1, + "9680": 1, + "9681": 1, + "9682": 1, + "9683": 1, + "9684": 1, + "9685": 1, + "9686": 1, + "9687": 1, + "9688": 1, + "9689": 1, + "969": 1, + "9690": 1, + "9691": 1, + "9692": 1, + "9693": 1, + "9694": 1, + "9695": 1, + "9696": 1, + "9697": 1, + "9698": 1, + "9699": 1, + "97": 1, + "970": 1, + "9700": 1, + "9701": 1, + "9702": 1, + "9703": 1, + "9704": 1, + "9705": 1, + "9706": 1, + "9707": 1, + "9708": 1, + "9709": 1, + "971": 1, + "9710": 1, + "9711": 1, + "9712": 1, + "9713": 1, + "9714": 1, + "9715": 1, + "9716": 1, + "9717": 1, + "9718": 1, + "9719": 1, + "972": 1, + "9720": 1, + "9721": 1, + "9722": 1, + "9723": 1, + "9724": 1, + "9725": 1, + "9726": 1, + "9727": 1, + "9728": 1, + "9729": 1, + "973": 1, + "9730": 1, + "9731": 1, + "9732": 1, + "9733": 1, + "9734": 1, + "9735": 1, + "9736": 1, + "9737": 1, + "9738": 1, + "9739": 1, + "974": 1, + "9740": 1, + "9741": 1, + "9742": 1, + "9743": 1, + "9744": 1, + "9745": 1, + "9746": 1, + "9747": 1, + "9748": 1, + "9749": 1, + "975": 1, + "9750": 1, + "9751": 1, + "9752": 1, + "9753": 1, + "9754": 1, + "9755": 1, + "9756": 1, + "9757": 1, + "9758": 1, + "9759": 1, + "976": 1, + "9760": 1, + "9761": 1, + "9762": 1, + "9763": 1, + "9764": 1, + "9765": 1, + "9766": 1, + "9767": 1, + "9768": 1, + "9769": 1, + "977": 1, + "9770": 1, + "9771": 1, + "9772": 1, + "9773": 1, + "9774": 1, + "9775": 1, + "9776": 1, + "9777": 1, + "9778": 1, + "9779": 1, + "978": 1, + "9780": 1, + "9781": 1, + "9782": 1, + "9783": 1, + "9784": 1, + "9785": 1, + "9786": 1, + "9787": 1, + "9788": 1, + "9789": 1, + "979": 1, + "9790": 1, + "9791": 1, + "9792": 1, + "9793": 1, + "9794": 1, + "9795": 1, + "9796": 1, + "9797": 1, + "9798": 1, + "9799": 1, + "98": 1, + "980": 1, + "9800": 1, + "9801": 1, + "9802": 1, + "9803": 1, + "9804": 1, + "9805": 1, + "9806": 1, + "9807": 1, + "9808": 1, + "9809": 1, + "981": 1, + "9810": 1, + "9811": 1, + "9812": 1, + "9813": 1, + "9814": 1, + "9815": 1, + "9816": 1, + "9817": 1, + "9818": 1, + "9819": 1, + "982": 1, + "9820": 1, + "9821": 1, + "9822": 1, + "9823": 1, + "9824": 1, + "9825": 1, + "9826": 1, + "9827": 1, + "9828": 1, + "9829": 1, + "983": 1, + "9830": 1, + "9831": 1, + "9832": 1, + "9833": 1, + "9834": 1, + "9835": 1, + "9836": 1, + "9837": 1, + "9838": 1, + "9839": 1, + "984": 1, + "9840": 1, + "9841": 1, + "9842": 1, + "9843": 1, + "9844": 1, + "9845": 1, + "9846": 1, + "9847": 1, + "9848": 1, + "9849": 1, + "985": 1, + "9850": 1, + "9851": 1, + "9852": 1, + "9853": 1, + "9854": 1, + "9855": 1, + "9856": 1, + "9857": 1, + "9858": 1, + "9859": 1, + "986": 1, + "9860": 1, + "9861": 1, + "9862": 1, + "9863": 1, + "9864": 1, + "9865": 1, + "9866": 1, + "9867": 1, + "9868": 1, + "9869": 1, + "987": 1, + "9870": 1, + "9871": 1, + "9872": 1, + "9873": 1, + "9874": 1, + "9875": 1, + "9876": 1, + "9877": 1, + "9878": 1, + "9879": 1, + "988": 1, + "9880": 1, + "9881": 1, + "9882": 1, + "9883": 1, + "9884": 1, + "9885": 1, + "9886": 1, + "9887": 1, + "9888": 1, + "9889": 1, + "989": 1, + "9890": 1, + "9891": 1, + "9892": 1, + "9893": 1, + "9894": 1, + "9895": 1, + "9896": 1, + "9897": 1, + "9898": 1, + "9899": 1, + "99": 1, + "990": 1, + "9900": 1, + "9901": 1, + "9902": 1, + "9903": 1, + "9904": 1, + "9905": 1, + "9906": 1, + "9907": 1, + "9908": 1, + "9909": 1, + "991": 1, + "9910": 1, + "9911": 1, + "9912": 1, + "9913": 1, + "9914": 1, + "9915": 1, + "9916": 1, + "9917": 1, + "9918": 1, + "9919": 1, + "992": 1, + "9920": 1, + "9921": 1, + "9922": 1, + "9923": 1, + "9924": 1, + "9925": 1, + "9926": 1, + "9927": 1, + "9928": 1, + "9929": 1, + "993": 1, + "9930": 1, + "9931": 1, + "9932": 1, + "9933": 1, + "9934": 1, + "9935": 1, + "9936": 1, + "9937": 1, + "9938": 1, + "9939": 1, + "994": 1, + "9940": 1, + "9941": 1, + "9942": 1, + "9943": 1, + "9944": 1, + "9945": 1, + "9946": 1, + "9947": 1, + "9948": 1, + "9949": 1, + "995": 1, + "9950": 1, + "9951": 1, + "9952": 1, + "9953": 1, + "9954": 1, + "9955": 1, + "9956": 1, + "9957": 1, + "9958": 1, + "9959": 1, + "996": 1, + "9960": 1, + "9961": 1, + "9962": 1, + "9963": 1, + "9964": 1, + "9965": 1, + "9966": 1, + "9967": 1, + "9968": 1, + "9969": 1, + "997": 1, + "9970": 1, + "9971": 1, + "9972": 1, + "9973": 1, + "9974": 1, + "9975": 1, + "9976": 1, + "9977": 1, + "9978": 1, + "9979": 1, + "998": 1, + "9980": 1, + "9981": 1, + "9982": 1, + "9983": 1, + "9984": 1, + "9985": 1, + "9986": 1, + "9987": 1, + "9988": 1, + "9989": 1, + "999": 1, + "9990": 1, + "9991": 1, + "9992": 1, + "9993": 1, + "9994": 1, + "9995": 1, + "9996": 1, + "9997": 1, + "9998": 1, + "9999": 1 +} From d6191f050c92dbc5de796ce6cbb97403998236f6 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:10:06 +0100 Subject: [PATCH 080/112] Updated benchmarks folder --- benchmarks/example.txt | 10002 --------------------------------------- 1 file changed, 10002 deletions(-) delete mode 100644 benchmarks/example.txt diff --git a/benchmarks/example.txt b/benchmarks/example.txt deleted file mode 100644 index 10b7e8c35..000000000 --- a/benchmarks/example.txt +++ /dev/null @@ -1,10002 +0,0 @@ -{ - "0": 1, - "1": 1, - "10": 1, - "100": 1, - "1000": 1, - "1001": 1, - "1002": 1, - "1003": 1, - "1004": 1, - "1005": 1, - "1006": 1, - "1007": 1, - "1008": 1, - "1009": 1, - "101": 1, - "1010": 1, - "1011": 1, - "1012": 1, - "1013": 1, - "1014": 1, - "1015": 1, - "1016": 1, - "1017": 1, - "1018": 1, - "1019": 1, - "102": 1, - "1020": 1, - "1021": 1, - "1022": 1, - "1023": 1, - "1024": 1, - "1025": 1, - "1026": 1, - "1027": 1, - "1028": 1, - "1029": 1, - "103": 1, - "1030": 1, - "1031": 1, - "1032": 1, - "1033": 1, - "1034": 1, - "1035": 1, - "1036": 1, - "1037": 1, - "1038": 1, - "1039": 1, - "104": 1, - "1040": 1, - "1041": 1, - "1042": 1, - "1043": 1, - "1044": 1, - "1045": 1, - "1046": 1, - "1047": 1, - "1048": 1, - "1049": 1, - "105": 1, - "1050": 1, - "1051": 1, - "1052": 1, - "1053": 1, - "1054": 1, - "1055": 1, - "1056": 1, - "1057": 1, - "1058": 1, - "1059": 1, - "106": 1, - "1060": 1, - "1061": 1, - "1062": 1, - "1063": 1, - "1064": 1, - "1065": 1, - "1066": 1, - "1067": 1, - "1068": 1, - "1069": 1, - "107": 1, - "1070": 1, - "1071": 1, - "1072": 1, - "1073": 1, - "1074": 1, - "1075": 1, - "1076": 1, - "1077": 1, - "1078": 1, - "1079": 1, - "108": 1, - "1080": 1, - "1081": 1, - "1082": 1, - "1083": 1, - "1084": 1, - "1085": 1, - "1086": 1, - "1087": 1, - "1088": 1, - "1089": 1, - "109": 1, - "1090": 1, - "1091": 1, - "1092": 1, - "1093": 1, - "1094": 1, - "1095": 1, - "1096": 1, - "1097": 1, - "1098": 1, - "1099": 1, - "11": 1, - "110": 1, - "1100": 1, - "1101": 1, - "1102": 1, - "1103": 1, - "1104": 1, - "1105": 1, - "1106": 1, - "1107": 1, - "1108": 1, - "1109": 1, - "111": 1, - "1110": 1, - "1111": 1, - "1112": 1, - "1113": 1, - "1114": 1, - "1115": 1, - "1116": 1, - "1117": 1, - "1118": 1, - "1119": 1, - "112": 1, - "1120": 1, - "1121": 1, - "1122": 1, - "1123": 1, - "1124": 1, - "1125": 1, - "1126": 1, - "1127": 1, - "1128": 1, - "1129": 1, - "113": 1, - "1130": 1, - "1131": 1, - "1132": 1, - "1133": 1, - "1134": 1, - "1135": 1, - "1136": 1, - "1137": 1, - "1138": 1, - "1139": 1, - "114": 1, - "1140": 1, - "1141": 1, - "1142": 1, - "1143": 1, - "1144": 1, - "1145": 1, - "1146": 1, - "1147": 1, - "1148": 1, - "1149": 1, - "115": 1, - "1150": 1, - "1151": 1, - "1152": 1, - "1153": 1, - "1154": 1, - "1155": 1, - "1156": 1, - "1157": 1, - "1158": 1, - "1159": 1, - "116": 1, - "1160": 1, - "1161": 1, - "1162": 1, - "1163": 1, - "1164": 1, - "1165": 1, - "1166": 1, - "1167": 1, - "1168": 1, - "1169": 1, - "117": 1, - "1170": 1, - "1171": 1, - "1172": 1, - "1173": 1, - "1174": 1, - "1175": 1, - "1176": 1, - "1177": 1, - "1178": 1, - "1179": 1, - "118": 1, - "1180": 1, - "1181": 1, - "1182": 1, - "1183": 1, - "1184": 1, - "1185": 1, - "1186": 1, - "1187": 1, - "1188": 1, - "1189": 1, - "119": 1, - "1190": 1, - "1191": 1, - "1192": 1, - "1193": 1, - "1194": 1, - "1195": 1, - "1196": 1, - "1197": 1, - "1198": 1, - "1199": 1, - "12": 1, - "120": 1, - "1200": 1, - "1201": 1, - "1202": 1, - "1203": 1, - "1204": 1, - "1205": 1, - "1206": 1, - "1207": 1, - "1208": 1, - "1209": 1, - "121": 1, - "1210": 1, - "1211": 1, - "1212": 1, - "1213": 1, - "1214": 1, - "1215": 1, - "1216": 1, - "1217": 1, - "1218": 1, - "1219": 1, - "122": 1, - "1220": 1, - "1221": 1, - "1222": 1, - "1223": 1, - "1224": 1, - "1225": 1, - "1226": 1, - "1227": 1, - "1228": 1, - "1229": 1, - "123": 1, - "1230": 1, - "1231": 1, - "1232": 1, - "1233": 1, - "1234": 1, - "1235": 1, - "1236": 1, - "1237": 1, - "1238": 1, - "1239": 1, - "124": 1, - "1240": 1, - "1241": 1, - "1242": 1, - "1243": 1, - "1244": 1, - "1245": 1, - "1246": 1, - "1247": 1, - "1248": 1, - "1249": 1, - "125": 1, - "1250": 1, - "1251": 1, - "1252": 1, - "1253": 1, - "1254": 1, - "1255": 1, - "1256": 1, - "1257": 1, - "1258": 1, - "1259": 1, - "126": 1, - "1260": 1, - "1261": 1, - "1262": 1, - "1263": 1, - "1264": 1, - "1265": 1, - "1266": 1, - "1267": 1, - "1268": 1, - "1269": 1, - "127": 1, - "1270": 1, - "1271": 1, - "1272": 1, - "1273": 1, - "1274": 1, - "1275": 1, - "1276": 1, - "1277": 1, - "1278": 1, - "1279": 1, - "128": 1, - "1280": 1, - "1281": 1, - "1282": 1, - "1283": 1, - "1284": 1, - "1285": 1, - "1286": 1, - "1287": 1, - "1288": 1, - "1289": 1, - "129": 1, - "1290": 1, - "1291": 1, - "1292": 1, - "1293": 1, - "1294": 1, - "1295": 1, - "1296": 1, - "1297": 1, - "1298": 1, - "1299": 1, - "13": 1, - "130": 1, - "1300": 1, - "1301": 1, - "1302": 1, - "1303": 1, - "1304": 1, - "1305": 1, - "1306": 1, - "1307": 1, - "1308": 1, - "1309": 1, - "131": 1, - "1310": 1, - "1311": 1, - "1312": 1, - "1313": 1, - "1314": 1, - "1315": 1, - "1316": 1, - "1317": 1, - "1318": 1, - "1319": 1, - "132": 1, - "1320": 1, - "1321": 1, - "1322": 1, - "1323": 1, - "1324": 1, - "1325": 1, - "1326": 1, - "1327": 1, - "1328": 1, - "1329": 1, - "133": 1, - "1330": 1, - "1331": 1, - "1332": 1, - "1333": 1, - "1334": 1, - "1335": 1, - "1336": 1, - "1337": 1, - "1338": 1, - "1339": 1, - "134": 1, - "1340": 1, - "1341": 1, - "1342": 1, - "1343": 1, - "1344": 1, - "1345": 1, - "1346": 1, - "1347": 1, - "1348": 1, - "1349": 1, - "135": 1, - "1350": 1, - "1351": 1, - "1352": 1, - "1353": 1, - "1354": 1, - "1355": 1, - "1356": 1, - "1357": 1, - "1358": 1, - "1359": 1, - "136": 1, - "1360": 1, - "1361": 1, - "1362": 1, - "1363": 1, - "1364": 1, - "1365": 1, - "1366": 1, - "1367": 1, - "1368": 1, - "1369": 1, - "137": 1, - "1370": 1, - "1371": 1, - "1372": 1, - "1373": 1, - "1374": 1, - "1375": 1, - "1376": 1, - "1377": 1, - "1378": 1, - "1379": 1, - "138": 1, - "1380": 1, - "1381": 1, - "1382": 1, - "1383": 1, - "1384": 1, - "1385": 1, - "1386": 1, - "1387": 1, - "1388": 1, - "1389": 1, - "139": 1, - "1390": 1, - "1391": 1, - "1392": 1, - "1393": 1, - "1394": 1, - "1395": 1, - "1396": 1, - "1397": 1, - "1398": 1, - "1399": 1, - "14": 1, - "140": 1, - "1400": 1, - "1401": 1, - "1402": 1, - "1403": 1, - "1404": 1, - "1405": 1, - "1406": 1, - "1407": 1, - "1408": 1, - "1409": 1, - "141": 1, - "1410": 1, - "1411": 1, - "1412": 1, - "1413": 1, - "1414": 1, - "1415": 1, - "1416": 1, - "1417": 1, - "1418": 1, - "1419": 1, - "142": 1, - "1420": 1, - "1421": 1, - "1422": 1, - "1423": 1, - "1424": 1, - "1425": 1, - "1426": 1, - "1427": 1, - "1428": 1, - "1429": 1, - "143": 1, - "1430": 1, - "1431": 1, - "1432": 1, - "1433": 1, - "1434": 1, - "1435": 1, - "1436": 1, - "1437": 1, - "1438": 1, - "1439": 1, - "144": 1, - "1440": 1, - "1441": 1, - "1442": 1, - "1443": 1, - "1444": 1, - "1445": 1, - "1446": 1, - "1447": 1, - "1448": 1, - "1449": 1, - "145": 1, - "1450": 1, - "1451": 1, - "1452": 1, - "1453": 1, - "1454": 1, - "1455": 1, - "1456": 1, - "1457": 1, - "1458": 1, - "1459": 1, - "146": 1, - "1460": 1, - "1461": 1, - "1462": 1, - "1463": 1, - "1464": 1, - "1465": 1, - "1466": 1, - "1467": 1, - "1468": 1, - "1469": 1, - "147": 1, - "1470": 1, - "1471": 1, - "1472": 1, - "1473": 1, - "1474": 1, - "1475": 1, - "1476": 1, - "1477": 1, - "1478": 1, - "1479": 1, - "148": 1, - "1480": 1, - "1481": 1, - "1482": 1, - "1483": 1, - "1484": 1, - "1485": 1, - "1486": 1, - "1487": 1, - "1488": 1, - "1489": 1, - "149": 1, - "1490": 1, - "1491": 1, - "1492": 1, - "1493": 1, - "1494": 1, - "1495": 1, - "1496": 1, - "1497": 1, - "1498": 1, - "1499": 1, - "15": 1, - "150": 1, - "1500": 1, - "1501": 1, - "1502": 1, - "1503": 1, - "1504": 1, - "1505": 1, - "1506": 1, - "1507": 1, - "1508": 1, - "1509": 1, - "151": 1, - "1510": 1, - "1511": 1, - "1512": 1, - "1513": 1, - "1514": 1, - "1515": 1, - "1516": 1, - "1517": 1, - "1518": 1, - "1519": 1, - "152": 1, - "1520": 1, - "1521": 1, - "1522": 1, - "1523": 1, - "1524": 1, - "1525": 1, - "1526": 1, - "1527": 1, - "1528": 1, - "1529": 1, - "153": 1, - "1530": 1, - "1531": 1, - "1532": 1, - "1533": 1, - "1534": 1, - "1535": 1, - "1536": 1, - "1537": 1, - "1538": 1, - "1539": 1, - "154": 1, - "1540": 1, - "1541": 1, - "1542": 1, - "1543": 1, - "1544": 1, - "1545": 1, - "1546": 1, - "1547": 1, - "1548": 1, - "1549": 1, - "155": 1, - "1550": 1, - "1551": 1, - "1552": 1, - "1553": 1, - "1554": 1, - "1555": 1, - "1556": 1, - "1557": 1, - "1558": 1, - "1559": 1, - "156": 1, - "1560": 1, - "1561": 1, - "1562": 1, - "1563": 1, - "1564": 1, - "1565": 1, - "1566": 1, - "1567": 1, - "1568": 1, - "1569": 1, - "157": 1, - "1570": 1, - "1571": 1, - "1572": 1, - "1573": 1, - "1574": 1, - "1575": 1, - "1576": 1, - "1577": 1, - "1578": 1, - "1579": 1, - "158": 1, - "1580": 1, - "1581": 1, - "1582": 1, - "1583": 1, - "1584": 1, - "1585": 1, - "1586": 1, - "1587": 1, - "1588": 1, - "1589": 1, - "159": 1, - "1590": 1, - "1591": 1, - "1592": 1, - "1593": 1, - "1594": 1, - "1595": 1, - "1596": 1, - "1597": 1, - "1598": 1, - "1599": 1, - "16": 1, - "160": 1, - "1600": 1, - "1601": 1, - "1602": 1, - "1603": 1, - "1604": 1, - "1605": 1, - "1606": 1, - "1607": 1, - "1608": 1, - "1609": 1, - "161": 1, - "1610": 1, - "1611": 1, - "1612": 1, - "1613": 1, - "1614": 1, - "1615": 1, - "1616": 1, - "1617": 1, - "1618": 1, - "1619": 1, - "162": 1, - "1620": 1, - "1621": 1, - "1622": 1, - "1623": 1, - "1624": 1, - "1625": 1, - "1626": 1, - "1627": 1, - "1628": 1, - "1629": 1, - "163": 1, - "1630": 1, - "1631": 1, - "1632": 1, - "1633": 1, - "1634": 1, - "1635": 1, - "1636": 1, - "1637": 1, - "1638": 1, - "1639": 1, - "164": 1, - "1640": 1, - "1641": 1, - "1642": 1, - "1643": 1, - "1644": 1, - "1645": 1, - "1646": 1, - "1647": 1, - "1648": 1, - "1649": 1, - "165": 1, - "1650": 1, - "1651": 1, - "1652": 1, - "1653": 1, - "1654": 1, - "1655": 1, - "1656": 1, - "1657": 1, - "1658": 1, - "1659": 1, - "166": 1, - "1660": 1, - "1661": 1, - "1662": 1, - "1663": 1, - "1664": 1, - "1665": 1, - "1666": 1, - "1667": 1, - "1668": 1, - "1669": 1, - "167": 1, - "1670": 1, - "1671": 1, - "1672": 1, - "1673": 1, - "1674": 1, - "1675": 1, - "1676": 1, - "1677": 1, - "1678": 1, - "1679": 1, - "168": 1, - "1680": 1, - "1681": 1, - "1682": 1, - "1683": 1, - "1684": 1, - "1685": 1, - "1686": 1, - "1687": 1, - "1688": 1, - "1689": 1, - "169": 1, - "1690": 1, - "1691": 1, - "1692": 1, - "1693": 1, - "1694": 1, - "1695": 1, - "1696": 1, - "1697": 1, - "1698": 1, - "1699": 1, - "17": 1, - "170": 1, - "1700": 1, - "1701": 1, - "1702": 1, - "1703": 1, - "1704": 1, - "1705": 1, - "1706": 1, - "1707": 1, - "1708": 1, - "1709": 1, - "171": 1, - "1710": 1, - "1711": 1, - "1712": 1, - "1713": 1, - "1714": 1, - "1715": 1, - "1716": 1, - "1717": 1, - "1718": 1, - "1719": 1, - "172": 1, - "1720": 1, - "1721": 1, - "1722": 1, - "1723": 1, - "1724": 1, - "1725": 1, - "1726": 1, - "1727": 1, - "1728": 1, - "1729": 1, - "173": 1, - "1730": 1, - "1731": 1, - "1732": 1, - "1733": 1, - "1734": 1, - "1735": 1, - "1736": 1, - "1737": 1, - "1738": 1, - "1739": 1, - "174": 1, - "1740": 1, - "1741": 1, - "1742": 1, - "1743": 1, - "1744": 1, - "1745": 1, - "1746": 1, - "1747": 1, - "1748": 1, - "1749": 1, - "175": 1, - "1750": 1, - "1751": 1, - "1752": 1, - "1753": 1, - "1754": 1, - "1755": 1, - "1756": 1, - "1757": 1, - "1758": 1, - "1759": 1, - "176": 1, - "1760": 1, - "1761": 1, - "1762": 1, - "1763": 1, - "1764": 1, - "1765": 1, - "1766": 1, - "1767": 1, - "1768": 1, - "1769": 1, - "177": 1, - "1770": 1, - "1771": 1, - "1772": 1, - "1773": 1, - "1774": 1, - "1775": 1, - "1776": 1, - "1777": 1, - "1778": 1, - "1779": 1, - "178": 1, - "1780": 1, - "1781": 1, - "1782": 1, - "1783": 1, - "1784": 1, - "1785": 1, - "1786": 1, - "1787": 1, - "1788": 1, - "1789": 1, - "179": 1, - "1790": 1, - "1791": 1, - "1792": 1, - "1793": 1, - "1794": 1, - "1795": 1, - "1796": 1, - "1797": 1, - "1798": 1, - "1799": 1, - "18": 1, - "180": 1, - "1800": 1, - "1801": 1, - "1802": 1, - "1803": 1, - "1804": 1, - "1805": 1, - "1806": 1, - "1807": 1, - "1808": 1, - "1809": 1, - "181": 1, - "1810": 1, - "1811": 1, - "1812": 1, - "1813": 1, - "1814": 1, - "1815": 1, - "1816": 1, - "1817": 1, - "1818": 1, - "1819": 1, - "182": 1, - "1820": 1, - "1821": 1, - "1822": 1, - "1823": 1, - "1824": 1, - "1825": 1, - "1826": 1, - "1827": 1, - "1828": 1, - "1829": 1, - "183": 1, - "1830": 1, - "1831": 1, - "1832": 1, - "1833": 1, - "1834": 1, - "1835": 1, - "1836": 1, - "1837": 1, - "1838": 1, - "1839": 1, - "184": 1, - "1840": 1, - "1841": 1, - "1842": 1, - "1843": 1, - "1844": 1, - "1845": 1, - "1846": 1, - "1847": 1, - "1848": 1, - "1849": 1, - "185": 1, - "1850": 1, - "1851": 1, - "1852": 1, - "1853": 1, - "1854": 1, - "1855": 1, - "1856": 1, - "1857": 1, - "1858": 1, - "1859": 1, - "186": 1, - "1860": 1, - "1861": 1, - "1862": 1, - "1863": 1, - "1864": 1, - "1865": 1, - "1866": 1, - "1867": 1, - "1868": 1, - "1869": 1, - "187": 1, - "1870": 1, - "1871": 1, - "1872": 1, - "1873": 1, - "1874": 1, - "1875": 1, - "1876": 1, - "1877": 1, - "1878": 1, - "1879": 1, - "188": 1, - "1880": 1, - "1881": 1, - "1882": 1, - "1883": 1, - "1884": 1, - "1885": 1, - "1886": 1, - "1887": 1, - "1888": 1, - "1889": 1, - "189": 1, - "1890": 1, - "1891": 1, - "1892": 1, - "1893": 1, - "1894": 1, - "1895": 1, - "1896": 1, - "1897": 1, - "1898": 1, - "1899": 1, - "19": 1, - "190": 1, - "1900": 1, - "1901": 1, - "1902": 1, - "1903": 1, - "1904": 1, - "1905": 1, - "1906": 1, - "1907": 1, - "1908": 1, - "1909": 1, - "191": 1, - "1910": 1, - "1911": 1, - "1912": 1, - "1913": 1, - "1914": 1, - "1915": 1, - "1916": 1, - "1917": 1, - "1918": 1, - "1919": 1, - "192": 1, - "1920": 1, - "1921": 1, - "1922": 1, - "1923": 1, - "1924": 1, - "1925": 1, - "1926": 1, - "1927": 1, - "1928": 1, - "1929": 1, - "193": 1, - "1930": 1, - "1931": 1, - "1932": 1, - "1933": 1, - "1934": 1, - "1935": 1, - "1936": 1, - "1937": 1, - "1938": 1, - "1939": 1, - "194": 1, - "1940": 1, - "1941": 1, - "1942": 1, - "1943": 1, - "1944": 1, - "1945": 1, - "1946": 1, - "1947": 1, - "1948": 1, - "1949": 1, - "195": 1, - "1950": 1, - "1951": 1, - "1952": 1, - "1953": 1, - "1954": 1, - "1955": 1, - "1956": 1, - "1957": 1, - "1958": 1, - "1959": 1, - "196": 1, - "1960": 1, - "1961": 1, - "1962": 1, - "1963": 1, - "1964": 1, - "1965": 1, - "1966": 1, - "1967": 1, - "1968": 1, - "1969": 1, - "197": 1, - "1970": 1, - "1971": 1, - "1972": 1, - "1973": 1, - "1974": 1, - "1975": 1, - "1976": 1, - "1977": 1, - "1978": 1, - "1979": 1, - "198": 1, - "1980": 1, - "1981": 1, - "1982": 1, - "1983": 1, - "1984": 1, - "1985": 1, - "1986": 1, - "1987": 1, - "1988": 1, - "1989": 1, - "199": 1, - "1990": 1, - "1991": 1, - "1992": 1, - "1993": 1, - "1994": 1, - "1995": 1, - "1996": 1, - "1997": 1, - "1998": 1, - "1999": 1, - "2": 1, - "20": 1, - "200": 1, - "2000": 1, - "2001": 1, - "2002": 1, - "2003": 1, - "2004": 1, - "2005": 1, - "2006": 1, - "2007": 1, - "2008": 1, - "2009": 1, - "201": 1, - "2010": 1, - "2011": 1, - "2012": 1, - "2013": 1, - "2014": 1, - "2015": 1, - "2016": 1, - "2017": 1, - "2018": 1, - "2019": 1, - "202": 1, - "2020": 1, - "2021": 1, - "2022": 1, - "2023": 1, - "2024": 1, - "2025": 1, - "2026": 1, - "2027": 1, - "2028": 1, - "2029": 1, - "203": 1, - "2030": 1, - "2031": 1, - "2032": 1, - "2033": 1, - "2034": 1, - "2035": 1, - "2036": 1, - "2037": 1, - "2038": 1, - "2039": 1, - "204": 1, - "2040": 1, - "2041": 1, - "2042": 1, - "2043": 1, - "2044": 1, - "2045": 1, - "2046": 1, - "2047": 1, - "2048": 1, - "2049": 1, - "205": 1, - "2050": 1, - "2051": 1, - "2052": 1, - "2053": 1, - "2054": 1, - "2055": 1, - "2056": 1, - "2057": 1, - "2058": 1, - "2059": 1, - "206": 1, - "2060": 1, - "2061": 1, - "2062": 1, - "2063": 1, - "2064": 1, - "2065": 1, - "2066": 1, - "2067": 1, - "2068": 1, - "2069": 1, - "207": 1, - "2070": 1, - "2071": 1, - "2072": 1, - "2073": 1, - "2074": 1, - "2075": 1, - "2076": 1, - "2077": 1, - "2078": 1, - "2079": 1, - "208": 1, - "2080": 1, - "2081": 1, - "2082": 1, - "2083": 1, - "2084": 1, - "2085": 1, - "2086": 1, - "2087": 1, - "2088": 1, - "2089": 1, - "209": 1, - "2090": 1, - "2091": 1, - "2092": 1, - "2093": 1, - "2094": 1, - "2095": 1, - "2096": 1, - "2097": 1, - "2098": 1, - "2099": 1, - "21": 1, - "210": 1, - "2100": 1, - "2101": 1, - "2102": 1, - "2103": 1, - "2104": 1, - "2105": 1, - "2106": 1, - "2107": 1, - "2108": 1, - "2109": 1, - "211": 1, - "2110": 1, - "2111": 1, - "2112": 1, - "2113": 1, - "2114": 1, - "2115": 1, - "2116": 1, - "2117": 1, - "2118": 1, - "2119": 1, - "212": 1, - "2120": 1, - "2121": 1, - "2122": 1, - "2123": 1, - "2124": 1, - "2125": 1, - "2126": 1, - "2127": 1, - "2128": 1, - "2129": 1, - "213": 1, - "2130": 1, - "2131": 1, - "2132": 1, - "2133": 1, - "2134": 1, - "2135": 1, - "2136": 1, - "2137": 1, - "2138": 1, - "2139": 1, - "214": 1, - "2140": 1, - "2141": 1, - "2142": 1, - "2143": 1, - "2144": 1, - "2145": 1, - "2146": 1, - "2147": 1, - "2148": 1, - "2149": 1, - "215": 1, - "2150": 1, - "2151": 1, - "2152": 1, - "2153": 1, - "2154": 1, - "2155": 1, - "2156": 1, - "2157": 1, - "2158": 1, - "2159": 1, - "216": 1, - "2160": 1, - "2161": 1, - "2162": 1, - "2163": 1, - "2164": 1, - "2165": 1, - "2166": 1, - "2167": 1, - "2168": 1, - "2169": 1, - "217": 1, - "2170": 1, - "2171": 1, - "2172": 1, - "2173": 1, - "2174": 1, - "2175": 1, - "2176": 1, - "2177": 1, - "2178": 1, - "2179": 1, - "218": 1, - "2180": 1, - "2181": 1, - "2182": 1, - "2183": 1, - "2184": 1, - "2185": 1, - "2186": 1, - "2187": 1, - "2188": 1, - "2189": 1, - "219": 1, - "2190": 1, - "2191": 1, - "2192": 1, - "2193": 1, - "2194": 1, - "2195": 1, - "2196": 1, - "2197": 1, - "2198": 1, - "2199": 1, - "22": 1, - "220": 1, - "2200": 1, - "2201": 1, - "2202": 1, - "2203": 1, - "2204": 1, - "2205": 1, - "2206": 1, - "2207": 1, - "2208": 1, - "2209": 1, - "221": 1, - "2210": 1, - "2211": 1, - "2212": 1, - "2213": 1, - "2214": 1, - "2215": 1, - "2216": 1, - "2217": 1, - "2218": 1, - "2219": 1, - "222": 1, - "2220": 1, - "2221": 1, - "2222": 1, - "2223": 1, - "2224": 1, - "2225": 1, - "2226": 1, - "2227": 1, - "2228": 1, - "2229": 1, - "223": 1, - "2230": 1, - "2231": 1, - "2232": 1, - "2233": 1, - "2234": 1, - "2235": 1, - "2236": 1, - "2237": 1, - "2238": 1, - "2239": 1, - "224": 1, - "2240": 1, - "2241": 1, - "2242": 1, - "2243": 1, - "2244": 1, - "2245": 1, - "2246": 1, - "2247": 1, - "2248": 1, - "2249": 1, - "225": 1, - "2250": 1, - "2251": 1, - "2252": 1, - "2253": 1, - "2254": 1, - "2255": 1, - "2256": 1, - "2257": 1, - "2258": 1, - "2259": 1, - "226": 1, - "2260": 1, - "2261": 1, - "2262": 1, - "2263": 1, - "2264": 1, - "2265": 1, - "2266": 1, - "2267": 1, - "2268": 1, - "2269": 1, - "227": 1, - "2270": 1, - "2271": 1, - "2272": 1, - "2273": 1, - "2274": 1, - "2275": 1, - "2276": 1, - "2277": 1, - "2278": 1, - "2279": 1, - "228": 1, - "2280": 1, - "2281": 1, - "2282": 1, - "2283": 1, - "2284": 1, - "2285": 1, - "2286": 1, - "2287": 1, - "2288": 1, - "2289": 1, - "229": 1, - "2290": 1, - "2291": 1, - "2292": 1, - "2293": 1, - "2294": 1, - "2295": 1, - "2296": 1, - "2297": 1, - "2298": 1, - "2299": 1, - "23": 1, - "230": 1, - "2300": 1, - "2301": 1, - "2302": 1, - "2303": 1, - "2304": 1, - "2305": 1, - "2306": 1, - "2307": 1, - "2308": 1, - "2309": 1, - "231": 1, - "2310": 1, - "2311": 1, - "2312": 1, - "2313": 1, - "2314": 1, - "2315": 1, - "2316": 1, - "2317": 1, - "2318": 1, - "2319": 1, - "232": 1, - "2320": 1, - "2321": 1, - "2322": 1, - "2323": 1, - "2324": 1, - "2325": 1, - "2326": 1, - "2327": 1, - "2328": 1, - "2329": 1, - "233": 1, - "2330": 1, - "2331": 1, - "2332": 1, - "2333": 1, - "2334": 1, - "2335": 1, - "2336": 1, - "2337": 1, - "2338": 1, - "2339": 1, - "234": 1, - "2340": 1, - "2341": 1, - "2342": 1, - "2343": 1, - "2344": 1, - "2345": 1, - "2346": 1, - "2347": 1, - "2348": 1, - "2349": 1, - "235": 1, - "2350": 1, - "2351": 1, - "2352": 1, - "2353": 1, - "2354": 1, - "2355": 1, - "2356": 1, - "2357": 1, - "2358": 1, - "2359": 1, - "236": 1, - "2360": 1, - "2361": 1, - "2362": 1, - "2363": 1, - "2364": 1, - "2365": 1, - "2366": 1, - "2367": 1, - "2368": 1, - "2369": 1, - "237": 1, - "2370": 1, - "2371": 1, - "2372": 1, - "2373": 1, - "2374": 1, - "2375": 1, - "2376": 1, - "2377": 1, - "2378": 1, - "2379": 1, - "238": 1, - "2380": 1, - "2381": 1, - "2382": 1, - "2383": 1, - "2384": 1, - "2385": 1, - "2386": 1, - "2387": 1, - "2388": 1, - "2389": 1, - "239": 1, - "2390": 1, - "2391": 1, - "2392": 1, - "2393": 1, - "2394": 1, - "2395": 1, - "2396": 1, - "2397": 1, - "2398": 1, - "2399": 1, - "24": 1, - "240": 1, - "2400": 1, - "2401": 1, - "2402": 1, - "2403": 1, - "2404": 1, - "2405": 1, - "2406": 1, - "2407": 1, - "2408": 1, - "2409": 1, - "241": 1, - "2410": 1, - "2411": 1, - "2412": 1, - "2413": 1, - "2414": 1, - "2415": 1, - "2416": 1, - "2417": 1, - "2418": 1, - "2419": 1, - "242": 1, - "2420": 1, - "2421": 1, - "2422": 1, - "2423": 1, - "2424": 1, - "2425": 1, - "2426": 1, - "2427": 1, - "2428": 1, - "2429": 1, - "243": 1, - "2430": 1, - "2431": 1, - "2432": 1, - "2433": 1, - "2434": 1, - "2435": 1, - "2436": 1, - "2437": 1, - "2438": 1, - "2439": 1, - "244": 1, - "2440": 1, - "2441": 1, - "2442": 1, - "2443": 1, - "2444": 1, - "2445": 1, - "2446": 1, - "2447": 1, - "2448": 1, - "2449": 1, - "245": 1, - "2450": 1, - "2451": 1, - "2452": 1, - "2453": 1, - "2454": 1, - "2455": 1, - "2456": 1, - "2457": 1, - "2458": 1, - "2459": 1, - "246": 1, - "2460": 1, - "2461": 1, - "2462": 1, - "2463": 1, - "2464": 1, - "2465": 1, - "2466": 1, - "2467": 1, - "2468": 1, - "2469": 1, - "247": 1, - "2470": 1, - "2471": 1, - "2472": 1, - "2473": 1, - "2474": 1, - "2475": 1, - "2476": 1, - "2477": 1, - "2478": 1, - "2479": 1, - "248": 1, - "2480": 1, - "2481": 1, - "2482": 1, - "2483": 1, - "2484": 1, - "2485": 1, - "2486": 1, - "2487": 1, - "2488": 1, - "2489": 1, - "249": 1, - "2490": 1, - "2491": 1, - "2492": 1, - "2493": 1, - "2494": 1, - "2495": 1, - "2496": 1, - "2497": 1, - "2498": 1, - "2499": 1, - "25": 1, - "250": 1, - "2500": 1, - "2501": 1, - "2502": 1, - "2503": 1, - "2504": 1, - "2505": 1, - "2506": 1, - "2507": 1, - "2508": 1, - "2509": 1, - "251": 1, - "2510": 1, - "2511": 1, - "2512": 1, - "2513": 1, - "2514": 1, - "2515": 1, - "2516": 1, - "2517": 1, - "2518": 1, - "2519": 1, - "252": 1, - "2520": 1, - "2521": 1, - "2522": 1, - "2523": 1, - "2524": 1, - "2525": 1, - "2526": 1, - "2527": 1, - "2528": 1, - "2529": 1, - "253": 1, - "2530": 1, - "2531": 1, - "2532": 1, - "2533": 1, - "2534": 1, - "2535": 1, - "2536": 1, - "2537": 1, - "2538": 1, - "2539": 1, - "254": 1, - "2540": 1, - "2541": 1, - "2542": 1, - "2543": 1, - "2544": 1, - "2545": 1, - "2546": 1, - "2547": 1, - "2548": 1, - "2549": 1, - "255": 1, - "2550": 1, - "2551": 1, - "2552": 1, - "2553": 1, - "2554": 1, - "2555": 1, - "2556": 1, - "2557": 1, - "2558": 1, - "2559": 1, - "256": 1, - "2560": 1, - "2561": 1, - "2562": 1, - "2563": 1, - "2564": 1, - "2565": 1, - "2566": 1, - "2567": 1, - "2568": 1, - "2569": 1, - "257": 1, - "2570": 1, - "2571": 1, - "2572": 1, - "2573": 1, - "2574": 1, - "2575": 1, - "2576": 1, - "2577": 1, - "2578": 1, - "2579": 1, - "258": 1, - "2580": 1, - "2581": 1, - "2582": 1, - "2583": 1, - "2584": 1, - "2585": 1, - "2586": 1, - "2587": 1, - "2588": 1, - "2589": 1, - "259": 1, - "2590": 1, - "2591": 1, - "2592": 1, - "2593": 1, - "2594": 1, - "2595": 1, - "2596": 1, - "2597": 1, - "2598": 1, - "2599": 1, - "26": 1, - "260": 1, - "2600": 1, - "2601": 1, - "2602": 1, - "2603": 1, - "2604": 1, - "2605": 1, - "2606": 1, - "2607": 1, - "2608": 1, - "2609": 1, - "261": 1, - "2610": 1, - "2611": 1, - "2612": 1, - "2613": 1, - "2614": 1, - "2615": 1, - "2616": 1, - "2617": 1, - "2618": 1, - "2619": 1, - "262": 1, - "2620": 1, - "2621": 1, - "2622": 1, - "2623": 1, - "2624": 1, - "2625": 1, - "2626": 1, - "2627": 1, - "2628": 1, - "2629": 1, - "263": 1, - "2630": 1, - "2631": 1, - "2632": 1, - "2633": 1, - "2634": 1, - "2635": 1, - "2636": 1, - "2637": 1, - "2638": 1, - "2639": 1, - "264": 1, - "2640": 1, - "2641": 1, - "2642": 1, - "2643": 1, - "2644": 1, - "2645": 1, - "2646": 1, - "2647": 1, - "2648": 1, - "2649": 1, - "265": 1, - "2650": 1, - "2651": 1, - "2652": 1, - "2653": 1, - "2654": 1, - "2655": 1, - "2656": 1, - "2657": 1, - "2658": 1, - "2659": 1, - "266": 1, - "2660": 1, - "2661": 1, - "2662": 1, - "2663": 1, - "2664": 1, - "2665": 1, - "2666": 1, - "2667": 1, - "2668": 1, - "2669": 1, - "267": 1, - "2670": 1, - "2671": 1, - "2672": 1, - "2673": 1, - "2674": 1, - "2675": 1, - "2676": 1, - "2677": 1, - "2678": 1, - "2679": 1, - "268": 1, - "2680": 1, - "2681": 1, - "2682": 1, - "2683": 1, - "2684": 1, - "2685": 1, - "2686": 1, - "2687": 1, - "2688": 1, - "2689": 1, - "269": 1, - "2690": 1, - "2691": 1, - "2692": 1, - "2693": 1, - "2694": 1, - "2695": 1, - "2696": 1, - "2697": 1, - "2698": 1, - "2699": 1, - "27": 1, - "270": 1, - "2700": 1, - "2701": 1, - "2702": 1, - "2703": 1, - "2704": 1, - "2705": 1, - "2706": 1, - "2707": 1, - "2708": 1, - "2709": 1, - "271": 1, - "2710": 1, - "2711": 1, - "2712": 1, - "2713": 1, - "2714": 1, - "2715": 1, - "2716": 1, - "2717": 1, - "2718": 1, - "2719": 1, - "272": 1, - "2720": 1, - "2721": 1, - "2722": 1, - "2723": 1, - "2724": 1, - "2725": 1, - "2726": 1, - "2727": 1, - "2728": 1, - "2729": 1, - "273": 1, - "2730": 1, - "2731": 1, - "2732": 1, - "2733": 1, - "2734": 1, - "2735": 1, - "2736": 1, - "2737": 1, - "2738": 1, - "2739": 1, - "274": 1, - "2740": 1, - "2741": 1, - "2742": 1, - "2743": 1, - "2744": 1, - "2745": 1, - "2746": 1, - "2747": 1, - "2748": 1, - "2749": 1, - "275": 1, - "2750": 1, - "2751": 1, - "2752": 1, - "2753": 1, - "2754": 1, - "2755": 1, - "2756": 1, - "2757": 1, - "2758": 1, - "2759": 1, - "276": 1, - "2760": 1, - "2761": 1, - "2762": 1, - "2763": 1, - "2764": 1, - "2765": 1, - "2766": 1, - "2767": 1, - "2768": 1, - "2769": 1, - "277": 1, - "2770": 1, - "2771": 1, - "2772": 1, - "2773": 1, - "2774": 1, - "2775": 1, - "2776": 1, - "2777": 1, - "2778": 1, - "2779": 1, - "278": 1, - "2780": 1, - "2781": 1, - "2782": 1, - "2783": 1, - "2784": 1, - "2785": 1, - "2786": 1, - "2787": 1, - "2788": 1, - "2789": 1, - "279": 1, - "2790": 1, - "2791": 1, - "2792": 1, - "2793": 1, - "2794": 1, - "2795": 1, - "2796": 1, - "2797": 1, - "2798": 1, - "2799": 1, - "28": 1, - "280": 1, - "2800": 1, - "2801": 1, - "2802": 1, - "2803": 1, - "2804": 1, - "2805": 1, - "2806": 1, - "2807": 1, - "2808": 1, - "2809": 1, - "281": 1, - "2810": 1, - "2811": 1, - "2812": 1, - "2813": 1, - "2814": 1, - "2815": 1, - "2816": 1, - "2817": 1, - "2818": 1, - "2819": 1, - "282": 1, - "2820": 1, - "2821": 1, - "2822": 1, - "2823": 1, - "2824": 1, - "2825": 1, - "2826": 1, - "2827": 1, - "2828": 1, - "2829": 1, - "283": 1, - "2830": 1, - "2831": 1, - "2832": 1, - "2833": 1, - "2834": 1, - "2835": 1, - "2836": 1, - "2837": 1, - "2838": 1, - "2839": 1, - "284": 1, - "2840": 1, - "2841": 1, - "2842": 1, - "2843": 1, - "2844": 1, - "2845": 1, - "2846": 1, - "2847": 1, - "2848": 1, - "2849": 1, - "285": 1, - "2850": 1, - "2851": 1, - "2852": 1, - "2853": 1, - "2854": 1, - "2855": 1, - "2856": 1, - "2857": 1, - "2858": 1, - "2859": 1, - "286": 1, - "2860": 1, - "2861": 1, - "2862": 1, - "2863": 1, - "2864": 1, - "2865": 1, - "2866": 1, - "2867": 1, - "2868": 1, - "2869": 1, - "287": 1, - "2870": 1, - "2871": 1, - "2872": 1, - "2873": 1, - "2874": 1, - "2875": 1, - "2876": 1, - "2877": 1, - "2878": 1, - "2879": 1, - "288": 1, - "2880": 1, - "2881": 1, - "2882": 1, - "2883": 1, - "2884": 1, - "2885": 1, - "2886": 1, - "2887": 1, - "2888": 1, - "2889": 1, - "289": 1, - "2890": 1, - "2891": 1, - "2892": 1, - "2893": 1, - "2894": 1, - "2895": 1, - "2896": 1, - "2897": 1, - "2898": 1, - "2899": 1, - "29": 1, - "290": 1, - "2900": 1, - "2901": 1, - "2902": 1, - "2903": 1, - "2904": 1, - "2905": 1, - "2906": 1, - "2907": 1, - "2908": 1, - "2909": 1, - "291": 1, - "2910": 1, - "2911": 1, - "2912": 1, - "2913": 1, - "2914": 1, - "2915": 1, - "2916": 1, - "2917": 1, - "2918": 1, - "2919": 1, - "292": 1, - "2920": 1, - "2921": 1, - "2922": 1, - "2923": 1, - "2924": 1, - "2925": 1, - "2926": 1, - "2927": 1, - "2928": 1, - "2929": 1, - "293": 1, - "2930": 1, - "2931": 1, - "2932": 1, - "2933": 1, - "2934": 1, - "2935": 1, - "2936": 1, - "2937": 1, - "2938": 1, - "2939": 1, - "294": 1, - "2940": 1, - "2941": 1, - "2942": 1, - "2943": 1, - "2944": 1, - "2945": 1, - "2946": 1, - "2947": 1, - "2948": 1, - "2949": 1, - "295": 1, - "2950": 1, - "2951": 1, - "2952": 1, - "2953": 1, - "2954": 1, - "2955": 1, - "2956": 1, - "2957": 1, - "2958": 1, - "2959": 1, - "296": 1, - "2960": 1, - "2961": 1, - "2962": 1, - "2963": 1, - "2964": 1, - "2965": 1, - "2966": 1, - "2967": 1, - "2968": 1, - "2969": 1, - "297": 1, - "2970": 1, - "2971": 1, - "2972": 1, - "2973": 1, - "2974": 1, - "2975": 1, - "2976": 1, - "2977": 1, - "2978": 1, - "2979": 1, - "298": 1, - "2980": 1, - "2981": 1, - "2982": 1, - "2983": 1, - "2984": 1, - "2985": 1, - "2986": 1, - "2987": 1, - "2988": 1, - "2989": 1, - "299": 1, - "2990": 1, - "2991": 1, - "2992": 1, - "2993": 1, - "2994": 1, - "2995": 1, - "2996": 1, - "2997": 1, - "2998": 1, - "2999": 1, - "3": 1, - "30": 1, - "300": 1, - "3000": 1, - "3001": 1, - "3002": 1, - "3003": 1, - "3004": 1, - "3005": 1, - "3006": 1, - "3007": 1, - "3008": 1, - "3009": 1, - "301": 1, - "3010": 1, - "3011": 1, - "3012": 1, - "3013": 1, - "3014": 1, - "3015": 1, - "3016": 1, - "3017": 1, - "3018": 1, - "3019": 1, - "302": 1, - "3020": 1, - "3021": 1, - "3022": 1, - "3023": 1, - "3024": 1, - "3025": 1, - "3026": 1, - "3027": 1, - "3028": 1, - "3029": 1, - "303": 1, - "3030": 1, - "3031": 1, - "3032": 1, - "3033": 1, - "3034": 1, - "3035": 1, - "3036": 1, - "3037": 1, - "3038": 1, - "3039": 1, - "304": 1, - "3040": 1, - "3041": 1, - "3042": 1, - "3043": 1, - "3044": 1, - "3045": 1, - "3046": 1, - "3047": 1, - "3048": 1, - "3049": 1, - "305": 1, - "3050": 1, - "3051": 1, - "3052": 1, - "3053": 1, - "3054": 1, - "3055": 1, - "3056": 1, - "3057": 1, - "3058": 1, - "3059": 1, - "306": 1, - "3060": 1, - "3061": 1, - "3062": 1, - "3063": 1, - "3064": 1, - "3065": 1, - "3066": 1, - "3067": 1, - "3068": 1, - "3069": 1, - "307": 1, - "3070": 1, - "3071": 1, - "3072": 1, - "3073": 1, - "3074": 1, - "3075": 1, - "3076": 1, - "3077": 1, - "3078": 1, - "3079": 1, - "308": 1, - "3080": 1, - "3081": 1, - "3082": 1, - "3083": 1, - "3084": 1, - "3085": 1, - "3086": 1, - "3087": 1, - "3088": 1, - "3089": 1, - "309": 1, - "3090": 1, - "3091": 1, - "3092": 1, - "3093": 1, - "3094": 1, - "3095": 1, - "3096": 1, - "3097": 1, - "3098": 1, - "3099": 1, - "31": 1, - "310": 1, - "3100": 1, - "3101": 1, - "3102": 1, - "3103": 1, - "3104": 1, - "3105": 1, - "3106": 1, - "3107": 1, - "3108": 1, - "3109": 1, - "311": 1, - "3110": 1, - "3111": 1, - "3112": 1, - "3113": 1, - "3114": 1, - "3115": 1, - "3116": 1, - "3117": 1, - "3118": 1, - "3119": 1, - "312": 1, - "3120": 1, - "3121": 1, - "3122": 1, - "3123": 1, - "3124": 1, - "3125": 1, - "3126": 1, - "3127": 1, - "3128": 1, - "3129": 1, - "313": 1, - "3130": 1, - "3131": 1, - "3132": 1, - "3133": 1, - "3134": 1, - "3135": 1, - "3136": 1, - "3137": 1, - "3138": 1, - "3139": 1, - "314": 1, - "3140": 1, - "3141": 1, - "3142": 1, - "3143": 1, - "3144": 1, - "3145": 1, - "3146": 1, - "3147": 1, - "3148": 1, - "3149": 1, - "315": 1, - "3150": 1, - "3151": 1, - "3152": 1, - "3153": 1, - "3154": 1, - "3155": 1, - "3156": 1, - "3157": 1, - "3158": 1, - "3159": 1, - "316": 1, - "3160": 1, - "3161": 1, - "3162": 1, - "3163": 1, - "3164": 1, - "3165": 1, - "3166": 1, - "3167": 1, - "3168": 1, - "3169": 1, - "317": 1, - "3170": 1, - "3171": 1, - "3172": 1, - "3173": 1, - "3174": 1, - "3175": 1, - "3176": 1, - "3177": 1, - "3178": 1, - "3179": 1, - "318": 1, - "3180": 1, - "3181": 1, - "3182": 1, - "3183": 1, - "3184": 1, - "3185": 1, - "3186": 1, - "3187": 1, - "3188": 1, - "3189": 1, - "319": 1, - "3190": 1, - "3191": 1, - "3192": 1, - "3193": 1, - "3194": 1, - "3195": 1, - "3196": 1, - "3197": 1, - "3198": 1, - "3199": 1, - "32": 1, - "320": 1, - "3200": 1, - "3201": 1, - "3202": 1, - "3203": 1, - "3204": 1, - "3205": 1, - "3206": 1, - "3207": 1, - "3208": 1, - "3209": 1, - "321": 1, - "3210": 1, - "3211": 1, - "3212": 1, - "3213": 1, - "3214": 1, - "3215": 1, - "3216": 1, - "3217": 1, - "3218": 1, - "3219": 1, - "322": 1, - "3220": 1, - "3221": 1, - "3222": 1, - "3223": 1, - "3224": 1, - "3225": 1, - "3226": 1, - "3227": 1, - "3228": 1, - "3229": 1, - "323": 1, - "3230": 1, - "3231": 1, - "3232": 1, - "3233": 1, - "3234": 1, - "3235": 1, - "3236": 1, - "3237": 1, - "3238": 1, - "3239": 1, - "324": 1, - "3240": 1, - "3241": 1, - "3242": 1, - "3243": 1, - "3244": 1, - "3245": 1, - "3246": 1, - "3247": 1, - "3248": 1, - "3249": 1, - "325": 1, - "3250": 1, - "3251": 1, - "3252": 1, - "3253": 1, - "3254": 1, - "3255": 1, - "3256": 1, - "3257": 1, - "3258": 1, - "3259": 1, - "326": 1, - "3260": 1, - "3261": 1, - "3262": 1, - "3263": 1, - "3264": 1, - "3265": 1, - "3266": 1, - "3267": 1, - "3268": 1, - "3269": 1, - "327": 1, - "3270": 1, - "3271": 1, - "3272": 1, - "3273": 1, - "3274": 1, - "3275": 1, - "3276": 1, - "3277": 1, - "3278": 1, - "3279": 1, - "328": 1, - "3280": 1, - "3281": 1, - "3282": 1, - "3283": 1, - "3284": 1, - "3285": 1, - "3286": 1, - "3287": 1, - "3288": 1, - "3289": 1, - "329": 1, - "3290": 1, - "3291": 1, - "3292": 1, - "3293": 1, - "3294": 1, - "3295": 1, - "3296": 1, - "3297": 1, - "3298": 1, - "3299": 1, - "33": 1, - "330": 1, - "3300": 1, - "3301": 1, - "3302": 1, - "3303": 1, - "3304": 1, - "3305": 1, - "3306": 1, - "3307": 1, - "3308": 1, - "3309": 1, - "331": 1, - "3310": 1, - "3311": 1, - "3312": 1, - "3313": 1, - "3314": 1, - "3315": 1, - "3316": 1, - "3317": 1, - "3318": 1, - "3319": 1, - "332": 1, - "3320": 1, - "3321": 1, - "3322": 1, - "3323": 1, - "3324": 1, - "3325": 1, - "3326": 1, - "3327": 1, - "3328": 1, - "3329": 1, - "333": 1, - "3330": 1, - "3331": 1, - "3332": 1, - "3333": 1, - "3334": 1, - "3335": 1, - "3336": 1, - "3337": 1, - "3338": 1, - "3339": 1, - "334": 1, - "3340": 1, - "3341": 1, - "3342": 1, - "3343": 1, - "3344": 1, - "3345": 1, - "3346": 1, - "3347": 1, - "3348": 1, - "3349": 1, - "335": 1, - "3350": 1, - "3351": 1, - "3352": 1, - "3353": 1, - "3354": 1, - "3355": 1, - "3356": 1, - "3357": 1, - "3358": 1, - "3359": 1, - "336": 1, - "3360": 1, - "3361": 1, - "3362": 1, - "3363": 1, - "3364": 1, - "3365": 1, - "3366": 1, - "3367": 1, - "3368": 1, - "3369": 1, - "337": 1, - "3370": 1, - "3371": 1, - "3372": 1, - "3373": 1, - "3374": 1, - "3375": 1, - "3376": 1, - "3377": 1, - "3378": 1, - "3379": 1, - "338": 1, - "3380": 1, - "3381": 1, - "3382": 1, - "3383": 1, - "3384": 1, - "3385": 1, - "3386": 1, - "3387": 1, - "3388": 1, - "3389": 1, - "339": 1, - "3390": 1, - "3391": 1, - "3392": 1, - "3393": 1, - "3394": 1, - "3395": 1, - "3396": 1, - "3397": 1, - "3398": 1, - "3399": 1, - "34": 1, - "340": 1, - "3400": 1, - "3401": 1, - "3402": 1, - "3403": 1, - "3404": 1, - "3405": 1, - "3406": 1, - "3407": 1, - "3408": 1, - "3409": 1, - "341": 1, - "3410": 1, - "3411": 1, - "3412": 1, - "3413": 1, - "3414": 1, - "3415": 1, - "3416": 1, - "3417": 1, - "3418": 1, - "3419": 1, - "342": 1, - "3420": 1, - "3421": 1, - "3422": 1, - "3423": 1, - "3424": 1, - "3425": 1, - "3426": 1, - "3427": 1, - "3428": 1, - "3429": 1, - "343": 1, - "3430": 1, - "3431": 1, - "3432": 1, - "3433": 1, - "3434": 1, - "3435": 1, - "3436": 1, - "3437": 1, - "3438": 1, - "3439": 1, - "344": 1, - "3440": 1, - "3441": 1, - "3442": 1, - "3443": 1, - "3444": 1, - "3445": 1, - "3446": 1, - "3447": 1, - "3448": 1, - "3449": 1, - "345": 1, - "3450": 1, - "3451": 1, - "3452": 1, - "3453": 1, - "3454": 1, - "3455": 1, - "3456": 1, - "3457": 1, - "3458": 1, - "3459": 1, - "346": 1, - "3460": 1, - "3461": 1, - "3462": 1, - "3463": 1, - "3464": 1, - "3465": 1, - "3466": 1, - "3467": 1, - "3468": 1, - "3469": 1, - "347": 1, - "3470": 1, - "3471": 1, - "3472": 1, - "3473": 1, - "3474": 1, - "3475": 1, - "3476": 1, - "3477": 1, - "3478": 1, - "3479": 1, - "348": 1, - "3480": 1, - "3481": 1, - "3482": 1, - "3483": 1, - "3484": 1, - "3485": 1, - "3486": 1, - "3487": 1, - "3488": 1, - "3489": 1, - "349": 1, - "3490": 1, - "3491": 1, - "3492": 1, - "3493": 1, - "3494": 1, - "3495": 1, - "3496": 1, - "3497": 1, - "3498": 1, - "3499": 1, - "35": 1, - "350": 1, - "3500": 1, - "3501": 1, - "3502": 1, - "3503": 1, - "3504": 1, - "3505": 1, - "3506": 1, - "3507": 1, - "3508": 1, - "3509": 1, - "351": 1, - "3510": 1, - "3511": 1, - "3512": 1, - "3513": 1, - "3514": 1, - "3515": 1, - "3516": 1, - "3517": 1, - "3518": 1, - "3519": 1, - "352": 1, - "3520": 1, - "3521": 1, - "3522": 1, - "3523": 1, - "3524": 1, - "3525": 1, - "3526": 1, - "3527": 1, - "3528": 1, - "3529": 1, - "353": 1, - "3530": 1, - "3531": 1, - "3532": 1, - "3533": 1, - "3534": 1, - "3535": 1, - "3536": 1, - "3537": 1, - "3538": 1, - "3539": 1, - "354": 1, - "3540": 1, - "3541": 1, - "3542": 1, - "3543": 1, - "3544": 1, - "3545": 1, - "3546": 1, - "3547": 1, - "3548": 1, - "3549": 1, - "355": 1, - "3550": 1, - "3551": 1, - "3552": 1, - "3553": 1, - "3554": 1, - "3555": 1, - "3556": 1, - "3557": 1, - "3558": 1, - "3559": 1, - "356": 1, - "3560": 1, - "3561": 1, - "3562": 1, - "3563": 1, - "3564": 1, - "3565": 1, - "3566": 1, - "3567": 1, - "3568": 1, - "3569": 1, - "357": 1, - "3570": 1, - "3571": 1, - "3572": 1, - "3573": 1, - "3574": 1, - "3575": 1, - "3576": 1, - "3577": 1, - "3578": 1, - "3579": 1, - "358": 1, - "3580": 1, - "3581": 1, - "3582": 1, - "3583": 1, - "3584": 1, - "3585": 1, - "3586": 1, - "3587": 1, - "3588": 1, - "3589": 1, - "359": 1, - "3590": 1, - "3591": 1, - "3592": 1, - "3593": 1, - "3594": 1, - "3595": 1, - "3596": 1, - "3597": 1, - "3598": 1, - "3599": 1, - "36": 1, - "360": 1, - "3600": 1, - "3601": 1, - "3602": 1, - "3603": 1, - "3604": 1, - "3605": 1, - "3606": 1, - "3607": 1, - "3608": 1, - "3609": 1, - "361": 1, - "3610": 1, - "3611": 1, - "3612": 1, - "3613": 1, - "3614": 1, - "3615": 1, - "3616": 1, - "3617": 1, - "3618": 1, - "3619": 1, - "362": 1, - "3620": 1, - "3621": 1, - "3622": 1, - "3623": 1, - "3624": 1, - "3625": 1, - "3626": 1, - "3627": 1, - "3628": 1, - "3629": 1, - "363": 1, - "3630": 1, - "3631": 1, - "3632": 1, - "3633": 1, - "3634": 1, - "3635": 1, - "3636": 1, - "3637": 1, - "3638": 1, - "3639": 1, - "364": 1, - "3640": 1, - "3641": 1, - "3642": 1, - "3643": 1, - "3644": 1, - "3645": 1, - "3646": 1, - "3647": 1, - "3648": 1, - "3649": 1, - "365": 1, - "3650": 1, - "3651": 1, - "3652": 1, - "3653": 1, - "3654": 1, - "3655": 1, - "3656": 1, - "3657": 1, - "3658": 1, - "3659": 1, - "366": 1, - "3660": 1, - "3661": 1, - "3662": 1, - "3663": 1, - "3664": 1, - "3665": 1, - "3666": 1, - "3667": 1, - "3668": 1, - "3669": 1, - "367": 1, - "3670": 1, - "3671": 1, - "3672": 1, - "3673": 1, - "3674": 1, - "3675": 1, - "3676": 1, - "3677": 1, - "3678": 1, - "3679": 1, - "368": 1, - "3680": 1, - "3681": 1, - "3682": 1, - "3683": 1, - "3684": 1, - "3685": 1, - "3686": 1, - "3687": 1, - "3688": 1, - "3689": 1, - "369": 1, - "3690": 1, - "3691": 1, - "3692": 1, - "3693": 1, - "3694": 1, - "3695": 1, - "3696": 1, - "3697": 1, - "3698": 1, - "3699": 1, - "37": 1, - "370": 1, - "3700": 1, - "3701": 1, - "3702": 1, - "3703": 1, - "3704": 1, - "3705": 1, - "3706": 1, - "3707": 1, - "3708": 1, - "3709": 1, - "371": 1, - "3710": 1, - "3711": 1, - "3712": 1, - "3713": 1, - "3714": 1, - "3715": 1, - "3716": 1, - "3717": 1, - "3718": 1, - "3719": 1, - "372": 1, - "3720": 1, - "3721": 1, - "3722": 1, - "3723": 1, - "3724": 1, - "3725": 1, - "3726": 1, - "3727": 1, - "3728": 1, - "3729": 1, - "373": 1, - "3730": 1, - "3731": 1, - "3732": 1, - "3733": 1, - "3734": 1, - "3735": 1, - "3736": 1, - "3737": 1, - "3738": 1, - "3739": 1, - "374": 1, - "3740": 1, - "3741": 1, - "3742": 1, - "3743": 1, - "3744": 1, - "3745": 1, - "3746": 1, - "3747": 1, - "3748": 1, - "3749": 1, - "375": 1, - "3750": 1, - "3751": 1, - "3752": 1, - "3753": 1, - "3754": 1, - "3755": 1, - "3756": 1, - "3757": 1, - "3758": 1, - "3759": 1, - "376": 1, - "3760": 1, - "3761": 1, - "3762": 1, - "3763": 1, - "3764": 1, - "3765": 1, - "3766": 1, - "3767": 1, - "3768": 1, - "3769": 1, - "377": 1, - "3770": 1, - "3771": 1, - "3772": 1, - "3773": 1, - "3774": 1, - "3775": 1, - "3776": 1, - "3777": 1, - "3778": 1, - "3779": 1, - "378": 1, - "3780": 1, - "3781": 1, - "3782": 1, - "3783": 1, - "3784": 1, - "3785": 1, - "3786": 1, - "3787": 1, - "3788": 1, - "3789": 1, - "379": 1, - "3790": 1, - "3791": 1, - "3792": 1, - "3793": 1, - "3794": 1, - "3795": 1, - "3796": 1, - "3797": 1, - "3798": 1, - "3799": 1, - "38": 1, - "380": 1, - "3800": 1, - "3801": 1, - "3802": 1, - "3803": 1, - "3804": 1, - "3805": 1, - "3806": 1, - "3807": 1, - "3808": 1, - "3809": 1, - "381": 1, - "3810": 1, - "3811": 1, - "3812": 1, - "3813": 1, - "3814": 1, - "3815": 1, - "3816": 1, - "3817": 1, - "3818": 1, - "3819": 1, - "382": 1, - "3820": 1, - "3821": 1, - "3822": 1, - "3823": 1, - "3824": 1, - "3825": 1, - "3826": 1, - "3827": 1, - "3828": 1, - "3829": 1, - "383": 1, - "3830": 1, - "3831": 1, - "3832": 1, - "3833": 1, - "3834": 1, - "3835": 1, - "3836": 1, - "3837": 1, - "3838": 1, - "3839": 1, - "384": 1, - "3840": 1, - "3841": 1, - "3842": 1, - "3843": 1, - "3844": 1, - "3845": 1, - "3846": 1, - "3847": 1, - "3848": 1, - "3849": 1, - "385": 1, - "3850": 1, - "3851": 1, - "3852": 1, - "3853": 1, - "3854": 1, - "3855": 1, - "3856": 1, - "3857": 1, - "3858": 1, - "3859": 1, - "386": 1, - "3860": 1, - "3861": 1, - "3862": 1, - "3863": 1, - "3864": 1, - "3865": 1, - "3866": 1, - "3867": 1, - "3868": 1, - "3869": 1, - "387": 1, - "3870": 1, - "3871": 1, - "3872": 1, - "3873": 1, - "3874": 1, - "3875": 1, - "3876": 1, - "3877": 1, - "3878": 1, - "3879": 1, - "388": 1, - "3880": 1, - "3881": 1, - "3882": 1, - "3883": 1, - "3884": 1, - "3885": 1, - "3886": 1, - "3887": 1, - "3888": 1, - "3889": 1, - "389": 1, - "3890": 1, - "3891": 1, - "3892": 1, - "3893": 1, - "3894": 1, - "3895": 1, - "3896": 1, - "3897": 1, - "3898": 1, - "3899": 1, - "39": 1, - "390": 1, - "3900": 1, - "3901": 1, - "3902": 1, - "3903": 1, - "3904": 1, - "3905": 1, - "3906": 1, - "3907": 1, - "3908": 1, - "3909": 1, - "391": 1, - "3910": 1, - "3911": 1, - "3912": 1, - "3913": 1, - "3914": 1, - "3915": 1, - "3916": 1, - "3917": 1, - "3918": 1, - "3919": 1, - "392": 1, - "3920": 1, - "3921": 1, - "3922": 1, - "3923": 1, - "3924": 1, - "3925": 1, - "3926": 1, - "3927": 1, - "3928": 1, - "3929": 1, - "393": 1, - "3930": 1, - "3931": 1, - "3932": 1, - "3933": 1, - "3934": 1, - "3935": 1, - "3936": 1, - "3937": 1, - "3938": 1, - "3939": 1, - "394": 1, - "3940": 1, - "3941": 1, - "3942": 1, - "3943": 1, - "3944": 1, - "3945": 1, - "3946": 1, - "3947": 1, - "3948": 1, - "3949": 1, - "395": 1, - "3950": 1, - "3951": 1, - "3952": 1, - "3953": 1, - "3954": 1, - "3955": 1, - "3956": 1, - "3957": 1, - "3958": 1, - "3959": 1, - "396": 1, - "3960": 1, - "3961": 1, - "3962": 1, - "3963": 1, - "3964": 1, - "3965": 1, - "3966": 1, - "3967": 1, - "3968": 1, - "3969": 1, - "397": 1, - "3970": 1, - "3971": 1, - "3972": 1, - "3973": 1, - "3974": 1, - "3975": 1, - "3976": 1, - "3977": 1, - "3978": 1, - "3979": 1, - "398": 1, - "3980": 1, - "3981": 1, - "3982": 1, - "3983": 1, - "3984": 1, - "3985": 1, - "3986": 1, - "3987": 1, - "3988": 1, - "3989": 1, - "399": 1, - "3990": 1, - "3991": 1, - "3992": 1, - "3993": 1, - "3994": 1, - "3995": 1, - "3996": 1, - "3997": 1, - "3998": 1, - "3999": 1, - "4": 1, - "40": 1, - "400": 1, - "4000": 1, - "4001": 1, - "4002": 1, - "4003": 1, - "4004": 1, - "4005": 1, - "4006": 1, - "4007": 1, - "4008": 1, - "4009": 1, - "401": 1, - "4010": 1, - "4011": 1, - "4012": 1, - "4013": 1, - "4014": 1, - "4015": 1, - "4016": 1, - "4017": 1, - "4018": 1, - "4019": 1, - "402": 1, - "4020": 1, - "4021": 1, - "4022": 1, - "4023": 1, - "4024": 1, - "4025": 1, - "4026": 1, - "4027": 1, - "4028": 1, - "4029": 1, - "403": 1, - "4030": 1, - "4031": 1, - "4032": 1, - "4033": 1, - "4034": 1, - "4035": 1, - "4036": 1, - "4037": 1, - "4038": 1, - "4039": 1, - "404": 1, - "4040": 1, - "4041": 1, - "4042": 1, - "4043": 1, - "4044": 1, - "4045": 1, - "4046": 1, - "4047": 1, - "4048": 1, - "4049": 1, - "405": 1, - "4050": 1, - "4051": 1, - "4052": 1, - "4053": 1, - "4054": 1, - "4055": 1, - "4056": 1, - "4057": 1, - "4058": 1, - "4059": 1, - "406": 1, - "4060": 1, - "4061": 1, - "4062": 1, - "4063": 1, - "4064": 1, - "4065": 1, - "4066": 1, - "4067": 1, - "4068": 1, - "4069": 1, - "407": 1, - "4070": 1, - "4071": 1, - "4072": 1, - "4073": 1, - "4074": 1, - "4075": 1, - "4076": 1, - "4077": 1, - "4078": 1, - "4079": 1, - "408": 1, - "4080": 1, - "4081": 1, - "4082": 1, - "4083": 1, - "4084": 1, - "4085": 1, - "4086": 1, - "4087": 1, - "4088": 1, - "4089": 1, - "409": 1, - "4090": 1, - "4091": 1, - "4092": 1, - "4093": 1, - "4094": 1, - "4095": 1, - "4096": 1, - "4097": 1, - "4098": 1, - "4099": 1, - "41": 1, - "410": 1, - "4100": 1, - "4101": 1, - "4102": 1, - "4103": 1, - "4104": 1, - "4105": 1, - "4106": 1, - "4107": 1, - "4108": 1, - "4109": 1, - "411": 1, - "4110": 1, - "4111": 1, - "4112": 1, - "4113": 1, - "4114": 1, - "4115": 1, - "4116": 1, - "4117": 1, - "4118": 1, - "4119": 1, - "412": 1, - "4120": 1, - "4121": 1, - "4122": 1, - "4123": 1, - "4124": 1, - "4125": 1, - "4126": 1, - "4127": 1, - "4128": 1, - "4129": 1, - "413": 1, - "4130": 1, - "4131": 1, - "4132": 1, - "4133": 1, - "4134": 1, - "4135": 1, - "4136": 1, - "4137": 1, - "4138": 1, - "4139": 1, - "414": 1, - "4140": 1, - "4141": 1, - "4142": 1, - "4143": 1, - "4144": 1, - "4145": 1, - "4146": 1, - "4147": 1, - "4148": 1, - "4149": 1, - "415": 1, - "4150": 1, - "4151": 1, - "4152": 1, - "4153": 1, - "4154": 1, - "4155": 1, - "4156": 1, - "4157": 1, - "4158": 1, - "4159": 1, - "416": 1, - "4160": 1, - "4161": 1, - "4162": 1, - "4163": 1, - "4164": 1, - "4165": 1, - "4166": 1, - "4167": 1, - "4168": 1, - "4169": 1, - "417": 1, - "4170": 1, - "4171": 1, - "4172": 1, - "4173": 1, - "4174": 1, - "4175": 1, - "4176": 1, - "4177": 1, - "4178": 1, - "4179": 1, - "418": 1, - "4180": 1, - "4181": 1, - "4182": 1, - "4183": 1, - "4184": 1, - "4185": 1, - "4186": 1, - "4187": 1, - "4188": 1, - "4189": 1, - "419": 1, - "4190": 1, - "4191": 1, - "4192": 1, - "4193": 1, - "4194": 1, - "4195": 1, - "4196": 1, - "4197": 1, - "4198": 1, - "4199": 1, - "42": 1, - "420": 1, - "4200": 1, - "4201": 1, - "4202": 1, - "4203": 1, - "4204": 1, - "4205": 1, - "4206": 1, - "4207": 1, - "4208": 1, - "4209": 1, - "421": 1, - "4210": 1, - "4211": 1, - "4212": 1, - "4213": 1, - "4214": 1, - "4215": 1, - "4216": 1, - "4217": 1, - "4218": 1, - "4219": 1, - "422": 1, - "4220": 1, - "4221": 1, - "4222": 1, - "4223": 1, - "4224": 1, - "4225": 1, - "4226": 1, - "4227": 1, - "4228": 1, - "4229": 1, - "423": 1, - "4230": 1, - "4231": 1, - "4232": 1, - "4233": 1, - "4234": 1, - "4235": 1, - "4236": 1, - "4237": 1, - "4238": 1, - "4239": 1, - "424": 1, - "4240": 1, - "4241": 1, - "4242": 1, - "4243": 1, - "4244": 1, - "4245": 1, - "4246": 1, - "4247": 1, - "4248": 1, - "4249": 1, - "425": 1, - "4250": 1, - "4251": 1, - "4252": 1, - "4253": 1, - "4254": 1, - "4255": 1, - "4256": 1, - "4257": 1, - "4258": 1, - "4259": 1, - "426": 1, - "4260": 1, - "4261": 1, - "4262": 1, - "4263": 1, - "4264": 1, - "4265": 1, - "4266": 1, - "4267": 1, - "4268": 1, - "4269": 1, - "427": 1, - "4270": 1, - "4271": 1, - "4272": 1, - "4273": 1, - "4274": 1, - "4275": 1, - "4276": 1, - "4277": 1, - "4278": 1, - "4279": 1, - "428": 1, - "4280": 1, - "4281": 1, - "4282": 1, - "4283": 1, - "4284": 1, - "4285": 1, - "4286": 1, - "4287": 1, - "4288": 1, - "4289": 1, - "429": 1, - "4290": 1, - "4291": 1, - "4292": 1, - "4293": 1, - "4294": 1, - "4295": 1, - "4296": 1, - "4297": 1, - "4298": 1, - "4299": 1, - "43": 1, - "430": 1, - "4300": 1, - "4301": 1, - "4302": 1, - "4303": 1, - "4304": 1, - "4305": 1, - "4306": 1, - "4307": 1, - "4308": 1, - "4309": 1, - "431": 1, - "4310": 1, - "4311": 1, - "4312": 1, - "4313": 1, - "4314": 1, - "4315": 1, - "4316": 1, - "4317": 1, - "4318": 1, - "4319": 1, - "432": 1, - "4320": 1, - "4321": 1, - "4322": 1, - "4323": 1, - "4324": 1, - "4325": 1, - "4326": 1, - "4327": 1, - "4328": 1, - "4329": 1, - "433": 1, - "4330": 1, - "4331": 1, - "4332": 1, - "4333": 1, - "4334": 1, - "4335": 1, - "4336": 1, - "4337": 1, - "4338": 1, - "4339": 1, - "434": 1, - "4340": 1, - "4341": 1, - "4342": 1, - "4343": 1, - "4344": 1, - "4345": 1, - "4346": 1, - "4347": 1, - "4348": 1, - "4349": 1, - "435": 1, - "4350": 1, - "4351": 1, - "4352": 1, - "4353": 1, - "4354": 1, - "4355": 1, - "4356": 1, - "4357": 1, - "4358": 1, - "4359": 1, - "436": 1, - "4360": 1, - "4361": 1, - "4362": 1, - "4363": 1, - "4364": 1, - "4365": 1, - "4366": 1, - "4367": 1, - "4368": 1, - "4369": 1, - "437": 1, - "4370": 1, - "4371": 1, - "4372": 1, - "4373": 1, - "4374": 1, - "4375": 1, - "4376": 1, - "4377": 1, - "4378": 1, - "4379": 1, - "438": 1, - "4380": 1, - "4381": 1, - "4382": 1, - "4383": 1, - "4384": 1, - "4385": 1, - "4386": 1, - "4387": 1, - "4388": 1, - "4389": 1, - "439": 1, - "4390": 1, - "4391": 1, - "4392": 1, - "4393": 1, - "4394": 1, - "4395": 1, - "4396": 1, - "4397": 1, - "4398": 1, - "4399": 1, - "44": 1, - "440": 1, - "4400": 1, - "4401": 1, - "4402": 1, - "4403": 1, - "4404": 1, - "4405": 1, - "4406": 1, - "4407": 1, - "4408": 1, - "4409": 1, - "441": 1, - "4410": 1, - "4411": 1, - "4412": 1, - "4413": 1, - "4414": 1, - "4415": 1, - "4416": 1, - "4417": 1, - "4418": 1, - "4419": 1, - "442": 1, - "4420": 1, - "4421": 1, - "4422": 1, - "4423": 1, - "4424": 1, - "4425": 1, - "4426": 1, - "4427": 1, - "4428": 1, - "4429": 1, - "443": 1, - "4430": 1, - "4431": 1, - "4432": 1, - "4433": 1, - "4434": 1, - "4435": 1, - "4436": 1, - "4437": 1, - "4438": 1, - "4439": 1, - "444": 1, - "4440": 1, - "4441": 1, - "4442": 1, - "4443": 1, - "4444": 1, - "4445": 1, - "4446": 1, - "4447": 1, - "4448": 1, - "4449": 1, - "445": 1, - "4450": 1, - "4451": 1, - "4452": 1, - "4453": 1, - "4454": 1, - "4455": 1, - "4456": 1, - "4457": 1, - "4458": 1, - "4459": 1, - "446": 1, - "4460": 1, - "4461": 1, - "4462": 1, - "4463": 1, - "4464": 1, - "4465": 1, - "4466": 1, - "4467": 1, - "4468": 1, - "4469": 1, - "447": 1, - "4470": 1, - "4471": 1, - "4472": 1, - "4473": 1, - "4474": 1, - "4475": 1, - "4476": 1, - "4477": 1, - "4478": 1, - "4479": 1, - "448": 1, - "4480": 1, - "4481": 1, - "4482": 1, - "4483": 1, - "4484": 1, - "4485": 1, - "4486": 1, - "4487": 1, - "4488": 1, - "4489": 1, - "449": 1, - "4490": 1, - "4491": 1, - "4492": 1, - "4493": 1, - "4494": 1, - "4495": 1, - "4496": 1, - "4497": 1, - "4498": 1, - "4499": 1, - "45": 1, - "450": 1, - "4500": 1, - "4501": 1, - "4502": 1, - "4503": 1, - "4504": 1, - "4505": 1, - "4506": 1, - "4507": 1, - "4508": 1, - "4509": 1, - "451": 1, - "4510": 1, - "4511": 1, - "4512": 1, - "4513": 1, - "4514": 1, - "4515": 1, - "4516": 1, - "4517": 1, - "4518": 1, - "4519": 1, - "452": 1, - "4520": 1, - "4521": 1, - "4522": 1, - "4523": 1, - "4524": 1, - "4525": 1, - "4526": 1, - "4527": 1, - "4528": 1, - "4529": 1, - "453": 1, - "4530": 1, - "4531": 1, - "4532": 1, - "4533": 1, - "4534": 1, - "4535": 1, - "4536": 1, - "4537": 1, - "4538": 1, - "4539": 1, - "454": 1, - "4540": 1, - "4541": 1, - "4542": 1, - "4543": 1, - "4544": 1, - "4545": 1, - "4546": 1, - "4547": 1, - "4548": 1, - "4549": 1, - "455": 1, - "4550": 1, - "4551": 1, - "4552": 1, - "4553": 1, - "4554": 1, - "4555": 1, - "4556": 1, - "4557": 1, - "4558": 1, - "4559": 1, - "456": 1, - "4560": 1, - "4561": 1, - "4562": 1, - "4563": 1, - "4564": 1, - "4565": 1, - "4566": 1, - "4567": 1, - "4568": 1, - "4569": 1, - "457": 1, - "4570": 1, - "4571": 1, - "4572": 1, - "4573": 1, - "4574": 1, - "4575": 1, - "4576": 1, - "4577": 1, - "4578": 1, - "4579": 1, - "458": 1, - "4580": 1, - "4581": 1, - "4582": 1, - "4583": 1, - "4584": 1, - "4585": 1, - "4586": 1, - "4587": 1, - "4588": 1, - "4589": 1, - "459": 1, - "4590": 1, - "4591": 1, - "4592": 1, - "4593": 1, - "4594": 1, - "4595": 1, - "4596": 1, - "4597": 1, - "4598": 1, - "4599": 1, - "46": 1, - "460": 1, - "4600": 1, - "4601": 1, - "4602": 1, - "4603": 1, - "4604": 1, - "4605": 1, - "4606": 1, - "4607": 1, - "4608": 1, - "4609": 1, - "461": 1, - "4610": 1, - "4611": 1, - "4612": 1, - "4613": 1, - "4614": 1, - "4615": 1, - "4616": 1, - "4617": 1, - "4618": 1, - "4619": 1, - "462": 1, - "4620": 1, - "4621": 1, - "4622": 1, - "4623": 1, - "4624": 1, - "4625": 1, - "4626": 1, - "4627": 1, - "4628": 1, - "4629": 1, - "463": 1, - "4630": 1, - "4631": 1, - "4632": 1, - "4633": 1, - "4634": 1, - "4635": 1, - "4636": 1, - "4637": 1, - "4638": 1, - "4639": 1, - "464": 1, - "4640": 1, - "4641": 1, - "4642": 1, - "4643": 1, - "4644": 1, - "4645": 1, - "4646": 1, - "4647": 1, - "4648": 1, - "4649": 1, - "465": 1, - "4650": 1, - "4651": 1, - "4652": 1, - "4653": 1, - "4654": 1, - "4655": 1, - "4656": 1, - "4657": 1, - "4658": 1, - "4659": 1, - "466": 1, - "4660": 1, - "4661": 1, - "4662": 1, - "4663": 1, - "4664": 1, - "4665": 1, - "4666": 1, - "4667": 1, - "4668": 1, - "4669": 1, - "467": 1, - "4670": 1, - "4671": 1, - "4672": 1, - "4673": 1, - "4674": 1, - "4675": 1, - "4676": 1, - "4677": 1, - "4678": 1, - "4679": 1, - "468": 1, - "4680": 1, - "4681": 1, - "4682": 1, - "4683": 1, - "4684": 1, - "4685": 1, - "4686": 1, - "4687": 1, - "4688": 1, - "4689": 1, - "469": 1, - "4690": 1, - "4691": 1, - "4692": 1, - "4693": 1, - "4694": 1, - "4695": 1, - "4696": 1, - "4697": 1, - "4698": 1, - "4699": 1, - "47": 1, - "470": 1, - "4700": 1, - "4701": 1, - "4702": 1, - "4703": 1, - "4704": 1, - "4705": 1, - "4706": 1, - "4707": 1, - "4708": 1, - "4709": 1, - "471": 1, - "4710": 1, - "4711": 1, - "4712": 1, - "4713": 1, - "4714": 1, - "4715": 1, - "4716": 1, - "4717": 1, - "4718": 1, - "4719": 1, - "472": 1, - "4720": 1, - "4721": 1, - "4722": 1, - "4723": 1, - "4724": 1, - "4725": 1, - "4726": 1, - "4727": 1, - "4728": 1, - "4729": 1, - "473": 1, - "4730": 1, - "4731": 1, - "4732": 1, - "4733": 1, - "4734": 1, - "4735": 1, - "4736": 1, - "4737": 1, - "4738": 1, - "4739": 1, - "474": 1, - "4740": 1, - "4741": 1, - "4742": 1, - "4743": 1, - "4744": 1, - "4745": 1, - "4746": 1, - "4747": 1, - "4748": 1, - "4749": 1, - "475": 1, - "4750": 1, - "4751": 1, - "4752": 1, - "4753": 1, - "4754": 1, - "4755": 1, - "4756": 1, - "4757": 1, - "4758": 1, - "4759": 1, - "476": 1, - "4760": 1, - "4761": 1, - "4762": 1, - "4763": 1, - "4764": 1, - "4765": 1, - "4766": 1, - "4767": 1, - "4768": 1, - "4769": 1, - "477": 1, - "4770": 1, - "4771": 1, - "4772": 1, - "4773": 1, - "4774": 1, - "4775": 1, - "4776": 1, - "4777": 1, - "4778": 1, - "4779": 1, - "478": 1, - "4780": 1, - "4781": 1, - "4782": 1, - "4783": 1, - "4784": 1, - "4785": 1, - "4786": 1, - "4787": 1, - "4788": 1, - "4789": 1, - "479": 1, - "4790": 1, - "4791": 1, - "4792": 1, - "4793": 1, - "4794": 1, - "4795": 1, - "4796": 1, - "4797": 1, - "4798": 1, - "4799": 1, - "48": 1, - "480": 1, - "4800": 1, - "4801": 1, - "4802": 1, - "4803": 1, - "4804": 1, - "4805": 1, - "4806": 1, - "4807": 1, - "4808": 1, - "4809": 1, - "481": 1, - "4810": 1, - "4811": 1, - "4812": 1, - "4813": 1, - "4814": 1, - "4815": 1, - "4816": 1, - "4817": 1, - "4818": 1, - "4819": 1, - "482": 1, - "4820": 1, - "4821": 1, - "4822": 1, - "4823": 1, - "4824": 1, - "4825": 1, - "4826": 1, - "4827": 1, - "4828": 1, - "4829": 1, - "483": 1, - "4830": 1, - "4831": 1, - "4832": 1, - "4833": 1, - "4834": 1, - "4835": 1, - "4836": 1, - "4837": 1, - "4838": 1, - "4839": 1, - "484": 1, - "4840": 1, - "4841": 1, - "4842": 1, - "4843": 1, - "4844": 1, - "4845": 1, - "4846": 1, - "4847": 1, - "4848": 1, - "4849": 1, - "485": 1, - "4850": 1, - "4851": 1, - "4852": 1, - "4853": 1, - "4854": 1, - "4855": 1, - "4856": 1, - "4857": 1, - "4858": 1, - "4859": 1, - "486": 1, - "4860": 1, - "4861": 1, - "4862": 1, - "4863": 1, - "4864": 1, - "4865": 1, - "4866": 1, - "4867": 1, - "4868": 1, - "4869": 1, - "487": 1, - "4870": 1, - "4871": 1, - "4872": 1, - "4873": 1, - "4874": 1, - "4875": 1, - "4876": 1, - "4877": 1, - "4878": 1, - "4879": 1, - "488": 1, - "4880": 1, - "4881": 1, - "4882": 1, - "4883": 1, - "4884": 1, - "4885": 1, - "4886": 1, - "4887": 1, - "4888": 1, - "4889": 1, - "489": 1, - "4890": 1, - "4891": 1, - "4892": 1, - "4893": 1, - "4894": 1, - "4895": 1, - "4896": 1, - "4897": 1, - "4898": 1, - "4899": 1, - "49": 1, - "490": 1, - "4900": 1, - "4901": 1, - "4902": 1, - "4903": 1, - "4904": 1, - "4905": 1, - "4906": 1, - "4907": 1, - "4908": 1, - "4909": 1, - "491": 1, - "4910": 1, - "4911": 1, - "4912": 1, - "4913": 1, - "4914": 1, - "4915": 1, - "4916": 1, - "4917": 1, - "4918": 1, - "4919": 1, - "492": 1, - "4920": 1, - "4921": 1, - "4922": 1, - "4923": 1, - "4924": 1, - "4925": 1, - "4926": 1, - "4927": 1, - "4928": 1, - "4929": 1, - "493": 1, - "4930": 1, - "4931": 1, - "4932": 1, - "4933": 1, - "4934": 1, - "4935": 1, - "4936": 1, - "4937": 1, - "4938": 1, - "4939": 1, - "494": 1, - "4940": 1, - "4941": 1, - "4942": 1, - "4943": 1, - "4944": 1, - "4945": 1, - "4946": 1, - "4947": 1, - "4948": 1, - "4949": 1, - "495": 1, - "4950": 1, - "4951": 1, - "4952": 1, - "4953": 1, - "4954": 1, - "4955": 1, - "4956": 1, - "4957": 1, - "4958": 1, - "4959": 1, - "496": 1, - "4960": 1, - "4961": 1, - "4962": 1, - "4963": 1, - "4964": 1, - "4965": 1, - "4966": 1, - "4967": 1, - "4968": 1, - "4969": 1, - "497": 1, - "4970": 1, - "4971": 1, - "4972": 1, - "4973": 1, - "4974": 1, - "4975": 1, - "4976": 1, - "4977": 1, - "4978": 1, - "4979": 1, - "498": 1, - "4980": 1, - "4981": 1, - "4982": 1, - "4983": 1, - "4984": 1, - "4985": 1, - "4986": 1, - "4987": 1, - "4988": 1, - "4989": 1, - "499": 1, - "4990": 1, - "4991": 1, - "4992": 1, - "4993": 1, - "4994": 1, - "4995": 1, - "4996": 1, - "4997": 1, - "4998": 1, - "4999": 1, - "5": 1, - "50": 1, - "500": 1, - "5000": 1, - "5001": 1, - "5002": 1, - "5003": 1, - "5004": 1, - "5005": 1, - "5006": 1, - "5007": 1, - "5008": 1, - "5009": 1, - "501": 1, - "5010": 1, - "5011": 1, - "5012": 1, - "5013": 1, - "5014": 1, - "5015": 1, - "5016": 1, - "5017": 1, - "5018": 1, - "5019": 1, - "502": 1, - "5020": 1, - "5021": 1, - "5022": 1, - "5023": 1, - "5024": 1, - "5025": 1, - "5026": 1, - "5027": 1, - "5028": 1, - "5029": 1, - "503": 1, - "5030": 1, - "5031": 1, - "5032": 1, - "5033": 1, - "5034": 1, - "5035": 1, - "5036": 1, - "5037": 1, - "5038": 1, - "5039": 1, - "504": 1, - "5040": 1, - "5041": 1, - "5042": 1, - "5043": 1, - "5044": 1, - "5045": 1, - "5046": 1, - "5047": 1, - "5048": 1, - "5049": 1, - "505": 1, - "5050": 1, - "5051": 1, - "5052": 1, - "5053": 1, - "5054": 1, - "5055": 1, - "5056": 1, - "5057": 1, - "5058": 1, - "5059": 1, - "506": 1, - "5060": 1, - "5061": 1, - "5062": 1, - "5063": 1, - "5064": 1, - "5065": 1, - "5066": 1, - "5067": 1, - "5068": 1, - "5069": 1, - "507": 1, - "5070": 1, - "5071": 1, - "5072": 1, - "5073": 1, - "5074": 1, - "5075": 1, - "5076": 1, - "5077": 1, - "5078": 1, - "5079": 1, - "508": 1, - "5080": 1, - "5081": 1, - "5082": 1, - "5083": 1, - "5084": 1, - "5085": 1, - "5086": 1, - "5087": 1, - "5088": 1, - "5089": 1, - "509": 1, - "5090": 1, - "5091": 1, - "5092": 1, - "5093": 1, - "5094": 1, - "5095": 1, - "5096": 1, - "5097": 1, - "5098": 1, - "5099": 1, - "51": 1, - "510": 1, - "5100": 1, - "5101": 1, - "5102": 1, - "5103": 1, - "5104": 1, - "5105": 1, - "5106": 1, - "5107": 1, - "5108": 1, - "5109": 1, - "511": 1, - "5110": 1, - "5111": 1, - "5112": 1, - "5113": 1, - "5114": 1, - "5115": 1, - "5116": 1, - "5117": 1, - "5118": 1, - "5119": 1, - "512": 1, - "5120": 1, - "5121": 1, - "5122": 1, - "5123": 1, - "5124": 1, - "5125": 1, - "5126": 1, - "5127": 1, - "5128": 1, - "5129": 1, - "513": 1, - "5130": 1, - "5131": 1, - "5132": 1, - "5133": 1, - "5134": 1, - "5135": 1, - "5136": 1, - "5137": 1, - "5138": 1, - "5139": 1, - "514": 1, - "5140": 1, - "5141": 1, - "5142": 1, - "5143": 1, - "5144": 1, - "5145": 1, - "5146": 1, - "5147": 1, - "5148": 1, - "5149": 1, - "515": 1, - "5150": 1, - "5151": 1, - "5152": 1, - "5153": 1, - "5154": 1, - "5155": 1, - "5156": 1, - "5157": 1, - "5158": 1, - "5159": 1, - "516": 1, - "5160": 1, - "5161": 1, - "5162": 1, - "5163": 1, - "5164": 1, - "5165": 1, - "5166": 1, - "5167": 1, - "5168": 1, - "5169": 1, - "517": 1, - "5170": 1, - "5171": 1, - "5172": 1, - "5173": 1, - "5174": 1, - "5175": 1, - "5176": 1, - "5177": 1, - "5178": 1, - "5179": 1, - "518": 1, - "5180": 1, - "5181": 1, - "5182": 1, - "5183": 1, - "5184": 1, - "5185": 1, - "5186": 1, - "5187": 1, - "5188": 1, - "5189": 1, - "519": 1, - "5190": 1, - "5191": 1, - "5192": 1, - "5193": 1, - "5194": 1, - "5195": 1, - "5196": 1, - "5197": 1, - "5198": 1, - "5199": 1, - "52": 1, - "520": 1, - "5200": 1, - "5201": 1, - "5202": 1, - "5203": 1, - "5204": 1, - "5205": 1, - "5206": 1, - "5207": 1, - "5208": 1, - "5209": 1, - "521": 1, - "5210": 1, - "5211": 1, - "5212": 1, - "5213": 1, - "5214": 1, - "5215": 1, - "5216": 1, - "5217": 1, - "5218": 1, - "5219": 1, - "522": 1, - "5220": 1, - "5221": 1, - "5222": 1, - "5223": 1, - "5224": 1, - "5225": 1, - "5226": 1, - "5227": 1, - "5228": 1, - "5229": 1, - "523": 1, - "5230": 1, - "5231": 1, - "5232": 1, - "5233": 1, - "5234": 1, - "5235": 1, - "5236": 1, - "5237": 1, - "5238": 1, - "5239": 1, - "524": 1, - "5240": 1, - "5241": 1, - "5242": 1, - "5243": 1, - "5244": 1, - "5245": 1, - "5246": 1, - "5247": 1, - "5248": 1, - "5249": 1, - "525": 1, - "5250": 1, - "5251": 1, - "5252": 1, - "5253": 1, - "5254": 1, - "5255": 1, - "5256": 1, - "5257": 1, - "5258": 1, - "5259": 1, - "526": 1, - "5260": 1, - "5261": 1, - "5262": 1, - "5263": 1, - "5264": 1, - "5265": 1, - "5266": 1, - "5267": 1, - "5268": 1, - "5269": 1, - "527": 1, - "5270": 1, - "5271": 1, - "5272": 1, - "5273": 1, - "5274": 1, - "5275": 1, - "5276": 1, - "5277": 1, - "5278": 1, - "5279": 1, - "528": 1, - "5280": 1, - "5281": 1, - "5282": 1, - "5283": 1, - "5284": 1, - "5285": 1, - "5286": 1, - "5287": 1, - "5288": 1, - "5289": 1, - "529": 1, - "5290": 1, - "5291": 1, - "5292": 1, - "5293": 1, - "5294": 1, - "5295": 1, - "5296": 1, - "5297": 1, - "5298": 1, - "5299": 1, - "53": 1, - "530": 1, - "5300": 1, - "5301": 1, - "5302": 1, - "5303": 1, - "5304": 1, - "5305": 1, - "5306": 1, - "5307": 1, - "5308": 1, - "5309": 1, - "531": 1, - "5310": 1, - "5311": 1, - "5312": 1, - "5313": 1, - "5314": 1, - "5315": 1, - "5316": 1, - "5317": 1, - "5318": 1, - "5319": 1, - "532": 1, - "5320": 1, - "5321": 1, - "5322": 1, - "5323": 1, - "5324": 1, - "5325": 1, - "5326": 1, - "5327": 1, - "5328": 1, - "5329": 1, - "533": 1, - "5330": 1, - "5331": 1, - "5332": 1, - "5333": 1, - "5334": 1, - "5335": 1, - "5336": 1, - "5337": 1, - "5338": 1, - "5339": 1, - "534": 1, - "5340": 1, - "5341": 1, - "5342": 1, - "5343": 1, - "5344": 1, - "5345": 1, - "5346": 1, - "5347": 1, - "5348": 1, - "5349": 1, - "535": 1, - "5350": 1, - "5351": 1, - "5352": 1, - "5353": 1, - "5354": 1, - "5355": 1, - "5356": 1, - "5357": 1, - "5358": 1, - "5359": 1, - "536": 1, - "5360": 1, - "5361": 1, - "5362": 1, - "5363": 1, - "5364": 1, - "5365": 1, - "5366": 1, - "5367": 1, - "5368": 1, - "5369": 1, - "537": 1, - "5370": 1, - "5371": 1, - "5372": 1, - "5373": 1, - "5374": 1, - "5375": 1, - "5376": 1, - "5377": 1, - "5378": 1, - "5379": 1, - "538": 1, - "5380": 1, - "5381": 1, - "5382": 1, - "5383": 1, - "5384": 1, - "5385": 1, - "5386": 1, - "5387": 1, - "5388": 1, - "5389": 1, - "539": 1, - "5390": 1, - "5391": 1, - "5392": 1, - "5393": 1, - "5394": 1, - "5395": 1, - "5396": 1, - "5397": 1, - "5398": 1, - "5399": 1, - "54": 1, - "540": 1, - "5400": 1, - "5401": 1, - "5402": 1, - "5403": 1, - "5404": 1, - "5405": 1, - "5406": 1, - "5407": 1, - "5408": 1, - "5409": 1, - "541": 1, - "5410": 1, - "5411": 1, - "5412": 1, - "5413": 1, - "5414": 1, - "5415": 1, - "5416": 1, - "5417": 1, - "5418": 1, - "5419": 1, - "542": 1, - "5420": 1, - "5421": 1, - "5422": 1, - "5423": 1, - "5424": 1, - "5425": 1, - "5426": 1, - "5427": 1, - "5428": 1, - "5429": 1, - "543": 1, - "5430": 1, - "5431": 1, - "5432": 1, - "5433": 1, - "5434": 1, - "5435": 1, - "5436": 1, - "5437": 1, - "5438": 1, - "5439": 1, - "544": 1, - "5440": 1, - "5441": 1, - "5442": 1, - "5443": 1, - "5444": 1, - "5445": 1, - "5446": 1, - "5447": 1, - "5448": 1, - "5449": 1, - "545": 1, - "5450": 1, - "5451": 1, - "5452": 1, - "5453": 1, - "5454": 1, - "5455": 1, - "5456": 1, - "5457": 1, - "5458": 1, - "5459": 1, - "546": 1, - "5460": 1, - "5461": 1, - "5462": 1, - "5463": 1, - "5464": 1, - "5465": 1, - "5466": 1, - "5467": 1, - "5468": 1, - "5469": 1, - "547": 1, - "5470": 1, - "5471": 1, - "5472": 1, - "5473": 1, - "5474": 1, - "5475": 1, - "5476": 1, - "5477": 1, - "5478": 1, - "5479": 1, - "548": 1, - "5480": 1, - "5481": 1, - "5482": 1, - "5483": 1, - "5484": 1, - "5485": 1, - "5486": 1, - "5487": 1, - "5488": 1, - "5489": 1, - "549": 1, - "5490": 1, - "5491": 1, - "5492": 1, - "5493": 1, - "5494": 1, - "5495": 1, - "5496": 1, - "5497": 1, - "5498": 1, - "5499": 1, - "55": 1, - "550": 1, - "5500": 1, - "5501": 1, - "5502": 1, - "5503": 1, - "5504": 1, - "5505": 1, - "5506": 1, - "5507": 1, - "5508": 1, - "5509": 1, - "551": 1, - "5510": 1, - "5511": 1, - "5512": 1, - "5513": 1, - "5514": 1, - "5515": 1, - "5516": 1, - "5517": 1, - "5518": 1, - "5519": 1, - "552": 1, - "5520": 1, - "5521": 1, - "5522": 1, - "5523": 1, - "5524": 1, - "5525": 1, - "5526": 1, - "5527": 1, - "5528": 1, - "5529": 1, - "553": 1, - "5530": 1, - "5531": 1, - "5532": 1, - "5533": 1, - "5534": 1, - "5535": 1, - "5536": 1, - "5537": 1, - "5538": 1, - "5539": 1, - "554": 1, - "5540": 1, - "5541": 1, - "5542": 1, - "5543": 1, - "5544": 1, - "5545": 1, - "5546": 1, - "5547": 1, - "5548": 1, - "5549": 1, - "555": 1, - "5550": 1, - "5551": 1, - "5552": 1, - "5553": 1, - "5554": 1, - "5555": 1, - "5556": 1, - "5557": 1, - "5558": 1, - "5559": 1, - "556": 1, - "5560": 1, - "5561": 1, - "5562": 1, - "5563": 1, - "5564": 1, - "5565": 1, - "5566": 1, - "5567": 1, - "5568": 1, - "5569": 1, - "557": 1, - "5570": 1, - "5571": 1, - "5572": 1, - "5573": 1, - "5574": 1, - "5575": 1, - "5576": 1, - "5577": 1, - "5578": 1, - "5579": 1, - "558": 1, - "5580": 1, - "5581": 1, - "5582": 1, - "5583": 1, - "5584": 1, - "5585": 1, - "5586": 1, - "5587": 1, - "5588": 1, - "5589": 1, - "559": 1, - "5590": 1, - "5591": 1, - "5592": 1, - "5593": 1, - "5594": 1, - "5595": 1, - "5596": 1, - "5597": 1, - "5598": 1, - "5599": 1, - "56": 1, - "560": 1, - "5600": 1, - "5601": 1, - "5602": 1, - "5603": 1, - "5604": 1, - "5605": 1, - "5606": 1, - "5607": 1, - "5608": 1, - "5609": 1, - "561": 1, - "5610": 1, - "5611": 1, - "5612": 1, - "5613": 1, - "5614": 1, - "5615": 1, - "5616": 1, - "5617": 1, - "5618": 1, - "5619": 1, - "562": 1, - "5620": 1, - "5621": 1, - "5622": 1, - "5623": 1, - "5624": 1, - "5625": 1, - "5626": 1, - "5627": 1, - "5628": 1, - "5629": 1, - "563": 1, - "5630": 1, - "5631": 1, - "5632": 1, - "5633": 1, - "5634": 1, - "5635": 1, - "5636": 1, - "5637": 1, - "5638": 1, - "5639": 1, - "564": 1, - "5640": 1, - "5641": 1, - "5642": 1, - "5643": 1, - "5644": 1, - "5645": 1, - "5646": 1, - "5647": 1, - "5648": 1, - "5649": 1, - "565": 1, - "5650": 1, - "5651": 1, - "5652": 1, - "5653": 1, - "5654": 1, - "5655": 1, - "5656": 1, - "5657": 1, - "5658": 1, - "5659": 1, - "566": 1, - "5660": 1, - "5661": 1, - "5662": 1, - "5663": 1, - "5664": 1, - "5665": 1, - "5666": 1, - "5667": 1, - "5668": 1, - "5669": 1, - "567": 1, - "5670": 1, - "5671": 1, - "5672": 1, - "5673": 1, - "5674": 1, - "5675": 1, - "5676": 1, - "5677": 1, - "5678": 1, - "5679": 1, - "568": 1, - "5680": 1, - "5681": 1, - "5682": 1, - "5683": 1, - "5684": 1, - "5685": 1, - "5686": 1, - "5687": 1, - "5688": 1, - "5689": 1, - "569": 1, - "5690": 1, - "5691": 1, - "5692": 1, - "5693": 1, - "5694": 1, - "5695": 1, - "5696": 1, - "5697": 1, - "5698": 1, - "5699": 1, - "57": 1, - "570": 1, - "5700": 1, - "5701": 1, - "5702": 1, - "5703": 1, - "5704": 1, - "5705": 1, - "5706": 1, - "5707": 1, - "5708": 1, - "5709": 1, - "571": 1, - "5710": 1, - "5711": 1, - "5712": 1, - "5713": 1, - "5714": 1, - "5715": 1, - "5716": 1, - "5717": 1, - "5718": 1, - "5719": 1, - "572": 1, - "5720": 1, - "5721": 1, - "5722": 1, - "5723": 1, - "5724": 1, - "5725": 1, - "5726": 1, - "5727": 1, - "5728": 1, - "5729": 1, - "573": 1, - "5730": 1, - "5731": 1, - "5732": 1, - "5733": 1, - "5734": 1, - "5735": 1, - "5736": 1, - "5737": 1, - "5738": 1, - "5739": 1, - "574": 1, - "5740": 1, - "5741": 1, - "5742": 1, - "5743": 1, - "5744": 1, - "5745": 1, - "5746": 1, - "5747": 1, - "5748": 1, - "5749": 1, - "575": 1, - "5750": 1, - "5751": 1, - "5752": 1, - "5753": 1, - "5754": 1, - "5755": 1, - "5756": 1, - "5757": 1, - "5758": 1, - "5759": 1, - "576": 1, - "5760": 1, - "5761": 1, - "5762": 1, - "5763": 1, - "5764": 1, - "5765": 1, - "5766": 1, - "5767": 1, - "5768": 1, - "5769": 1, - "577": 1, - "5770": 1, - "5771": 1, - "5772": 1, - "5773": 1, - "5774": 1, - "5775": 1, - "5776": 1, - "5777": 1, - "5778": 1, - "5779": 1, - "578": 1, - "5780": 1, - "5781": 1, - "5782": 1, - "5783": 1, - "5784": 1, - "5785": 1, - "5786": 1, - "5787": 1, - "5788": 1, - "5789": 1, - "579": 1, - "5790": 1, - "5791": 1, - "5792": 1, - "5793": 1, - "5794": 1, - "5795": 1, - "5796": 1, - "5797": 1, - "5798": 1, - "5799": 1, - "58": 1, - "580": 1, - "5800": 1, - "5801": 1, - "5802": 1, - "5803": 1, - "5804": 1, - "5805": 1, - "5806": 1, - "5807": 1, - "5808": 1, - "5809": 1, - "581": 1, - "5810": 1, - "5811": 1, - "5812": 1, - "5813": 1, - "5814": 1, - "5815": 1, - "5816": 1, - "5817": 1, - "5818": 1, - "5819": 1, - "582": 1, - "5820": 1, - "5821": 1, - "5822": 1, - "5823": 1, - "5824": 1, - "5825": 1, - "5826": 1, - "5827": 1, - "5828": 1, - "5829": 1, - "583": 1, - "5830": 1, - "5831": 1, - "5832": 1, - "5833": 1, - "5834": 1, - "5835": 1, - "5836": 1, - "5837": 1, - "5838": 1, - "5839": 1, - "584": 1, - "5840": 1, - "5841": 1, - "5842": 1, - "5843": 1, - "5844": 1, - "5845": 1, - "5846": 1, - "5847": 1, - "5848": 1, - "5849": 1, - "585": 1, - "5850": 1, - "5851": 1, - "5852": 1, - "5853": 1, - "5854": 1, - "5855": 1, - "5856": 1, - "5857": 1, - "5858": 1, - "5859": 1, - "586": 1, - "5860": 1, - "5861": 1, - "5862": 1, - "5863": 1, - "5864": 1, - "5865": 1, - "5866": 1, - "5867": 1, - "5868": 1, - "5869": 1, - "587": 1, - "5870": 1, - "5871": 1, - "5872": 1, - "5873": 1, - "5874": 1, - "5875": 1, - "5876": 1, - "5877": 1, - "5878": 1, - "5879": 1, - "588": 1, - "5880": 1, - "5881": 1, - "5882": 1, - "5883": 1, - "5884": 1, - "5885": 1, - "5886": 1, - "5887": 1, - "5888": 1, - "5889": 1, - "589": 1, - "5890": 1, - "5891": 1, - "5892": 1, - "5893": 1, - "5894": 1, - "5895": 1, - "5896": 1, - "5897": 1, - "5898": 1, - "5899": 1, - "59": 1, - "590": 1, - "5900": 1, - "5901": 1, - "5902": 1, - "5903": 1, - "5904": 1, - "5905": 1, - "5906": 1, - "5907": 1, - "5908": 1, - "5909": 1, - "591": 1, - "5910": 1, - "5911": 1, - "5912": 1, - "5913": 1, - "5914": 1, - "5915": 1, - "5916": 1, - "5917": 1, - "5918": 1, - "5919": 1, - "592": 1, - "5920": 1, - "5921": 1, - "5922": 1, - "5923": 1, - "5924": 1, - "5925": 1, - "5926": 1, - "5927": 1, - "5928": 1, - "5929": 1, - "593": 1, - "5930": 1, - "5931": 1, - "5932": 1, - "5933": 1, - "5934": 1, - "5935": 1, - "5936": 1, - "5937": 1, - "5938": 1, - "5939": 1, - "594": 1, - "5940": 1, - "5941": 1, - "5942": 1, - "5943": 1, - "5944": 1, - "5945": 1, - "5946": 1, - "5947": 1, - "5948": 1, - "5949": 1, - "595": 1, - "5950": 1, - "5951": 1, - "5952": 1, - "5953": 1, - "5954": 1, - "5955": 1, - "5956": 1, - "5957": 1, - "5958": 1, - "5959": 1, - "596": 1, - "5960": 1, - "5961": 1, - "5962": 1, - "5963": 1, - "5964": 1, - "5965": 1, - "5966": 1, - "5967": 1, - "5968": 1, - "5969": 1, - "597": 1, - "5970": 1, - "5971": 1, - "5972": 1, - "5973": 1, - "5974": 1, - "5975": 1, - "5976": 1, - "5977": 1, - "5978": 1, - "5979": 1, - "598": 1, - "5980": 1, - "5981": 1, - "5982": 1, - "5983": 1, - "5984": 1, - "5985": 1, - "5986": 1, - "5987": 1, - "5988": 1, - "5989": 1, - "599": 1, - "5990": 1, - "5991": 1, - "5992": 1, - "5993": 1, - "5994": 1, - "5995": 1, - "5996": 1, - "5997": 1, - "5998": 1, - "5999": 1, - "6": 1, - "60": 1, - "600": 1, - "6000": 1, - "6001": 1, - "6002": 1, - "6003": 1, - "6004": 1, - "6005": 1, - "6006": 1, - "6007": 1, - "6008": 1, - "6009": 1, - "601": 1, - "6010": 1, - "6011": 1, - "6012": 1, - "6013": 1, - "6014": 1, - "6015": 1, - "6016": 1, - "6017": 1, - "6018": 1, - "6019": 1, - "602": 1, - "6020": 1, - "6021": 1, - "6022": 1, - "6023": 1, - "6024": 1, - "6025": 1, - "6026": 1, - "6027": 1, - "6028": 1, - "6029": 1, - "603": 1, - "6030": 1, - "6031": 1, - "6032": 1, - "6033": 1, - "6034": 1, - "6035": 1, - "6036": 1, - "6037": 1, - "6038": 1, - "6039": 1, - "604": 1, - "6040": 1, - "6041": 1, - "6042": 1, - "6043": 1, - "6044": 1, - "6045": 1, - "6046": 1, - "6047": 1, - "6048": 1, - "6049": 1, - "605": 1, - "6050": 1, - "6051": 1, - "6052": 1, - "6053": 1, - "6054": 1, - "6055": 1, - "6056": 1, - "6057": 1, - "6058": 1, - "6059": 1, - "606": 1, - "6060": 1, - "6061": 1, - "6062": 1, - "6063": 1, - "6064": 1, - "6065": 1, - "6066": 1, - "6067": 1, - "6068": 1, - "6069": 1, - "607": 1, - "6070": 1, - "6071": 1, - "6072": 1, - "6073": 1, - "6074": 1, - "6075": 1, - "6076": 1, - "6077": 1, - "6078": 1, - "6079": 1, - "608": 1, - "6080": 1, - "6081": 1, - "6082": 1, - "6083": 1, - "6084": 1, - "6085": 1, - "6086": 1, - "6087": 1, - "6088": 1, - "6089": 1, - "609": 1, - "6090": 1, - "6091": 1, - "6092": 1, - "6093": 1, - "6094": 1, - "6095": 1, - "6096": 1, - "6097": 1, - "6098": 1, - "6099": 1, - "61": 1, - "610": 1, - "6100": 1, - "6101": 1, - "6102": 1, - "6103": 1, - "6104": 1, - "6105": 1, - "6106": 1, - "6107": 1, - "6108": 1, - "6109": 1, - "611": 1, - "6110": 1, - "6111": 1, - "6112": 1, - "6113": 1, - "6114": 1, - "6115": 1, - "6116": 1, - "6117": 1, - "6118": 1, - "6119": 1, - "612": 1, - "6120": 1, - "6121": 1, - "6122": 1, - "6123": 1, - "6124": 1, - "6125": 1, - "6126": 1, - "6127": 1, - "6128": 1, - "6129": 1, - "613": 1, - "6130": 1, - "6131": 1, - "6132": 1, - "6133": 1, - "6134": 1, - "6135": 1, - "6136": 1, - "6137": 1, - "6138": 1, - "6139": 1, - "614": 1, - "6140": 1, - "6141": 1, - "6142": 1, - "6143": 1, - "6144": 1, - "6145": 1, - "6146": 1, - "6147": 1, - "6148": 1, - "6149": 1, - "615": 1, - "6150": 1, - "6151": 1, - "6152": 1, - "6153": 1, - "6154": 1, - "6155": 1, - "6156": 1, - "6157": 1, - "6158": 1, - "6159": 1, - "616": 1, - "6160": 1, - "6161": 1, - "6162": 1, - "6163": 1, - "6164": 1, - "6165": 1, - "6166": 1, - "6167": 1, - "6168": 1, - "6169": 1, - "617": 1, - "6170": 1, - "6171": 1, - "6172": 1, - "6173": 1, - "6174": 1, - "6175": 1, - "6176": 1, - "6177": 1, - "6178": 1, - "6179": 1, - "618": 1, - "6180": 1, - "6181": 1, - "6182": 1, - "6183": 1, - "6184": 1, - "6185": 1, - "6186": 1, - "6187": 1, - "6188": 1, - "6189": 1, - "619": 1, - "6190": 1, - "6191": 1, - "6192": 1, - "6193": 1, - "6194": 1, - "6195": 1, - "6196": 1, - "6197": 1, - "6198": 1, - "6199": 1, - "62": 1, - "620": 1, - "6200": 1, - "6201": 1, - "6202": 1, - "6203": 1, - "6204": 1, - "6205": 1, - "6206": 1, - "6207": 1, - "6208": 1, - "6209": 1, - "621": 1, - "6210": 1, - "6211": 1, - "6212": 1, - "6213": 1, - "6214": 1, - "6215": 1, - "6216": 1, - "6217": 1, - "6218": 1, - "6219": 1, - "622": 1, - "6220": 1, - "6221": 1, - "6222": 1, - "6223": 1, - "6224": 1, - "6225": 1, - "6226": 1, - "6227": 1, - "6228": 1, - "6229": 1, - "623": 1, - "6230": 1, - "6231": 1, - "6232": 1, - "6233": 1, - "6234": 1, - "6235": 1, - "6236": 1, - "6237": 1, - "6238": 1, - "6239": 1, - "624": 1, - "6240": 1, - "6241": 1, - "6242": 1, - "6243": 1, - "6244": 1, - "6245": 1, - "6246": 1, - "6247": 1, - "6248": 1, - "6249": 1, - "625": 1, - "6250": 1, - "6251": 1, - "6252": 1, - "6253": 1, - "6254": 1, - "6255": 1, - "6256": 1, - "6257": 1, - "6258": 1, - "6259": 1, - "626": 1, - "6260": 1, - "6261": 1, - "6262": 1, - "6263": 1, - "6264": 1, - "6265": 1, - "6266": 1, - "6267": 1, - "6268": 1, - "6269": 1, - "627": 1, - "6270": 1, - "6271": 1, - "6272": 1, - "6273": 1, - "6274": 1, - "6275": 1, - "6276": 1, - "6277": 1, - "6278": 1, - "6279": 1, - "628": 1, - "6280": 1, - "6281": 1, - "6282": 1, - "6283": 1, - "6284": 1, - "6285": 1, - "6286": 1, - "6287": 1, - "6288": 1, - "6289": 1, - "629": 1, - "6290": 1, - "6291": 1, - "6292": 1, - "6293": 1, - "6294": 1, - "6295": 1, - "6296": 1, - "6297": 1, - "6298": 1, - "6299": 1, - "63": 1, - "630": 1, - "6300": 1, - "6301": 1, - "6302": 1, - "6303": 1, - "6304": 1, - "6305": 1, - "6306": 1, - "6307": 1, - "6308": 1, - "6309": 1, - "631": 1, - "6310": 1, - "6311": 1, - "6312": 1, - "6313": 1, - "6314": 1, - "6315": 1, - "6316": 1, - "6317": 1, - "6318": 1, - "6319": 1, - "632": 1, - "6320": 1, - "6321": 1, - "6322": 1, - "6323": 1, - "6324": 1, - "6325": 1, - "6326": 1, - "6327": 1, - "6328": 1, - "6329": 1, - "633": 1, - "6330": 1, - "6331": 1, - "6332": 1, - "6333": 1, - "6334": 1, - "6335": 1, - "6336": 1, - "6337": 1, - "6338": 1, - "6339": 1, - "634": 1, - "6340": 1, - "6341": 1, - "6342": 1, - "6343": 1, - "6344": 1, - "6345": 1, - "6346": 1, - "6347": 1, - "6348": 1, - "6349": 1, - "635": 1, - "6350": 1, - "6351": 1, - "6352": 1, - "6353": 1, - "6354": 1, - "6355": 1, - "6356": 1, - "6357": 1, - "6358": 1, - "6359": 1, - "636": 1, - "6360": 1, - "6361": 1, - "6362": 1, - "6363": 1, - "6364": 1, - "6365": 1, - "6366": 1, - "6367": 1, - "6368": 1, - "6369": 1, - "637": 1, - "6370": 1, - "6371": 1, - "6372": 1, - "6373": 1, - "6374": 1, - "6375": 1, - "6376": 1, - "6377": 1, - "6378": 1, - "6379": 1, - "638": 1, - "6380": 1, - "6381": 1, - "6382": 1, - "6383": 1, - "6384": 1, - "6385": 1, - "6386": 1, - "6387": 1, - "6388": 1, - "6389": 1, - "639": 1, - "6390": 1, - "6391": 1, - "6392": 1, - "6393": 1, - "6394": 1, - "6395": 1, - "6396": 1, - "6397": 1, - "6398": 1, - "6399": 1, - "64": 1, - "640": 1, - "6400": 1, - "6401": 1, - "6402": 1, - "6403": 1, - "6404": 1, - "6405": 1, - "6406": 1, - "6407": 1, - "6408": 1, - "6409": 1, - "641": 1, - "6410": 1, - "6411": 1, - "6412": 1, - "6413": 1, - "6414": 1, - "6415": 1, - "6416": 1, - "6417": 1, - "6418": 1, - "6419": 1, - "642": 1, - "6420": 1, - "6421": 1, - "6422": 1, - "6423": 1, - "6424": 1, - "6425": 1, - "6426": 1, - "6427": 1, - "6428": 1, - "6429": 1, - "643": 1, - "6430": 1, - "6431": 1, - "6432": 1, - "6433": 1, - "6434": 1, - "6435": 1, - "6436": 1, - "6437": 1, - "6438": 1, - "6439": 1, - "644": 1, - "6440": 1, - "6441": 1, - "6442": 1, - "6443": 1, - "6444": 1, - "6445": 1, - "6446": 1, - "6447": 1, - "6448": 1, - "6449": 1, - "645": 1, - "6450": 1, - "6451": 1, - "6452": 1, - "6453": 1, - "6454": 1, - "6455": 1, - "6456": 1, - "6457": 1, - "6458": 1, - "6459": 1, - "646": 1, - "6460": 1, - "6461": 1, - "6462": 1, - "6463": 1, - "6464": 1, - "6465": 1, - "6466": 1, - "6467": 1, - "6468": 1, - "6469": 1, - "647": 1, - "6470": 1, - "6471": 1, - "6472": 1, - "6473": 1, - "6474": 1, - "6475": 1, - "6476": 1, - "6477": 1, - "6478": 1, - "6479": 1, - "648": 1, - "6480": 1, - "6481": 1, - "6482": 1, - "6483": 1, - "6484": 1, - "6485": 1, - "6486": 1, - "6487": 1, - "6488": 1, - "6489": 1, - "649": 1, - "6490": 1, - "6491": 1, - "6492": 1, - "6493": 1, - "6494": 1, - "6495": 1, - "6496": 1, - "6497": 1, - "6498": 1, - "6499": 1, - "65": 1, - "650": 1, - "6500": 1, - "6501": 1, - "6502": 1, - "6503": 1, - "6504": 1, - "6505": 1, - "6506": 1, - "6507": 1, - "6508": 1, - "6509": 1, - "651": 1, - "6510": 1, - "6511": 1, - "6512": 1, - "6513": 1, - "6514": 1, - "6515": 1, - "6516": 1, - "6517": 1, - "6518": 1, - "6519": 1, - "652": 1, - "6520": 1, - "6521": 1, - "6522": 1, - "6523": 1, - "6524": 1, - "6525": 1, - "6526": 1, - "6527": 1, - "6528": 1, - "6529": 1, - "653": 1, - "6530": 1, - "6531": 1, - "6532": 1, - "6533": 1, - "6534": 1, - "6535": 1, - "6536": 1, - "6537": 1, - "6538": 1, - "6539": 1, - "654": 1, - "6540": 1, - "6541": 1, - "6542": 1, - "6543": 1, - "6544": 1, - "6545": 1, - "6546": 1, - "6547": 1, - "6548": 1, - "6549": 1, - "655": 1, - "6550": 1, - "6551": 1, - "6552": 1, - "6553": 1, - "6554": 1, - "6555": 1, - "6556": 1, - "6557": 1, - "6558": 1, - "6559": 1, - "656": 1, - "6560": 1, - "6561": 1, - "6562": 1, - "6563": 1, - "6564": 1, - "6565": 1, - "6566": 1, - "6567": 1, - "6568": 1, - "6569": 1, - "657": 1, - "6570": 1, - "6571": 1, - "6572": 1, - "6573": 1, - "6574": 1, - "6575": 1, - "6576": 1, - "6577": 1, - "6578": 1, - "6579": 1, - "658": 1, - "6580": 1, - "6581": 1, - "6582": 1, - "6583": 1, - "6584": 1, - "6585": 1, - "6586": 1, - "6587": 1, - "6588": 1, - "6589": 1, - "659": 1, - "6590": 1, - "6591": 1, - "6592": 1, - "6593": 1, - "6594": 1, - "6595": 1, - "6596": 1, - "6597": 1, - "6598": 1, - "6599": 1, - "66": 1, - "660": 1, - "6600": 1, - "6601": 1, - "6602": 1, - "6603": 1, - "6604": 1, - "6605": 1, - "6606": 1, - "6607": 1, - "6608": 1, - "6609": 1, - "661": 1, - "6610": 1, - "6611": 1, - "6612": 1, - "6613": 1, - "6614": 1, - "6615": 1, - "6616": 1, - "6617": 1, - "6618": 1, - "6619": 1, - "662": 1, - "6620": 1, - "6621": 1, - "6622": 1, - "6623": 1, - "6624": 1, - "6625": 1, - "6626": 1, - "6627": 1, - "6628": 1, - "6629": 1, - "663": 1, - "6630": 1, - "6631": 1, - "6632": 1, - "6633": 1, - "6634": 1, - "6635": 1, - "6636": 1, - "6637": 1, - "6638": 1, - "6639": 1, - "664": 1, - "6640": 1, - "6641": 1, - "6642": 1, - "6643": 1, - "6644": 1, - "6645": 1, - "6646": 1, - "6647": 1, - "6648": 1, - "6649": 1, - "665": 1, - "6650": 1, - "6651": 1, - "6652": 1, - "6653": 1, - "6654": 1, - "6655": 1, - "6656": 1, - "6657": 1, - "6658": 1, - "6659": 1, - "666": 1, - "6660": 1, - "6661": 1, - "6662": 1, - "6663": 1, - "6664": 1, - "6665": 1, - "6666": 1, - "6667": 1, - "6668": 1, - "6669": 1, - "667": 1, - "6670": 1, - "6671": 1, - "6672": 1, - "6673": 1, - "6674": 1, - "6675": 1, - "6676": 1, - "6677": 1, - "6678": 1, - "6679": 1, - "668": 1, - "6680": 1, - "6681": 1, - "6682": 1, - "6683": 1, - "6684": 1, - "6685": 1, - "6686": 1, - "6687": 1, - "6688": 1, - "6689": 1, - "669": 1, - "6690": 1, - "6691": 1, - "6692": 1, - "6693": 1, - "6694": 1, - "6695": 1, - "6696": 1, - "6697": 1, - "6698": 1, - "6699": 1, - "67": 1, - "670": 1, - "6700": 1, - "6701": 1, - "6702": 1, - "6703": 1, - "6704": 1, - "6705": 1, - "6706": 1, - "6707": 1, - "6708": 1, - "6709": 1, - "671": 1, - "6710": 1, - "6711": 1, - "6712": 1, - "6713": 1, - "6714": 1, - "6715": 1, - "6716": 1, - "6717": 1, - "6718": 1, - "6719": 1, - "672": 1, - "6720": 1, - "6721": 1, - "6722": 1, - "6723": 1, - "6724": 1, - "6725": 1, - "6726": 1, - "6727": 1, - "6728": 1, - "6729": 1, - "673": 1, - "6730": 1, - "6731": 1, - "6732": 1, - "6733": 1, - "6734": 1, - "6735": 1, - "6736": 1, - "6737": 1, - "6738": 1, - "6739": 1, - "674": 1, - "6740": 1, - "6741": 1, - "6742": 1, - "6743": 1, - "6744": 1, - "6745": 1, - "6746": 1, - "6747": 1, - "6748": 1, - "6749": 1, - "675": 1, - "6750": 1, - "6751": 1, - "6752": 1, - "6753": 1, - "6754": 1, - "6755": 1, - "6756": 1, - "6757": 1, - "6758": 1, - "6759": 1, - "676": 1, - "6760": 1, - "6761": 1, - "6762": 1, - "6763": 1, - "6764": 1, - "6765": 1, - "6766": 1, - "6767": 1, - "6768": 1, - "6769": 1, - "677": 1, - "6770": 1, - "6771": 1, - "6772": 1, - "6773": 1, - "6774": 1, - "6775": 1, - "6776": 1, - "6777": 1, - "6778": 1, - "6779": 1, - "678": 1, - "6780": 1, - "6781": 1, - "6782": 1, - "6783": 1, - "6784": 1, - "6785": 1, - "6786": 1, - "6787": 1, - "6788": 1, - "6789": 1, - "679": 1, - "6790": 1, - "6791": 1, - "6792": 1, - "6793": 1, - "6794": 1, - "6795": 1, - "6796": 1, - "6797": 1, - "6798": 1, - "6799": 1, - "68": 1, - "680": 1, - "6800": 1, - "6801": 1, - "6802": 1, - "6803": 1, - "6804": 1, - "6805": 1, - "6806": 1, - "6807": 1, - "6808": 1, - "6809": 1, - "681": 1, - "6810": 1, - "6811": 1, - "6812": 1, - "6813": 1, - "6814": 1, - "6815": 1, - "6816": 1, - "6817": 1, - "6818": 1, - "6819": 1, - "682": 1, - "6820": 1, - "6821": 1, - "6822": 1, - "6823": 1, - "6824": 1, - "6825": 1, - "6826": 1, - "6827": 1, - "6828": 1, - "6829": 1, - "683": 1, - "6830": 1, - "6831": 1, - "6832": 1, - "6833": 1, - "6834": 1, - "6835": 1, - "6836": 1, - "6837": 1, - "6838": 1, - "6839": 1, - "684": 1, - "6840": 1, - "6841": 1, - "6842": 1, - "6843": 1, - "6844": 1, - "6845": 1, - "6846": 1, - "6847": 1, - "6848": 1, - "6849": 1, - "685": 1, - "6850": 1, - "6851": 1, - "6852": 1, - "6853": 1, - "6854": 1, - "6855": 1, - "6856": 1, - "6857": 1, - "6858": 1, - "6859": 1, - "686": 1, - "6860": 1, - "6861": 1, - "6862": 1, - "6863": 1, - "6864": 1, - "6865": 1, - "6866": 1, - "6867": 1, - "6868": 1, - "6869": 1, - "687": 1, - "6870": 1, - "6871": 1, - "6872": 1, - "6873": 1, - "6874": 1, - "6875": 1, - "6876": 1, - "6877": 1, - "6878": 1, - "6879": 1, - "688": 1, - "6880": 1, - "6881": 1, - "6882": 1, - "6883": 1, - "6884": 1, - "6885": 1, - "6886": 1, - "6887": 1, - "6888": 1, - "6889": 1, - "689": 1, - "6890": 1, - "6891": 1, - "6892": 1, - "6893": 1, - "6894": 1, - "6895": 1, - "6896": 1, - "6897": 1, - "6898": 1, - "6899": 1, - "69": 1, - "690": 1, - "6900": 1, - "6901": 1, - "6902": 1, - "6903": 1, - "6904": 1, - "6905": 1, - "6906": 1, - "6907": 1, - "6908": 1, - "6909": 1, - "691": 1, - "6910": 1, - "6911": 1, - "6912": 1, - "6913": 1, - "6914": 1, - "6915": 1, - "6916": 1, - "6917": 1, - "6918": 1, - "6919": 1, - "692": 1, - "6920": 1, - "6921": 1, - "6922": 1, - "6923": 1, - "6924": 1, - "6925": 1, - "6926": 1, - "6927": 1, - "6928": 1, - "6929": 1, - "693": 1, - "6930": 1, - "6931": 1, - "6932": 1, - "6933": 1, - "6934": 1, - "6935": 1, - "6936": 1, - "6937": 1, - "6938": 1, - "6939": 1, - "694": 1, - "6940": 1, - "6941": 1, - "6942": 1, - "6943": 1, - "6944": 1, - "6945": 1, - "6946": 1, - "6947": 1, - "6948": 1, - "6949": 1, - "695": 1, - "6950": 1, - "6951": 1, - "6952": 1, - "6953": 1, - "6954": 1, - "6955": 1, - "6956": 1, - "6957": 1, - "6958": 1, - "6959": 1, - "696": 1, - "6960": 1, - "6961": 1, - "6962": 1, - "6963": 1, - "6964": 1, - "6965": 1, - "6966": 1, - "6967": 1, - "6968": 1, - "6969": 1, - "697": 1, - "6970": 1, - "6971": 1, - "6972": 1, - "6973": 1, - "6974": 1, - "6975": 1, - "6976": 1, - "6977": 1, - "6978": 1, - "6979": 1, - "698": 1, - "6980": 1, - "6981": 1, - "6982": 1, - "6983": 1, - "6984": 1, - "6985": 1, - "6986": 1, - "6987": 1, - "6988": 1, - "6989": 1, - "699": 1, - "6990": 1, - "6991": 1, - "6992": 1, - "6993": 1, - "6994": 1, - "6995": 1, - "6996": 1, - "6997": 1, - "6998": 1, - "6999": 1, - "7": 1, - "70": 1, - "700": 1, - "7000": 1, - "7001": 1, - "7002": 1, - "7003": 1, - "7004": 1, - "7005": 1, - "7006": 1, - "7007": 1, - "7008": 1, - "7009": 1, - "701": 1, - "7010": 1, - "7011": 1, - "7012": 1, - "7013": 1, - "7014": 1, - "7015": 1, - "7016": 1, - "7017": 1, - "7018": 1, - "7019": 1, - "702": 1, - "7020": 1, - "7021": 1, - "7022": 1, - "7023": 1, - "7024": 1, - "7025": 1, - "7026": 1, - "7027": 1, - "7028": 1, - "7029": 1, - "703": 1, - "7030": 1, - "7031": 1, - "7032": 1, - "7033": 1, - "7034": 1, - "7035": 1, - "7036": 1, - "7037": 1, - "7038": 1, - "7039": 1, - "704": 1, - "7040": 1, - "7041": 1, - "7042": 1, - "7043": 1, - "7044": 1, - "7045": 1, - "7046": 1, - "7047": 1, - "7048": 1, - "7049": 1, - "705": 1, - "7050": 1, - "7051": 1, - "7052": 1, - "7053": 1, - "7054": 1, - "7055": 1, - "7056": 1, - "7057": 1, - "7058": 1, - "7059": 1, - "706": 1, - "7060": 1, - "7061": 1, - "7062": 1, - "7063": 1, - "7064": 1, - "7065": 1, - "7066": 1, - "7067": 1, - "7068": 1, - "7069": 1, - "707": 1, - "7070": 1, - "7071": 1, - "7072": 1, - "7073": 1, - "7074": 1, - "7075": 1, - "7076": 1, - "7077": 1, - "7078": 1, - "7079": 1, - "708": 1, - "7080": 1, - "7081": 1, - "7082": 1, - "7083": 1, - "7084": 1, - "7085": 1, - "7086": 1, - "7087": 1, - "7088": 1, - "7089": 1, - "709": 1, - "7090": 1, - "7091": 1, - "7092": 1, - "7093": 1, - "7094": 1, - "7095": 1, - "7096": 1, - "7097": 1, - "7098": 1, - "7099": 1, - "71": 1, - "710": 1, - "7100": 1, - "7101": 1, - "7102": 1, - "7103": 1, - "7104": 1, - "7105": 1, - "7106": 1, - "7107": 1, - "7108": 1, - "7109": 1, - "711": 1, - "7110": 1, - "7111": 1, - "7112": 1, - "7113": 1, - "7114": 1, - "7115": 1, - "7116": 1, - "7117": 1, - "7118": 1, - "7119": 1, - "712": 1, - "7120": 1, - "7121": 1, - "7122": 1, - "7123": 1, - "7124": 1, - "7125": 1, - "7126": 1, - "7127": 1, - "7128": 1, - "7129": 1, - "713": 1, - "7130": 1, - "7131": 1, - "7132": 1, - "7133": 1, - "7134": 1, - "7135": 1, - "7136": 1, - "7137": 1, - "7138": 1, - "7139": 1, - "714": 1, - "7140": 1, - "7141": 1, - "7142": 1, - "7143": 1, - "7144": 1, - "7145": 1, - "7146": 1, - "7147": 1, - "7148": 1, - "7149": 1, - "715": 1, - "7150": 1, - "7151": 1, - "7152": 1, - "7153": 1, - "7154": 1, - "7155": 1, - "7156": 1, - "7157": 1, - "7158": 1, - "7159": 1, - "716": 1, - "7160": 1, - "7161": 1, - "7162": 1, - "7163": 1, - "7164": 1, - "7165": 1, - "7166": 1, - "7167": 1, - "7168": 1, - "7169": 1, - "717": 1, - "7170": 1, - "7171": 1, - "7172": 1, - "7173": 1, - "7174": 1, - "7175": 1, - "7176": 1, - "7177": 1, - "7178": 1, - "7179": 1, - "718": 1, - "7180": 1, - "7181": 1, - "7182": 1, - "7183": 1, - "7184": 1, - "7185": 1, - "7186": 1, - "7187": 1, - "7188": 1, - "7189": 1, - "719": 1, - "7190": 1, - "7191": 1, - "7192": 1, - "7193": 1, - "7194": 1, - "7195": 1, - "7196": 1, - "7197": 1, - "7198": 1, - "7199": 1, - "72": 1, - "720": 1, - "7200": 1, - "7201": 1, - "7202": 1, - "7203": 1, - "7204": 1, - "7205": 1, - "7206": 1, - "7207": 1, - "7208": 1, - "7209": 1, - "721": 1, - "7210": 1, - "7211": 1, - "7212": 1, - "7213": 1, - "7214": 1, - "7215": 1, - "7216": 1, - "7217": 1, - "7218": 1, - "7219": 1, - "722": 1, - "7220": 1, - "7221": 1, - "7222": 1, - "7223": 1, - "7224": 1, - "7225": 1, - "7226": 1, - "7227": 1, - "7228": 1, - "7229": 1, - "723": 1, - "7230": 1, - "7231": 1, - "7232": 1, - "7233": 1, - "7234": 1, - "7235": 1, - "7236": 1, - "7237": 1, - "7238": 1, - "7239": 1, - "724": 1, - "7240": 1, - "7241": 1, - "7242": 1, - "7243": 1, - "7244": 1, - "7245": 1, - "7246": 1, - "7247": 1, - "7248": 1, - "7249": 1, - "725": 1, - "7250": 1, - "7251": 1, - "7252": 1, - "7253": 1, - "7254": 1, - "7255": 1, - "7256": 1, - "7257": 1, - "7258": 1, - "7259": 1, - "726": 1, - "7260": 1, - "7261": 1, - "7262": 1, - "7263": 1, - "7264": 1, - "7265": 1, - "7266": 1, - "7267": 1, - "7268": 1, - "7269": 1, - "727": 1, - "7270": 1, - "7271": 1, - "7272": 1, - "7273": 1, - "7274": 1, - "7275": 1, - "7276": 1, - "7277": 1, - "7278": 1, - "7279": 1, - "728": 1, - "7280": 1, - "7281": 1, - "7282": 1, - "7283": 1, - "7284": 1, - "7285": 1, - "7286": 1, - "7287": 1, - "7288": 1, - "7289": 1, - "729": 1, - "7290": 1, - "7291": 1, - "7292": 1, - "7293": 1, - "7294": 1, - "7295": 1, - "7296": 1, - "7297": 1, - "7298": 1, - "7299": 1, - "73": 1, - "730": 1, - "7300": 1, - "7301": 1, - "7302": 1, - "7303": 1, - "7304": 1, - "7305": 1, - "7306": 1, - "7307": 1, - "7308": 1, - "7309": 1, - "731": 1, - "7310": 1, - "7311": 1, - "7312": 1, - "7313": 1, - "7314": 1, - "7315": 1, - "7316": 1, - "7317": 1, - "7318": 1, - "7319": 1, - "732": 1, - "7320": 1, - "7321": 1, - "7322": 1, - "7323": 1, - "7324": 1, - "7325": 1, - "7326": 1, - "7327": 1, - "7328": 1, - "7329": 1, - "733": 1, - "7330": 1, - "7331": 1, - "7332": 1, - "7333": 1, - "7334": 1, - "7335": 1, - "7336": 1, - "7337": 1, - "7338": 1, - "7339": 1, - "734": 1, - "7340": 1, - "7341": 1, - "7342": 1, - "7343": 1, - "7344": 1, - "7345": 1, - "7346": 1, - "7347": 1, - "7348": 1, - "7349": 1, - "735": 1, - "7350": 1, - "7351": 1, - "7352": 1, - "7353": 1, - "7354": 1, - "7355": 1, - "7356": 1, - "7357": 1, - "7358": 1, - "7359": 1, - "736": 1, - "7360": 1, - "7361": 1, - "7362": 1, - "7363": 1, - "7364": 1, - "7365": 1, - "7366": 1, - "7367": 1, - "7368": 1, - "7369": 1, - "737": 1, - "7370": 1, - "7371": 1, - "7372": 1, - "7373": 1, - "7374": 1, - "7375": 1, - "7376": 1, - "7377": 1, - "7378": 1, - "7379": 1, - "738": 1, - "7380": 1, - "7381": 1, - "7382": 1, - "7383": 1, - "7384": 1, - "7385": 1, - "7386": 1, - "7387": 1, - "7388": 1, - "7389": 1, - "739": 1, - "7390": 1, - "7391": 1, - "7392": 1, - "7393": 1, - "7394": 1, - "7395": 1, - "7396": 1, - "7397": 1, - "7398": 1, - "7399": 1, - "74": 1, - "740": 1, - "7400": 1, - "7401": 1, - "7402": 1, - "7403": 1, - "7404": 1, - "7405": 1, - "7406": 1, - "7407": 1, - "7408": 1, - "7409": 1, - "741": 1, - "7410": 1, - "7411": 1, - "7412": 1, - "7413": 1, - "7414": 1, - "7415": 1, - "7416": 1, - "7417": 1, - "7418": 1, - "7419": 1, - "742": 1, - "7420": 1, - "7421": 1, - "7422": 1, - "7423": 1, - "7424": 1, - "7425": 1, - "7426": 1, - "7427": 1, - "7428": 1, - "7429": 1, - "743": 1, - "7430": 1, - "7431": 1, - "7432": 1, - "7433": 1, - "7434": 1, - "7435": 1, - "7436": 1, - "7437": 1, - "7438": 1, - "7439": 1, - "744": 1, - "7440": 1, - "7441": 1, - "7442": 1, - "7443": 1, - "7444": 1, - "7445": 1, - "7446": 1, - "7447": 1, - "7448": 1, - "7449": 1, - "745": 1, - "7450": 1, - "7451": 1, - "7452": 1, - "7453": 1, - "7454": 1, - "7455": 1, - "7456": 1, - "7457": 1, - "7458": 1, - "7459": 1, - "746": 1, - "7460": 1, - "7461": 1, - "7462": 1, - "7463": 1, - "7464": 1, - "7465": 1, - "7466": 1, - "7467": 1, - "7468": 1, - "7469": 1, - "747": 1, - "7470": 1, - "7471": 1, - "7472": 1, - "7473": 1, - "7474": 1, - "7475": 1, - "7476": 1, - "7477": 1, - "7478": 1, - "7479": 1, - "748": 1, - "7480": 1, - "7481": 1, - "7482": 1, - "7483": 1, - "7484": 1, - "7485": 1, - "7486": 1, - "7487": 1, - "7488": 1, - "7489": 1, - "749": 1, - "7490": 1, - "7491": 1, - "7492": 1, - "7493": 1, - "7494": 1, - "7495": 1, - "7496": 1, - "7497": 1, - "7498": 1, - "7499": 1, - "75": 1, - "750": 1, - "7500": 1, - "7501": 1, - "7502": 1, - "7503": 1, - "7504": 1, - "7505": 1, - "7506": 1, - "7507": 1, - "7508": 1, - "7509": 1, - "751": 1, - "7510": 1, - "7511": 1, - "7512": 1, - "7513": 1, - "7514": 1, - "7515": 1, - "7516": 1, - "7517": 1, - "7518": 1, - "7519": 1, - "752": 1, - "7520": 1, - "7521": 1, - "7522": 1, - "7523": 1, - "7524": 1, - "7525": 1, - "7526": 1, - "7527": 1, - "7528": 1, - "7529": 1, - "753": 1, - "7530": 1, - "7531": 1, - "7532": 1, - "7533": 1, - "7534": 1, - "7535": 1, - "7536": 1, - "7537": 1, - "7538": 1, - "7539": 1, - "754": 1, - "7540": 1, - "7541": 1, - "7542": 1, - "7543": 1, - "7544": 1, - "7545": 1, - "7546": 1, - "7547": 1, - "7548": 1, - "7549": 1, - "755": 1, - "7550": 1, - "7551": 1, - "7552": 1, - "7553": 1, - "7554": 1, - "7555": 1, - "7556": 1, - "7557": 1, - "7558": 1, - "7559": 1, - "756": 1, - "7560": 1, - "7561": 1, - "7562": 1, - "7563": 1, - "7564": 1, - "7565": 1, - "7566": 1, - "7567": 1, - "7568": 1, - "7569": 1, - "757": 1, - "7570": 1, - "7571": 1, - "7572": 1, - "7573": 1, - "7574": 1, - "7575": 1, - "7576": 1, - "7577": 1, - "7578": 1, - "7579": 1, - "758": 1, - "7580": 1, - "7581": 1, - "7582": 1, - "7583": 1, - "7584": 1, - "7585": 1, - "7586": 1, - "7587": 1, - "7588": 1, - "7589": 1, - "759": 1, - "7590": 1, - "7591": 1, - "7592": 1, - "7593": 1, - "7594": 1, - "7595": 1, - "7596": 1, - "7597": 1, - "7598": 1, - "7599": 1, - "76": 1, - "760": 1, - "7600": 1, - "7601": 1, - "7602": 1, - "7603": 1, - "7604": 1, - "7605": 1, - "7606": 1, - "7607": 1, - "7608": 1, - "7609": 1, - "761": 1, - "7610": 1, - "7611": 1, - "7612": 1, - "7613": 1, - "7614": 1, - "7615": 1, - "7616": 1, - "7617": 1, - "7618": 1, - "7619": 1, - "762": 1, - "7620": 1, - "7621": 1, - "7622": 1, - "7623": 1, - "7624": 1, - "7625": 1, - "7626": 1, - "7627": 1, - "7628": 1, - "7629": 1, - "763": 1, - "7630": 1, - "7631": 1, - "7632": 1, - "7633": 1, - "7634": 1, - "7635": 1, - "7636": 1, - "7637": 1, - "7638": 1, - "7639": 1, - "764": 1, - "7640": 1, - "7641": 1, - "7642": 1, - "7643": 1, - "7644": 1, - "7645": 1, - "7646": 1, - "7647": 1, - "7648": 1, - "7649": 1, - "765": 1, - "7650": 1, - "7651": 1, - "7652": 1, - "7653": 1, - "7654": 1, - "7655": 1, - "7656": 1, - "7657": 1, - "7658": 1, - "7659": 1, - "766": 1, - "7660": 1, - "7661": 1, - "7662": 1, - "7663": 1, - "7664": 1, - "7665": 1, - "7666": 1, - "7667": 1, - "7668": 1, - "7669": 1, - "767": 1, - "7670": 1, - "7671": 1, - "7672": 1, - "7673": 1, - "7674": 1, - "7675": 1, - "7676": 1, - "7677": 1, - "7678": 1, - "7679": 1, - "768": 1, - "7680": 1, - "7681": 1, - "7682": 1, - "7683": 1, - "7684": 1, - "7685": 1, - "7686": 1, - "7687": 1, - "7688": 1, - "7689": 1, - "769": 1, - "7690": 1, - "7691": 1, - "7692": 1, - "7693": 1, - "7694": 1, - "7695": 1, - "7696": 1, - "7697": 1, - "7698": 1, - "7699": 1, - "77": 1, - "770": 1, - "7700": 1, - "7701": 1, - "7702": 1, - "7703": 1, - "7704": 1, - "7705": 1, - "7706": 1, - "7707": 1, - "7708": 1, - "7709": 1, - "771": 1, - "7710": 1, - "7711": 1, - "7712": 1, - "7713": 1, - "7714": 1, - "7715": 1, - "7716": 1, - "7717": 1, - "7718": 1, - "7719": 1, - "772": 1, - "7720": 1, - "7721": 1, - "7722": 1, - "7723": 1, - "7724": 1, - "7725": 1, - "7726": 1, - "7727": 1, - "7728": 1, - "7729": 1, - "773": 1, - "7730": 1, - "7731": 1, - "7732": 1, - "7733": 1, - "7734": 1, - "7735": 1, - "7736": 1, - "7737": 1, - "7738": 1, - "7739": 1, - "774": 1, - "7740": 1, - "7741": 1, - "7742": 1, - "7743": 1, - "7744": 1, - "7745": 1, - "7746": 1, - "7747": 1, - "7748": 1, - "7749": 1, - "775": 1, - "7750": 1, - "7751": 1, - "7752": 1, - "7753": 1, - "7754": 1, - "7755": 1, - "7756": 1, - "7757": 1, - "7758": 1, - "7759": 1, - "776": 1, - "7760": 1, - "7761": 1, - "7762": 1, - "7763": 1, - "7764": 1, - "7765": 1, - "7766": 1, - "7767": 1, - "7768": 1, - "7769": 1, - "777": 1, - "7770": 1, - "7771": 1, - "7772": 1, - "7773": 1, - "7774": 1, - "7775": 1, - "7776": 1, - "7777": 1, - "7778": 1, - "7779": 1, - "778": 1, - "7780": 1, - "7781": 1, - "7782": 1, - "7783": 1, - "7784": 1, - "7785": 1, - "7786": 1, - "7787": 1, - "7788": 1, - "7789": 1, - "779": 1, - "7790": 1, - "7791": 1, - "7792": 1, - "7793": 1, - "7794": 1, - "7795": 1, - "7796": 1, - "7797": 1, - "7798": 1, - "7799": 1, - "78": 1, - "780": 1, - "7800": 1, - "7801": 1, - "7802": 1, - "7803": 1, - "7804": 1, - "7805": 1, - "7806": 1, - "7807": 1, - "7808": 1, - "7809": 1, - "781": 1, - "7810": 1, - "7811": 1, - "7812": 1, - "7813": 1, - "7814": 1, - "7815": 1, - "7816": 1, - "7817": 1, - "7818": 1, - "7819": 1, - "782": 1, - "7820": 1, - "7821": 1, - "7822": 1, - "7823": 1, - "7824": 1, - "7825": 1, - "7826": 1, - "7827": 1, - "7828": 1, - "7829": 1, - "783": 1, - "7830": 1, - "7831": 1, - "7832": 1, - "7833": 1, - "7834": 1, - "7835": 1, - "7836": 1, - "7837": 1, - "7838": 1, - "7839": 1, - "784": 1, - "7840": 1, - "7841": 1, - "7842": 1, - "7843": 1, - "7844": 1, - "7845": 1, - "7846": 1, - "7847": 1, - "7848": 1, - "7849": 1, - "785": 1, - "7850": 1, - "7851": 1, - "7852": 1, - "7853": 1, - "7854": 1, - "7855": 1, - "7856": 1, - "7857": 1, - "7858": 1, - "7859": 1, - "786": 1, - "7860": 1, - "7861": 1, - "7862": 1, - "7863": 1, - "7864": 1, - "7865": 1, - "7866": 1, - "7867": 1, - "7868": 1, - "7869": 1, - "787": 1, - "7870": 1, - "7871": 1, - "7872": 1, - "7873": 1, - "7874": 1, - "7875": 1, - "7876": 1, - "7877": 1, - "7878": 1, - "7879": 1, - "788": 1, - "7880": 1, - "7881": 1, - "7882": 1, - "7883": 1, - "7884": 1, - "7885": 1, - "7886": 1, - "7887": 1, - "7888": 1, - "7889": 1, - "789": 1, - "7890": 1, - "7891": 1, - "7892": 1, - "7893": 1, - "7894": 1, - "7895": 1, - "7896": 1, - "7897": 1, - "7898": 1, - "7899": 1, - "79": 1, - "790": 1, - "7900": 1, - "7901": 1, - "7902": 1, - "7903": 1, - "7904": 1, - "7905": 1, - "7906": 1, - "7907": 1, - "7908": 1, - "7909": 1, - "791": 1, - "7910": 1, - "7911": 1, - "7912": 1, - "7913": 1, - "7914": 1, - "7915": 1, - "7916": 1, - "7917": 1, - "7918": 1, - "7919": 1, - "792": 1, - "7920": 1, - "7921": 1, - "7922": 1, - "7923": 1, - "7924": 1, - "7925": 1, - "7926": 1, - "7927": 1, - "7928": 1, - "7929": 1, - "793": 1, - "7930": 1, - "7931": 1, - "7932": 1, - "7933": 1, - "7934": 1, - "7935": 1, - "7936": 1, - "7937": 1, - "7938": 1, - "7939": 1, - "794": 1, - "7940": 1, - "7941": 1, - "7942": 1, - "7943": 1, - "7944": 1, - "7945": 1, - "7946": 1, - "7947": 1, - "7948": 1, - "7949": 1, - "795": 1, - "7950": 1, - "7951": 1, - "7952": 1, - "7953": 1, - "7954": 1, - "7955": 1, - "7956": 1, - "7957": 1, - "7958": 1, - "7959": 1, - "796": 1, - "7960": 1, - "7961": 1, - "7962": 1, - "7963": 1, - "7964": 1, - "7965": 1, - "7966": 1, - "7967": 1, - "7968": 1, - "7969": 1, - "797": 1, - "7970": 1, - "7971": 1, - "7972": 1, - "7973": 1, - "7974": 1, - "7975": 1, - "7976": 1, - "7977": 1, - "7978": 1, - "7979": 1, - "798": 1, - "7980": 1, - "7981": 1, - "7982": 1, - "7983": 1, - "7984": 1, - "7985": 1, - "7986": 1, - "7987": 1, - "7988": 1, - "7989": 1, - "799": 1, - "7990": 1, - "7991": 1, - "7992": 1, - "7993": 1, - "7994": 1, - "7995": 1, - "7996": 1, - "7997": 1, - "7998": 1, - "7999": 1, - "8": 1, - "80": 1, - "800": 1, - "8000": 1, - "8001": 1, - "8002": 1, - "8003": 1, - "8004": 1, - "8005": 1, - "8006": 1, - "8007": 1, - "8008": 1, - "8009": 1, - "801": 1, - "8010": 1, - "8011": 1, - "8012": 1, - "8013": 1, - "8014": 1, - "8015": 1, - "8016": 1, - "8017": 1, - "8018": 1, - "8019": 1, - "802": 1, - "8020": 1, - "8021": 1, - "8022": 1, - "8023": 1, - "8024": 1, - "8025": 1, - "8026": 1, - "8027": 1, - "8028": 1, - "8029": 1, - "803": 1, - "8030": 1, - "8031": 1, - "8032": 1, - "8033": 1, - "8034": 1, - "8035": 1, - "8036": 1, - "8037": 1, - "8038": 1, - "8039": 1, - "804": 1, - "8040": 1, - "8041": 1, - "8042": 1, - "8043": 1, - "8044": 1, - "8045": 1, - "8046": 1, - "8047": 1, - "8048": 1, - "8049": 1, - "805": 1, - "8050": 1, - "8051": 1, - "8052": 1, - "8053": 1, - "8054": 1, - "8055": 1, - "8056": 1, - "8057": 1, - "8058": 1, - "8059": 1, - "806": 1, - "8060": 1, - "8061": 1, - "8062": 1, - "8063": 1, - "8064": 1, - "8065": 1, - "8066": 1, - "8067": 1, - "8068": 1, - "8069": 1, - "807": 1, - "8070": 1, - "8071": 1, - "8072": 1, - "8073": 1, - "8074": 1, - "8075": 1, - "8076": 1, - "8077": 1, - "8078": 1, - "8079": 1, - "808": 1, - "8080": 1, - "8081": 1, - "8082": 1, - "8083": 1, - "8084": 1, - "8085": 1, - "8086": 1, - "8087": 1, - "8088": 1, - "8089": 1, - "809": 1, - "8090": 1, - "8091": 1, - "8092": 1, - "8093": 1, - "8094": 1, - "8095": 1, - "8096": 1, - "8097": 1, - "8098": 1, - "8099": 1, - "81": 1, - "810": 1, - "8100": 1, - "8101": 1, - "8102": 1, - "8103": 1, - "8104": 1, - "8105": 1, - "8106": 1, - "8107": 1, - "8108": 1, - "8109": 1, - "811": 1, - "8110": 1, - "8111": 1, - "8112": 1, - "8113": 1, - "8114": 1, - "8115": 1, - "8116": 1, - "8117": 1, - "8118": 1, - "8119": 1, - "812": 1, - "8120": 1, - "8121": 1, - "8122": 1, - "8123": 1, - "8124": 1, - "8125": 1, - "8126": 1, - "8127": 1, - "8128": 1, - "8129": 1, - "813": 1, - "8130": 1, - "8131": 1, - "8132": 1, - "8133": 1, - "8134": 1, - "8135": 1, - "8136": 1, - "8137": 1, - "8138": 1, - "8139": 1, - "814": 1, - "8140": 1, - "8141": 1, - "8142": 1, - "8143": 1, - "8144": 1, - "8145": 1, - "8146": 1, - "8147": 1, - "8148": 1, - "8149": 1, - "815": 1, - "8150": 1, - "8151": 1, - "8152": 1, - "8153": 1, - "8154": 1, - "8155": 1, - "8156": 1, - "8157": 1, - "8158": 1, - "8159": 1, - "816": 1, - "8160": 1, - "8161": 1, - "8162": 1, - "8163": 1, - "8164": 1, - "8165": 1, - "8166": 1, - "8167": 1, - "8168": 1, - "8169": 1, - "817": 1, - "8170": 1, - "8171": 1, - "8172": 1, - "8173": 1, - "8174": 1, - "8175": 1, - "8176": 1, - "8177": 1, - "8178": 1, - "8179": 1, - "818": 1, - "8180": 1, - "8181": 1, - "8182": 1, - "8183": 1, - "8184": 1, - "8185": 1, - "8186": 1, - "8187": 1, - "8188": 1, - "8189": 1, - "819": 1, - "8190": 1, - "8191": 1, - "8192": 1, - "8193": 1, - "8194": 1, - "8195": 1, - "8196": 1, - "8197": 1, - "8198": 1, - "8199": 1, - "82": 1, - "820": 1, - "8200": 1, - "8201": 1, - "8202": 1, - "8203": 1, - "8204": 1, - "8205": 1, - "8206": 1, - "8207": 1, - "8208": 1, - "8209": 1, - "821": 1, - "8210": 1, - "8211": 1, - "8212": 1, - "8213": 1, - "8214": 1, - "8215": 1, - "8216": 1, - "8217": 1, - "8218": 1, - "8219": 1, - "822": 1, - "8220": 1, - "8221": 1, - "8222": 1, - "8223": 1, - "8224": 1, - "8225": 1, - "8226": 1, - "8227": 1, - "8228": 1, - "8229": 1, - "823": 1, - "8230": 1, - "8231": 1, - "8232": 1, - "8233": 1, - "8234": 1, - "8235": 1, - "8236": 1, - "8237": 1, - "8238": 1, - "8239": 1, - "824": 1, - "8240": 1, - "8241": 1, - "8242": 1, - "8243": 1, - "8244": 1, - "8245": 1, - "8246": 1, - "8247": 1, - "8248": 1, - "8249": 1, - "825": 1, - "8250": 1, - "8251": 1, - "8252": 1, - "8253": 1, - "8254": 1, - "8255": 1, - "8256": 1, - "8257": 1, - "8258": 1, - "8259": 1, - "826": 1, - "8260": 1, - "8261": 1, - "8262": 1, - "8263": 1, - "8264": 1, - "8265": 1, - "8266": 1, - "8267": 1, - "8268": 1, - "8269": 1, - "827": 1, - "8270": 1, - "8271": 1, - "8272": 1, - "8273": 1, - "8274": 1, - "8275": 1, - "8276": 1, - "8277": 1, - "8278": 1, - "8279": 1, - "828": 1, - "8280": 1, - "8281": 1, - "8282": 1, - "8283": 1, - "8284": 1, - "8285": 1, - "8286": 1, - "8287": 1, - "8288": 1, - "8289": 1, - "829": 1, - "8290": 1, - "8291": 1, - "8292": 1, - "8293": 1, - "8294": 1, - "8295": 1, - "8296": 1, - "8297": 1, - "8298": 1, - "8299": 1, - "83": 1, - "830": 1, - "8300": 1, - "8301": 1, - "8302": 1, - "8303": 1, - "8304": 1, - "8305": 1, - "8306": 1, - "8307": 1, - "8308": 1, - "8309": 1, - "831": 1, - "8310": 1, - "8311": 1, - "8312": 1, - "8313": 1, - "8314": 1, - "8315": 1, - "8316": 1, - "8317": 1, - "8318": 1, - "8319": 1, - "832": 1, - "8320": 1, - "8321": 1, - "8322": 1, - "8323": 1, - "8324": 1, - "8325": 1, - "8326": 1, - "8327": 1, - "8328": 1, - "8329": 1, - "833": 1, - "8330": 1, - "8331": 1, - "8332": 1, - "8333": 1, - "8334": 1, - "8335": 1, - "8336": 1, - "8337": 1, - "8338": 1, - "8339": 1, - "834": 1, - "8340": 1, - "8341": 1, - "8342": 1, - "8343": 1, - "8344": 1, - "8345": 1, - "8346": 1, - "8347": 1, - "8348": 1, - "8349": 1, - "835": 1, - "8350": 1, - "8351": 1, - "8352": 1, - "8353": 1, - "8354": 1, - "8355": 1, - "8356": 1, - "8357": 1, - "8358": 1, - "8359": 1, - "836": 1, - "8360": 1, - "8361": 1, - "8362": 1, - "8363": 1, - "8364": 1, - "8365": 1, - "8366": 1, - "8367": 1, - "8368": 1, - "8369": 1, - "837": 1, - "8370": 1, - "8371": 1, - "8372": 1, - "8373": 1, - "8374": 1, - "8375": 1, - "8376": 1, - "8377": 1, - "8378": 1, - "8379": 1, - "838": 1, - "8380": 1, - "8381": 1, - "8382": 1, - "8383": 1, - "8384": 1, - "8385": 1, - "8386": 1, - "8387": 1, - "8388": 1, - "8389": 1, - "839": 1, - "8390": 1, - "8391": 1, - "8392": 1, - "8393": 1, - "8394": 1, - "8395": 1, - "8396": 1, - "8397": 1, - "8398": 1, - "8399": 1, - "84": 1, - "840": 1, - "8400": 1, - "8401": 1, - "8402": 1, - "8403": 1, - "8404": 1, - "8405": 1, - "8406": 1, - "8407": 1, - "8408": 1, - "8409": 1, - "841": 1, - "8410": 1, - "8411": 1, - "8412": 1, - "8413": 1, - "8414": 1, - "8415": 1, - "8416": 1, - "8417": 1, - "8418": 1, - "8419": 1, - "842": 1, - "8420": 1, - "8421": 1, - "8422": 1, - "8423": 1, - "8424": 1, - "8425": 1, - "8426": 1, - "8427": 1, - "8428": 1, - "8429": 1, - "843": 1, - "8430": 1, - "8431": 1, - "8432": 1, - "8433": 1, - "8434": 1, - "8435": 1, - "8436": 1, - "8437": 1, - "8438": 1, - "8439": 1, - "844": 1, - "8440": 1, - "8441": 1, - "8442": 1, - "8443": 1, - "8444": 1, - "8445": 1, - "8446": 1, - "8447": 1, - "8448": 1, - "8449": 1, - "845": 1, - "8450": 1, - "8451": 1, - "8452": 1, - "8453": 1, - "8454": 1, - "8455": 1, - "8456": 1, - "8457": 1, - "8458": 1, - "8459": 1, - "846": 1, - "8460": 1, - "8461": 1, - "8462": 1, - "8463": 1, - "8464": 1, - "8465": 1, - "8466": 1, - "8467": 1, - "8468": 1, - "8469": 1, - "847": 1, - "8470": 1, - "8471": 1, - "8472": 1, - "8473": 1, - "8474": 1, - "8475": 1, - "8476": 1, - "8477": 1, - "8478": 1, - "8479": 1, - "848": 1, - "8480": 1, - "8481": 1, - "8482": 1, - "8483": 1, - "8484": 1, - "8485": 1, - "8486": 1, - "8487": 1, - "8488": 1, - "8489": 1, - "849": 1, - "8490": 1, - "8491": 1, - "8492": 1, - "8493": 1, - "8494": 1, - "8495": 1, - "8496": 1, - "8497": 1, - "8498": 1, - "8499": 1, - "85": 1, - "850": 1, - "8500": 1, - "8501": 1, - "8502": 1, - "8503": 1, - "8504": 1, - "8505": 1, - "8506": 1, - "8507": 1, - "8508": 1, - "8509": 1, - "851": 1, - "8510": 1, - "8511": 1, - "8512": 1, - "8513": 1, - "8514": 1, - "8515": 1, - "8516": 1, - "8517": 1, - "8518": 1, - "8519": 1, - "852": 1, - "8520": 1, - "8521": 1, - "8522": 1, - "8523": 1, - "8524": 1, - "8525": 1, - "8526": 1, - "8527": 1, - "8528": 1, - "8529": 1, - "853": 1, - "8530": 1, - "8531": 1, - "8532": 1, - "8533": 1, - "8534": 1, - "8535": 1, - "8536": 1, - "8537": 1, - "8538": 1, - "8539": 1, - "854": 1, - "8540": 1, - "8541": 1, - "8542": 1, - "8543": 1, - "8544": 1, - "8545": 1, - "8546": 1, - "8547": 1, - "8548": 1, - "8549": 1, - "855": 1, - "8550": 1, - "8551": 1, - "8552": 1, - "8553": 1, - "8554": 1, - "8555": 1, - "8556": 1, - "8557": 1, - "8558": 1, - "8559": 1, - "856": 1, - "8560": 1, - "8561": 1, - "8562": 1, - "8563": 1, - "8564": 1, - "8565": 1, - "8566": 1, - "8567": 1, - "8568": 1, - "8569": 1, - "857": 1, - "8570": 1, - "8571": 1, - "8572": 1, - "8573": 1, - "8574": 1, - "8575": 1, - "8576": 1, - "8577": 1, - "8578": 1, - "8579": 1, - "858": 1, - "8580": 1, - "8581": 1, - "8582": 1, - "8583": 1, - "8584": 1, - "8585": 1, - "8586": 1, - "8587": 1, - "8588": 1, - "8589": 1, - "859": 1, - "8590": 1, - "8591": 1, - "8592": 1, - "8593": 1, - "8594": 1, - "8595": 1, - "8596": 1, - "8597": 1, - "8598": 1, - "8599": 1, - "86": 1, - "860": 1, - "8600": 1, - "8601": 1, - "8602": 1, - "8603": 1, - "8604": 1, - "8605": 1, - "8606": 1, - "8607": 1, - "8608": 1, - "8609": 1, - "861": 1, - "8610": 1, - "8611": 1, - "8612": 1, - "8613": 1, - "8614": 1, - "8615": 1, - "8616": 1, - "8617": 1, - "8618": 1, - "8619": 1, - "862": 1, - "8620": 1, - "8621": 1, - "8622": 1, - "8623": 1, - "8624": 1, - "8625": 1, - "8626": 1, - "8627": 1, - "8628": 1, - "8629": 1, - "863": 1, - "8630": 1, - "8631": 1, - "8632": 1, - "8633": 1, - "8634": 1, - "8635": 1, - "8636": 1, - "8637": 1, - "8638": 1, - "8639": 1, - "864": 1, - "8640": 1, - "8641": 1, - "8642": 1, - "8643": 1, - "8644": 1, - "8645": 1, - "8646": 1, - "8647": 1, - "8648": 1, - "8649": 1, - "865": 1, - "8650": 1, - "8651": 1, - "8652": 1, - "8653": 1, - "8654": 1, - "8655": 1, - "8656": 1, - "8657": 1, - "8658": 1, - "8659": 1, - "866": 1, - "8660": 1, - "8661": 1, - "8662": 1, - "8663": 1, - "8664": 1, - "8665": 1, - "8666": 1, - "8667": 1, - "8668": 1, - "8669": 1, - "867": 1, - "8670": 1, - "8671": 1, - "8672": 1, - "8673": 1, - "8674": 1, - "8675": 1, - "8676": 1, - "8677": 1, - "8678": 1, - "8679": 1, - "868": 1, - "8680": 1, - "8681": 1, - "8682": 1, - "8683": 1, - "8684": 1, - "8685": 1, - "8686": 1, - "8687": 1, - "8688": 1, - "8689": 1, - "869": 1, - "8690": 1, - "8691": 1, - "8692": 1, - "8693": 1, - "8694": 1, - "8695": 1, - "8696": 1, - "8697": 1, - "8698": 1, - "8699": 1, - "87": 1, - "870": 1, - "8700": 1, - "8701": 1, - "8702": 1, - "8703": 1, - "8704": 1, - "8705": 1, - "8706": 1, - "8707": 1, - "8708": 1, - "8709": 1, - "871": 1, - "8710": 1, - "8711": 1, - "8712": 1, - "8713": 1, - "8714": 1, - "8715": 1, - "8716": 1, - "8717": 1, - "8718": 1, - "8719": 1, - "872": 1, - "8720": 1, - "8721": 1, - "8722": 1, - "8723": 1, - "8724": 1, - "8725": 1, - "8726": 1, - "8727": 1, - "8728": 1, - "8729": 1, - "873": 1, - "8730": 1, - "8731": 1, - "8732": 1, - "8733": 1, - "8734": 1, - "8735": 1, - "8736": 1, - "8737": 1, - "8738": 1, - "8739": 1, - "874": 1, - "8740": 1, - "8741": 1, - "8742": 1, - "8743": 1, - "8744": 1, - "8745": 1, - "8746": 1, - "8747": 1, - "8748": 1, - "8749": 1, - "875": 1, - "8750": 1, - "8751": 1, - "8752": 1, - "8753": 1, - "8754": 1, - "8755": 1, - "8756": 1, - "8757": 1, - "8758": 1, - "8759": 1, - "876": 1, - "8760": 1, - "8761": 1, - "8762": 1, - "8763": 1, - "8764": 1, - "8765": 1, - "8766": 1, - "8767": 1, - "8768": 1, - "8769": 1, - "877": 1, - "8770": 1, - "8771": 1, - "8772": 1, - "8773": 1, - "8774": 1, - "8775": 1, - "8776": 1, - "8777": 1, - "8778": 1, - "8779": 1, - "878": 1, - "8780": 1, - "8781": 1, - "8782": 1, - "8783": 1, - "8784": 1, - "8785": 1, - "8786": 1, - "8787": 1, - "8788": 1, - "8789": 1, - "879": 1, - "8790": 1, - "8791": 1, - "8792": 1, - "8793": 1, - "8794": 1, - "8795": 1, - "8796": 1, - "8797": 1, - "8798": 1, - "8799": 1, - "88": 1, - "880": 1, - "8800": 1, - "8801": 1, - "8802": 1, - "8803": 1, - "8804": 1, - "8805": 1, - "8806": 1, - "8807": 1, - "8808": 1, - "8809": 1, - "881": 1, - "8810": 1, - "8811": 1, - "8812": 1, - "8813": 1, - "8814": 1, - "8815": 1, - "8816": 1, - "8817": 1, - "8818": 1, - "8819": 1, - "882": 1, - "8820": 1, - "8821": 1, - "8822": 1, - "8823": 1, - "8824": 1, - "8825": 1, - "8826": 1, - "8827": 1, - "8828": 1, - "8829": 1, - "883": 1, - "8830": 1, - "8831": 1, - "8832": 1, - "8833": 1, - "8834": 1, - "8835": 1, - "8836": 1, - "8837": 1, - "8838": 1, - "8839": 1, - "884": 1, - "8840": 1, - "8841": 1, - "8842": 1, - "8843": 1, - "8844": 1, - "8845": 1, - "8846": 1, - "8847": 1, - "8848": 1, - "8849": 1, - "885": 1, - "8850": 1, - "8851": 1, - "8852": 1, - "8853": 1, - "8854": 1, - "8855": 1, - "8856": 1, - "8857": 1, - "8858": 1, - "8859": 1, - "886": 1, - "8860": 1, - "8861": 1, - "8862": 1, - "8863": 1, - "8864": 1, - "8865": 1, - "8866": 1, - "8867": 1, - "8868": 1, - "8869": 1, - "887": 1, - "8870": 1, - "8871": 1, - "8872": 1, - "8873": 1, - "8874": 1, - "8875": 1, - "8876": 1, - "8877": 1, - "8878": 1, - "8879": 1, - "888": 1, - "8880": 1, - "8881": 1, - "8882": 1, - "8883": 1, - "8884": 1, - "8885": 1, - "8886": 1, - "8887": 1, - "8888": 1, - "8889": 1, - "889": 1, - "8890": 1, - "8891": 1, - "8892": 1, - "8893": 1, - "8894": 1, - "8895": 1, - "8896": 1, - "8897": 1, - "8898": 1, - "8899": 1, - "89": 1, - "890": 1, - "8900": 1, - "8901": 1, - "8902": 1, - "8903": 1, - "8904": 1, - "8905": 1, - "8906": 1, - "8907": 1, - "8908": 1, - "8909": 1, - "891": 1, - "8910": 1, - "8911": 1, - "8912": 1, - "8913": 1, - "8914": 1, - "8915": 1, - "8916": 1, - "8917": 1, - "8918": 1, - "8919": 1, - "892": 1, - "8920": 1, - "8921": 1, - "8922": 1, - "8923": 1, - "8924": 1, - "8925": 1, - "8926": 1, - "8927": 1, - "8928": 1, - "8929": 1, - "893": 1, - "8930": 1, - "8931": 1, - "8932": 1, - "8933": 1, - "8934": 1, - "8935": 1, - "8936": 1, - "8937": 1, - "8938": 1, - "8939": 1, - "894": 1, - "8940": 1, - "8941": 1, - "8942": 1, - "8943": 1, - "8944": 1, - "8945": 1, - "8946": 1, - "8947": 1, - "8948": 1, - "8949": 1, - "895": 1, - "8950": 1, - "8951": 1, - "8952": 1, - "8953": 1, - "8954": 1, - "8955": 1, - "8956": 1, - "8957": 1, - "8958": 1, - "8959": 1, - "896": 1, - "8960": 1, - "8961": 1, - "8962": 1, - "8963": 1, - "8964": 1, - "8965": 1, - "8966": 1, - "8967": 1, - "8968": 1, - "8969": 1, - "897": 1, - "8970": 1, - "8971": 1, - "8972": 1, - "8973": 1, - "8974": 1, - "8975": 1, - "8976": 1, - "8977": 1, - "8978": 1, - "8979": 1, - "898": 1, - "8980": 1, - "8981": 1, - "8982": 1, - "8983": 1, - "8984": 1, - "8985": 1, - "8986": 1, - "8987": 1, - "8988": 1, - "8989": 1, - "899": 1, - "8990": 1, - "8991": 1, - "8992": 1, - "8993": 1, - "8994": 1, - "8995": 1, - "8996": 1, - "8997": 1, - "8998": 1, - "8999": 1, - "9": 1, - "90": 1, - "900": 1, - "9000": 1, - "9001": 1, - "9002": 1, - "9003": 1, - "9004": 1, - "9005": 1, - "9006": 1, - "9007": 1, - "9008": 1, - "9009": 1, - "901": 1, - "9010": 1, - "9011": 1, - "9012": 1, - "9013": 1, - "9014": 1, - "9015": 1, - "9016": 1, - "9017": 1, - "9018": 1, - "9019": 1, - "902": 1, - "9020": 1, - "9021": 1, - "9022": 1, - "9023": 1, - "9024": 1, - "9025": 1, - "9026": 1, - "9027": 1, - "9028": 1, - "9029": 1, - "903": 1, - "9030": 1, - "9031": 1, - "9032": 1, - "9033": 1, - "9034": 1, - "9035": 1, - "9036": 1, - "9037": 1, - "9038": 1, - "9039": 1, - "904": 1, - "9040": 1, - "9041": 1, - "9042": 1, - "9043": 1, - "9044": 1, - "9045": 1, - "9046": 1, - "9047": 1, - "9048": 1, - "9049": 1, - "905": 1, - "9050": 1, - "9051": 1, - "9052": 1, - "9053": 1, - "9054": 1, - "9055": 1, - "9056": 1, - "9057": 1, - "9058": 1, - "9059": 1, - "906": 1, - "9060": 1, - "9061": 1, - "9062": 1, - "9063": 1, - "9064": 1, - "9065": 1, - "9066": 1, - "9067": 1, - "9068": 1, - "9069": 1, - "907": 1, - "9070": 1, - "9071": 1, - "9072": 1, - "9073": 1, - "9074": 1, - "9075": 1, - "9076": 1, - "9077": 1, - "9078": 1, - "9079": 1, - "908": 1, - "9080": 1, - "9081": 1, - "9082": 1, - "9083": 1, - "9084": 1, - "9085": 1, - "9086": 1, - "9087": 1, - "9088": 1, - "9089": 1, - "909": 1, - "9090": 1, - "9091": 1, - "9092": 1, - "9093": 1, - "9094": 1, - "9095": 1, - "9096": 1, - "9097": 1, - "9098": 1, - "9099": 1, - "91": 1, - "910": 1, - "9100": 1, - "9101": 1, - "9102": 1, - "9103": 1, - "9104": 1, - "9105": 1, - "9106": 1, - "9107": 1, - "9108": 1, - "9109": 1, - "911": 1, - "9110": 1, - "9111": 1, - "9112": 1, - "9113": 1, - "9114": 1, - "9115": 1, - "9116": 1, - "9117": 1, - "9118": 1, - "9119": 1, - "912": 1, - "9120": 1, - "9121": 1, - "9122": 1, - "9123": 1, - "9124": 1, - "9125": 1, - "9126": 1, - "9127": 1, - "9128": 1, - "9129": 1, - "913": 1, - "9130": 1, - "9131": 1, - "9132": 1, - "9133": 1, - "9134": 1, - "9135": 1, - "9136": 1, - "9137": 1, - "9138": 1, - "9139": 1, - "914": 1, - "9140": 1, - "9141": 1, - "9142": 1, - "9143": 1, - "9144": 1, - "9145": 1, - "9146": 1, - "9147": 1, - "9148": 1, - "9149": 1, - "915": 1, - "9150": 1, - "9151": 1, - "9152": 1, - "9153": 1, - "9154": 1, - "9155": 1, - "9156": 1, - "9157": 1, - "9158": 1, - "9159": 1, - "916": 1, - "9160": 1, - "9161": 1, - "9162": 1, - "9163": 1, - "9164": 1, - "9165": 1, - "9166": 1, - "9167": 1, - "9168": 1, - "9169": 1, - "917": 1, - "9170": 1, - "9171": 1, - "9172": 1, - "9173": 1, - "9174": 1, - "9175": 1, - "9176": 1, - "9177": 1, - "9178": 1, - "9179": 1, - "918": 1, - "9180": 1, - "9181": 1, - "9182": 1, - "9183": 1, - "9184": 1, - "9185": 1, - "9186": 1, - "9187": 1, - "9188": 1, - "9189": 1, - "919": 1, - "9190": 1, - "9191": 1, - "9192": 1, - "9193": 1, - "9194": 1, - "9195": 1, - "9196": 1, - "9197": 1, - "9198": 1, - "9199": 1, - "92": 1, - "920": 1, - "9200": 1, - "9201": 1, - "9202": 1, - "9203": 1, - "9204": 1, - "9205": 1, - "9206": 1, - "9207": 1, - "9208": 1, - "9209": 1, - "921": 1, - "9210": 1, - "9211": 1, - "9212": 1, - "9213": 1, - "9214": 1, - "9215": 1, - "9216": 1, - "9217": 1, - "9218": 1, - "9219": 1, - "922": 1, - "9220": 1, - "9221": 1, - "9222": 1, - "9223": 1, - "9224": 1, - "9225": 1, - "9226": 1, - "9227": 1, - "9228": 1, - "9229": 1, - "923": 1, - "9230": 1, - "9231": 1, - "9232": 1, - "9233": 1, - "9234": 1, - "9235": 1, - "9236": 1, - "9237": 1, - "9238": 1, - "9239": 1, - "924": 1, - "9240": 1, - "9241": 1, - "9242": 1, - "9243": 1, - "9244": 1, - "9245": 1, - "9246": 1, - "9247": 1, - "9248": 1, - "9249": 1, - "925": 1, - "9250": 1, - "9251": 1, - "9252": 1, - "9253": 1, - "9254": 1, - "9255": 1, - "9256": 1, - "9257": 1, - "9258": 1, - "9259": 1, - "926": 1, - "9260": 1, - "9261": 1, - "9262": 1, - "9263": 1, - "9264": 1, - "9265": 1, - "9266": 1, - "9267": 1, - "9268": 1, - "9269": 1, - "927": 1, - "9270": 1, - "9271": 1, - "9272": 1, - "9273": 1, - "9274": 1, - "9275": 1, - "9276": 1, - "9277": 1, - "9278": 1, - "9279": 1, - "928": 1, - "9280": 1, - "9281": 1, - "9282": 1, - "9283": 1, - "9284": 1, - "9285": 1, - "9286": 1, - "9287": 1, - "9288": 1, - "9289": 1, - "929": 1, - "9290": 1, - "9291": 1, - "9292": 1, - "9293": 1, - "9294": 1, - "9295": 1, - "9296": 1, - "9297": 1, - "9298": 1, - "9299": 1, - "93": 1, - "930": 1, - "9300": 1, - "9301": 1, - "9302": 1, - "9303": 1, - "9304": 1, - "9305": 1, - "9306": 1, - "9307": 1, - "9308": 1, - "9309": 1, - "931": 1, - "9310": 1, - "9311": 1, - "9312": 1, - "9313": 1, - "9314": 1, - "9315": 1, - "9316": 1, - "9317": 1, - "9318": 1, - "9319": 1, - "932": 1, - "9320": 1, - "9321": 1, - "9322": 1, - "9323": 1, - "9324": 1, - "9325": 1, - "9326": 1, - "9327": 1, - "9328": 1, - "9329": 1, - "933": 1, - "9330": 1, - "9331": 1, - "9332": 1, - "9333": 1, - "9334": 1, - "9335": 1, - "9336": 1, - "9337": 1, - "9338": 1, - "9339": 1, - "934": 1, - "9340": 1, - "9341": 1, - "9342": 1, - "9343": 1, - "9344": 1, - "9345": 1, - "9346": 1, - "9347": 1, - "9348": 1, - "9349": 1, - "935": 1, - "9350": 1, - "9351": 1, - "9352": 1, - "9353": 1, - "9354": 1, - "9355": 1, - "9356": 1, - "9357": 1, - "9358": 1, - "9359": 1, - "936": 1, - "9360": 1, - "9361": 1, - "9362": 1, - "9363": 1, - "9364": 1, - "9365": 1, - "9366": 1, - "9367": 1, - "9368": 1, - "9369": 1, - "937": 1, - "9370": 1, - "9371": 1, - "9372": 1, - "9373": 1, - "9374": 1, - "9375": 1, - "9376": 1, - "9377": 1, - "9378": 1, - "9379": 1, - "938": 1, - "9380": 1, - "9381": 1, - "9382": 1, - "9383": 1, - "9384": 1, - "9385": 1, - "9386": 1, - "9387": 1, - "9388": 1, - "9389": 1, - "939": 1, - "9390": 1, - "9391": 1, - "9392": 1, - "9393": 1, - "9394": 1, - "9395": 1, - "9396": 1, - "9397": 1, - "9398": 1, - "9399": 1, - "94": 1, - "940": 1, - "9400": 1, - "9401": 1, - "9402": 1, - "9403": 1, - "9404": 1, - "9405": 1, - "9406": 1, - "9407": 1, - "9408": 1, - "9409": 1, - "941": 1, - "9410": 1, - "9411": 1, - "9412": 1, - "9413": 1, - "9414": 1, - "9415": 1, - "9416": 1, - "9417": 1, - "9418": 1, - "9419": 1, - "942": 1, - "9420": 1, - "9421": 1, - "9422": 1, - "9423": 1, - "9424": 1, - "9425": 1, - "9426": 1, - "9427": 1, - "9428": 1, - "9429": 1, - "943": 1, - "9430": 1, - "9431": 1, - "9432": 1, - "9433": 1, - "9434": 1, - "9435": 1, - "9436": 1, - "9437": 1, - "9438": 1, - "9439": 1, - "944": 1, - "9440": 1, - "9441": 1, - "9442": 1, - "9443": 1, - "9444": 1, - "9445": 1, - "9446": 1, - "9447": 1, - "9448": 1, - "9449": 1, - "945": 1, - "9450": 1, - "9451": 1, - "9452": 1, - "9453": 1, - "9454": 1, - "9455": 1, - "9456": 1, - "9457": 1, - "9458": 1, - "9459": 1, - "946": 1, - "9460": 1, - "9461": 1, - "9462": 1, - "9463": 1, - "9464": 1, - "9465": 1, - "9466": 1, - "9467": 1, - "9468": 1, - "9469": 1, - "947": 1, - "9470": 1, - "9471": 1, - "9472": 1, - "9473": 1, - "9474": 1, - "9475": 1, - "9476": 1, - "9477": 1, - "9478": 1, - "9479": 1, - "948": 1, - "9480": 1, - "9481": 1, - "9482": 1, - "9483": 1, - "9484": 1, - "9485": 1, - "9486": 1, - "9487": 1, - "9488": 1, - "9489": 1, - "949": 1, - "9490": 1, - "9491": 1, - "9492": 1, - "9493": 1, - "9494": 1, - "9495": 1, - "9496": 1, - "9497": 1, - "9498": 1, - "9499": 1, - "95": 1, - "950": 1, - "9500": 1, - "9501": 1, - "9502": 1, - "9503": 1, - "9504": 1, - "9505": 1, - "9506": 1, - "9507": 1, - "9508": 1, - "9509": 1, - "951": 1, - "9510": 1, - "9511": 1, - "9512": 1, - "9513": 1, - "9514": 1, - "9515": 1, - "9516": 1, - "9517": 1, - "9518": 1, - "9519": 1, - "952": 1, - "9520": 1, - "9521": 1, - "9522": 1, - "9523": 1, - "9524": 1, - "9525": 1, - "9526": 1, - "9527": 1, - "9528": 1, - "9529": 1, - "953": 1, - "9530": 1, - "9531": 1, - "9532": 1, - "9533": 1, - "9534": 1, - "9535": 1, - "9536": 1, - "9537": 1, - "9538": 1, - "9539": 1, - "954": 1, - "9540": 1, - "9541": 1, - "9542": 1, - "9543": 1, - "9544": 1, - "9545": 1, - "9546": 1, - "9547": 1, - "9548": 1, - "9549": 1, - "955": 1, - "9550": 1, - "9551": 1, - "9552": 1, - "9553": 1, - "9554": 1, - "9555": 1, - "9556": 1, - "9557": 1, - "9558": 1, - "9559": 1, - "956": 1, - "9560": 1, - "9561": 1, - "9562": 1, - "9563": 1, - "9564": 1, - "9565": 1, - "9566": 1, - "9567": 1, - "9568": 1, - "9569": 1, - "957": 1, - "9570": 1, - "9571": 1, - "9572": 1, - "9573": 1, - "9574": 1, - "9575": 1, - "9576": 1, - "9577": 1, - "9578": 1, - "9579": 1, - "958": 1, - "9580": 1, - "9581": 1, - "9582": 1, - "9583": 1, - "9584": 1, - "9585": 1, - "9586": 1, - "9587": 1, - "9588": 1, - "9589": 1, - "959": 1, - "9590": 1, - "9591": 1, - "9592": 1, - "9593": 1, - "9594": 1, - "9595": 1, - "9596": 1, - "9597": 1, - "9598": 1, - "9599": 1, - "96": 1, - "960": 1, - "9600": 1, - "9601": 1, - "9602": 1, - "9603": 1, - "9604": 1, - "9605": 1, - "9606": 1, - "9607": 1, - "9608": 1, - "9609": 1, - "961": 1, - "9610": 1, - "9611": 1, - "9612": 1, - "9613": 1, - "9614": 1, - "9615": 1, - "9616": 1, - "9617": 1, - "9618": 1, - "9619": 1, - "962": 1, - "9620": 1, - "9621": 1, - "9622": 1, - "9623": 1, - "9624": 1, - "9625": 1, - "9626": 1, - "9627": 1, - "9628": 1, - "9629": 1, - "963": 1, - "9630": 1, - "9631": 1, - "9632": 1, - "9633": 1, - "9634": 1, - "9635": 1, - "9636": 1, - "9637": 1, - "9638": 1, - "9639": 1, - "964": 1, - "9640": 1, - "9641": 1, - "9642": 1, - "9643": 1, - "9644": 1, - "9645": 1, - "9646": 1, - "9647": 1, - "9648": 1, - "9649": 1, - "965": 1, - "9650": 1, - "9651": 1, - "9652": 1, - "9653": 1, - "9654": 1, - "9655": 1, - "9656": 1, - "9657": 1, - "9658": 1, - "9659": 1, - "966": 1, - "9660": 1, - "9661": 1, - "9662": 1, - "9663": 1, - "9664": 1, - "9665": 1, - "9666": 1, - "9667": 1, - "9668": 1, - "9669": 1, - "967": 1, - "9670": 1, - "9671": 1, - "9672": 1, - "9673": 1, - "9674": 1, - "9675": 1, - "9676": 1, - "9677": 1, - "9678": 1, - "9679": 1, - "968": 1, - "9680": 1, - "9681": 1, - "9682": 1, - "9683": 1, - "9684": 1, - "9685": 1, - "9686": 1, - "9687": 1, - "9688": 1, - "9689": 1, - "969": 1, - "9690": 1, - "9691": 1, - "9692": 1, - "9693": 1, - "9694": 1, - "9695": 1, - "9696": 1, - "9697": 1, - "9698": 1, - "9699": 1, - "97": 1, - "970": 1, - "9700": 1, - "9701": 1, - "9702": 1, - "9703": 1, - "9704": 1, - "9705": 1, - "9706": 1, - "9707": 1, - "9708": 1, - "9709": 1, - "971": 1, - "9710": 1, - "9711": 1, - "9712": 1, - "9713": 1, - "9714": 1, - "9715": 1, - "9716": 1, - "9717": 1, - "9718": 1, - "9719": 1, - "972": 1, - "9720": 1, - "9721": 1, - "9722": 1, - "9723": 1, - "9724": 1, - "9725": 1, - "9726": 1, - "9727": 1, - "9728": 1, - "9729": 1, - "973": 1, - "9730": 1, - "9731": 1, - "9732": 1, - "9733": 1, - "9734": 1, - "9735": 1, - "9736": 1, - "9737": 1, - "9738": 1, - "9739": 1, - "974": 1, - "9740": 1, - "9741": 1, - "9742": 1, - "9743": 1, - "9744": 1, - "9745": 1, - "9746": 1, - "9747": 1, - "9748": 1, - "9749": 1, - "975": 1, - "9750": 1, - "9751": 1, - "9752": 1, - "9753": 1, - "9754": 1, - "9755": 1, - "9756": 1, - "9757": 1, - "9758": 1, - "9759": 1, - "976": 1, - "9760": 1, - "9761": 1, - "9762": 1, - "9763": 1, - "9764": 1, - "9765": 1, - "9766": 1, - "9767": 1, - "9768": 1, - "9769": 1, - "977": 1, - "9770": 1, - "9771": 1, - "9772": 1, - "9773": 1, - "9774": 1, - "9775": 1, - "9776": 1, - "9777": 1, - "9778": 1, - "9779": 1, - "978": 1, - "9780": 1, - "9781": 1, - "9782": 1, - "9783": 1, - "9784": 1, - "9785": 1, - "9786": 1, - "9787": 1, - "9788": 1, - "9789": 1, - "979": 1, - "9790": 1, - "9791": 1, - "9792": 1, - "9793": 1, - "9794": 1, - "9795": 1, - "9796": 1, - "9797": 1, - "9798": 1, - "9799": 1, - "98": 1, - "980": 1, - "9800": 1, - "9801": 1, - "9802": 1, - "9803": 1, - "9804": 1, - "9805": 1, - "9806": 1, - "9807": 1, - "9808": 1, - "9809": 1, - "981": 1, - "9810": 1, - "9811": 1, - "9812": 1, - "9813": 1, - "9814": 1, - "9815": 1, - "9816": 1, - "9817": 1, - "9818": 1, - "9819": 1, - "982": 1, - "9820": 1, - "9821": 1, - "9822": 1, - "9823": 1, - "9824": 1, - "9825": 1, - "9826": 1, - "9827": 1, - "9828": 1, - "9829": 1, - "983": 1, - "9830": 1, - "9831": 1, - "9832": 1, - "9833": 1, - "9834": 1, - "9835": 1, - "9836": 1, - "9837": 1, - "9838": 1, - "9839": 1, - "984": 1, - "9840": 1, - "9841": 1, - "9842": 1, - "9843": 1, - "9844": 1, - "9845": 1, - "9846": 1, - "9847": 1, - "9848": 1, - "9849": 1, - "985": 1, - "9850": 1, - "9851": 1, - "9852": 1, - "9853": 1, - "9854": 1, - "9855": 1, - "9856": 1, - "9857": 1, - "9858": 1, - "9859": 1, - "986": 1, - "9860": 1, - "9861": 1, - "9862": 1, - "9863": 1, - "9864": 1, - "9865": 1, - "9866": 1, - "9867": 1, - "9868": 1, - "9869": 1, - "987": 1, - "9870": 1, - "9871": 1, - "9872": 1, - "9873": 1, - "9874": 1, - "9875": 1, - "9876": 1, - "9877": 1, - "9878": 1, - "9879": 1, - "988": 1, - "9880": 1, - "9881": 1, - "9882": 1, - "9883": 1, - "9884": 1, - "9885": 1, - "9886": 1, - "9887": 1, - "9888": 1, - "9889": 1, - "989": 1, - "9890": 1, - "9891": 1, - "9892": 1, - "9893": 1, - "9894": 1, - "9895": 1, - "9896": 1, - "9897": 1, - "9898": 1, - "9899": 1, - "99": 1, - "990": 1, - "9900": 1, - "9901": 1, - "9902": 1, - "9903": 1, - "9904": 1, - "9905": 1, - "9906": 1, - "9907": 1, - "9908": 1, - "9909": 1, - "991": 1, - "9910": 1, - "9911": 1, - "9912": 1, - "9913": 1, - "9914": 1, - "9915": 1, - "9916": 1, - "9917": 1, - "9918": 1, - "9919": 1, - "992": 1, - "9920": 1, - "9921": 1, - "9922": 1, - "9923": 1, - "9924": 1, - "9925": 1, - "9926": 1, - "9927": 1, - "9928": 1, - "9929": 1, - "993": 1, - "9930": 1, - "9931": 1, - "9932": 1, - "9933": 1, - "9934": 1, - "9935": 1, - "9936": 1, - "9937": 1, - "9938": 1, - "9939": 1, - "994": 1, - "9940": 1, - "9941": 1, - "9942": 1, - "9943": 1, - "9944": 1, - "9945": 1, - "9946": 1, - "9947": 1, - "9948": 1, - "9949": 1, - "995": 1, - "9950": 1, - "9951": 1, - "9952": 1, - "9953": 1, - "9954": 1, - "9955": 1, - "9956": 1, - "9957": 1, - "9958": 1, - "9959": 1, - "996": 1, - "9960": 1, - "9961": 1, - "9962": 1, - "9963": 1, - "9964": 1, - "9965": 1, - "9966": 1, - "9967": 1, - "9968": 1, - "9969": 1, - "997": 1, - "9970": 1, - "9971": 1, - "9972": 1, - "9973": 1, - "9974": 1, - "9975": 1, - "9976": 1, - "9977": 1, - "9978": 1, - "9979": 1, - "998": 1, - "9980": 1, - "9981": 1, - "9982": 1, - "9983": 1, - "9984": 1, - "9985": 1, - "9986": 1, - "9987": 1, - "9988": 1, - "9989": 1, - "999": 1, - "9990": 1, - "9991": 1, - "9992": 1, - "9993": 1, - "9994": 1, - "9995": 1, - "9996": 1, - "9997": 1, - "9998": 1, - "9999": 1 -} From e4f2e22d1ebf525a5d3e13f6243198fc8a46355e Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:14:51 +0100 Subject: [PATCH 081/112] Updated benchmarking to remove asserts --- ...omparing_misc_functions_in_rust_v_python.ipynb | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index 233cd213d..36af1cf1c 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -225,7 +225,8 @@ " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " assert np.allclose(python_result, rust_result, atol=1)\n", + " if not np.allclose(python_result, rust_result, atol=1):\n", + " print(\"Incorrect result\")\n", " sizeofarray.append(i)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " i *= 10" @@ -442,7 +443,8 @@ " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " assert python_object == rust_object\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " num_patches *= 10\n", @@ -653,7 +655,8 @@ " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " assert python_object == rust_object\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " num_patches *= 10\n", @@ -844,7 +847,8 @@ " rust_object = rust_string_to_tuple(in_str)\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " assert python_object == rust_object\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", " sizeofarray.append(len(in_str))\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " i *= 10" @@ -1389,7 +1393,8 @@ " )\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " assert python_object == rust_object\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " num_patches *= 10\n", From 5e61c6df0b95d756d7a2efc3b73d79fb913e138b Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 12:57:11 +0100 Subject: [PATCH 082/112] Updated patch_predictions_as_annotations test to cover all branches --- tests/test_utils.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/tests/test_utils.py b/tests/test_utils.py index efa71b4ed..4fd3a25bc 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -2783,3 +2783,36 @@ def _fake_virtual_memory() -> FakeVirtualMemory: assert isinstance(result, zarr.Array) assert result.shape == (10, 20) assert result.chunks == (5, 10) + + +def test_patch_predictions_as_annotations() -> None: + """Used to test patch predictions as annotations. + + Checks branch if len(patch_coords == 0). + """ + preds = [0.0, 1.0] + + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } + + class_probs = np.array( + [ + [0.8, 0.2], + [0.1, 0.9], + ], + dtype=np.float64, + ) + + annotations = utils.misc.patch_predictions_as_annotations( + preds, + ["labels, probabilities"], + class_dict, + class_probs, + [], # patch_coords + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + + assert len(annotations) == 0 From 0f563127fb86f50f8c4b9f96edd67535b0e18a7a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 13:07:42 +0100 Subject: [PATCH 083/112] Updated to have json.dump use rust --- tiatoolbox/utils/misc.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 10a1b98ba..69d171203 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -876,8 +876,11 @@ def save_as_json( raise FileExistsError(msg) if parents: save_path.parent.mkdir(parents=True, exist_ok=True) - with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 - json.dump(shadow_data, handle) + try: + rmisc.json_dump_python_object(str(save_path), shadow_data) + except ValueError: + with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 + json.dump(shadow_data, handle) def select_device(*, on_gpu: bool) -> str: @@ -1597,8 +1600,11 @@ def save_annotations( def save_qupath_json(save_path: Path, qupath_json: dict) -> Path: """Saves QuPath JSON to disk.""" save_path = save_path.with_suffix(".json") - with Path.open(save_path, "w") as f: - json.dump(qupath_json, f, indent=2) + try: + rmisc.json_dump_python_object(str(save_path), qupath_json) + except ValueError: + with Path.open(save_path, "w") as f: + json.dump(qupath_json, f, indent=2) return save_path From 8aec6c5fcd8f4a7bb1abd1df92e9a510cd31baa0 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Wed, 26 Aug 2026 13:57:03 +0100 Subject: [PATCH 084/112] Updated to have json.dump use rust --- tiatoolbox/utils/misc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tiatoolbox/utils/misc.py b/tiatoolbox/utils/misc.py index 69d171203..f69eeea58 100644 --- a/tiatoolbox/utils/misc.py +++ b/tiatoolbox/utils/misc.py @@ -878,7 +878,7 @@ def save_as_json( save_path.parent.mkdir(parents=True, exist_ok=True) try: rmisc.json_dump_python_object(str(save_path), shadow_data) - except ValueError: + except (ValueError, OSError): with Path.open(save_path, "w") as handle: # skipcq: PTC-W6004 json.dump(shadow_data, handle) @@ -1602,7 +1602,7 @@ def save_qupath_json(save_path: Path, qupath_json: dict) -> Path: save_path = save_path.with_suffix(".json") try: rmisc.json_dump_python_object(str(save_path), qupath_json) - except ValueError: + except (ValueError, OSError): with Path.open(save_path, "w") as f: json.dump(qupath_json, f, indent=2) return save_path From 2a2683176e7f8834013677216f4c68641cc1710f Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:18:22 +0100 Subject: [PATCH 085/112] Improved benchmarking --- ...ring_misc_functions_in_rust_v_python.ipynb | 1318 +++++++++++------ 1 file changed, 896 insertions(+), 422 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index 36af1cf1c..99fd05b5e 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -55,18 +55,11 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w" + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true }, "source": [ - "# Part 1: Contrast Enhancer\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Contrast Enhancer with some code written in rust\n", + "# Part 1: Json.dump\n", "\n" ] }, @@ -76,170 +69,49 @@ "metadata": {}, "outputs": [], "source": [ + "import json\n", + "import time\n", + "from pathlib import Path\n", + "\n", "import numpy as np\n", - "from skimage import exposure\n", "\n", "from tiatoolbox import rmisc\n", "\n", - "\n", - "def rust_contrast_enhancer(\n", - " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", - ") -> np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " # check if image is not uint8\n", - " dimension_for_rust = 3\n", - "\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " if img.ndim == dimension_for_rust:\n", - " return rmisc.contrast_enhancer(img, low_p, high_p)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Contrast Enhancer written fully in python\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def py_contrast_enhancer(\n", - " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", - ") -> np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Comparison of speed it takes to run code in rust vs python\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "DZBiw_EepT5x" - }, - "outputs": [], - "source": [ - "import time\n", - "\n", + "example_dict = {}\n", "sizeofarray = []\n", "timings = []\n", - "i = 1\n", + "i = 10\n", "maxarraysize = 10000\n", + "with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", + " json.dump({\"a\": 1}, handle)\n", "while i <= maxarraysize:\n", " python_times = np.empty(0)\n", " rust_times = np.empty(0)\n", - " for _j in range(5):\n", - " rng = np.random.default_rng()\n", - " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", + " for j in range(len(example_dict), i):\n", + " example_dict[str(j)] = 1\n", + " for _j in range(10):\n", " start_time = time.time()\n", - " python_result = py_contrast_enhancer(temp, 2, 96)\n", + " with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", + " json.dump(example_dict, handle)\n", " python_end_time = time.time() - start_time\n", " python_times = np.append(python_times, python_end_time)\n", " start_time = time.time()\n", - " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", + " rmisc.json_dump_python_object(\"example.txt\", example_dict)\n", " rust_end_time = time.time() - start_time\n", " rust_times = np.append(rust_times, rust_end_time)\n", - " if not np.allclose(python_result, rust_result, atol=1):\n", - " print(\"Incorrect result\")\n", - " sizeofarray.append(i)\n", + " sizeofarray.append(len(example_dict))\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", " i *= 10" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,24 +124,17 @@ "import matplotlib.pyplot as plt\n", "\n", "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of array\")\n", + "plt.xlabel(\"Size of dictionary\")\n", "plt.ylabel(\"Time(s)\")\n", "plt.legend([\"Python\", \"Rust\"])\n", "plt.show()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Caution - The rust version differs from the python version by max 1\n", - "\n" - ] - }, { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w" + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true }, "source": [ "# Part 2: Patch Predictions As Annotations\n", @@ -278,7 +143,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "### Patch predictions as annotations written fully in python\n", "\n" @@ -286,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -335,7 +202,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "### Patch Predictions As Annotations with some code written in rust\n", "\n" @@ -343,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -377,7 +246,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "## Comparison of speed it takes to run code in rust vs python\n", "\n" @@ -385,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -453,12 +324,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -497,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -569,10 +440,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ + "from tiatoolbox import rmisc\n", + "\n", + "\n", "def rust_patch_predictions_as_qupath_json(\n", " preds: list | np.ndarray,\n", " class_dict: dict,\n", @@ -609,7 +483,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -665,12 +539,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -692,241 +566,52 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w" + "jp-MarkdownHeadingCollapsed": true }, "source": [ - "# Part 4: Json.dump\n", + "# Part 4: Semantic Segmentations As QuPath Json\n", "\n" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import json\n", - "import time\n", - "from pathlib import Path\n", - "\n", - "import numpy as np\n", - "\n", - "example_dict = {}\n", - "sizeofarray = []\n", - "timings = []\n", - "i = 10\n", - "maxarraysize = 10000\n", - "with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", - " json.dump({\"a\": 1}, handle)\n", - "while i <= maxarraysize:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for j in range(len(example_dict), i):\n", - " example_dict[str(j)] = 1\n", - " for _j in range(10):\n", - " start_time = time.time()\n", - " with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", - " json.dump(example_dict, handle)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rmisc.json_dump_python_object(\"example.txt\", example_dict)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " sizeofarray.append(len(example_dict))\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Size of dictionary\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Part 5: String To Tuple\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "def py_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", - " \"\"\"Splits input string to tuple at ','.\n", - "\n", - " Args:\n", - " in_str (str):\n", - " input string.\n", - "\n", - " Returns:\n", - " tuple[str, ...]:\n", - " Return a tuple of strings by splitting in_str at ','.\n", - "\n", - " \"\"\"\n", - " return tuple(substring.strip() for substring in in_str.split(\",\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "from tiatoolbox import rmisc\n", - "\n", - "\n", - "def rust_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", - " \"\"\"Splits input string to tuple at ','.\n", - "\n", - " Args:\n", - " in_str (str):\n", - " input string.\n", - "\n", - " Returns:\n", - " tuple[str, ...]:\n", - " Return a tuple of strings by splitting in_str at ','.\n", - "\n", - " \"\"\"\n", - " return tuple(rmisc.string_to_tuple(in_str))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "\n", - "import numpy as np\n", - "\n", - "sizeofarray = []\n", - "timings = []\n", - "timings = []\n", - "i = 1\n", - "in_str = \"\"\n", - "max_patches = 100000\n", - "while i <= max_patches:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for j in range(int(len(in_str) / 2), i):\n", - " in_str += \" , \" + str(j)\n", - " for _j in range(10):\n", - " start_time = time.time()\n", - " python_object = py_string_to_tuple(in_str)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_object = rust_string_to_tuple(in_str)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " if python_object != rust_object:\n", - " print(\"Incorrect result\")\n", - " sizeofarray.append(len(in_str))\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(sizeofarray, timings)\n", - "plt.xlabel(\"Length of string\")\n", - "plt.ylabel(\"Time(s)\")\n", - "plt.legend([\"Python\", \"Rust\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Part 6: Semantic Segmentations As QuPath Json\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "from shapely.affinity import translate\n", - "from shapely.geometry.base import BaseGeometry\n", - "\n", - "\n", - "def make_valid_poly(\n", - " poly: BaseGeometry,\n", - " origin: tuple[float, float] | None = None,\n", - ") -> BaseGeometry:\n", - " \"\"\"Helper function to make a valid polygon.\n", - "\n", - " Args:\n", - " poly (Polygon):\n", - " The polygon to make valid.\n", - " origin (Tuple[float, float]):\n", - " The x and y coordinates to use as the origin for the annotation.\n", - "\n", - " Returns:\n", - " geometry:\n", - " A valid geometry.\n", - "\n", - " \"\"\"\n", - " if origin != (0, 0) and origin is not None:\n", - " # transform coords to be relative to given pt.\n", - " poly = translate(poly, -origin[0], -origin[1])\n", - " if poly.is_valid:\n", - " return poly\n", - " logger.warning(\"Invalid geometry found, fix using buffer().\", stacklevel=3)\n", - " return poly.buffer(0.01)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from shapely.affinity import translate\n", + "from shapely.geometry.base import BaseGeometry\n", + "\n", + "\n", + "def make_valid_poly(\n", + " poly: BaseGeometry,\n", + " origin: tuple[float, float] | None = None,\n", + ") -> BaseGeometry:\n", + " \"\"\"Helper function to make a valid polygon.\n", + "\n", + " Args:\n", + " poly (Polygon):\n", + " The polygon to make valid.\n", + " origin (Tuple[float, float]):\n", + " The x and y coordinates to use as the origin for the annotation.\n", + "\n", + " Returns:\n", + " geometry:\n", + " A valid geometry.\n", + "\n", + " \"\"\"\n", + " if origin != (0, 0) and origin is not None:\n", + " # transform coords to be relative to given pt.\n", + " poly = translate(poly, -origin[0], -origin[1])\n", + " if poly.is_valid:\n", + " return poly\n", + " logger.warning(\"Invalid geometry found, fix using buffer().\", stacklevel=3)\n", + " return poly.buffer(0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -943,7 +628,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -963,7 +648,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -1061,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -1099,13 +784,13 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a98d8b62517d40619d38b795c0cb1952", + "model_id": "b66ebe7cd3e641ef8b5a51a726b3fbcc", "version_major": 2, "version_minor": 0 }, @@ -1119,7 +804,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "da3c34de48284a85a68f5f14addb14d7", + "model_id": "d7b559fce7ea492183c80a62cd3da495", "version_major": 2, "version_minor": 0 }, @@ -1133,7 +818,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9d99c31c4f614c50954acb545a980fda", + "model_id": "eae152e3c916458da55349aa6e0fcdf5", "version_major": 2, "version_minor": 0 }, @@ -1147,7 +832,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6dd5629582f54ce9933fc6d25ccad444", + "model_id": "4d7dcd4747d046c3b199e1f94644b4a5", "version_major": 2, "version_minor": 0 }, @@ -1161,7 +846,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3eeb405d27c34f9d840b96c5e9dc3ab9", + "model_id": "6640117ea0c34548a819d31d62b5dec4", "version_major": 2, "version_minor": 0 }, @@ -1175,7 +860,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7dab6ce203f845fbb9dd1b2825936759", + "model_id": "a09eae9f8e054e84a3bc13c4a6a566d7", "version_major": 2, "version_minor": 0 }, @@ -1189,7 +874,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "942c0acd917a4dc58974e89dc8d7f37c", + "model_id": "eb65575affd14b7c909b3198a1d29846", "version_major": 2, "version_minor": 0 }, @@ -1203,7 +888,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "52894c4219c3425685e75f701c014eb6", + "model_id": "bb7d1bb1c0b14b49972260a268948518", "version_major": 2, "version_minor": 0 }, @@ -1217,7 +902,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5de9b8f354fa48739c0799183e763f3f", + "model_id": "609e9d5b5f7d402db67ed658fc9f85b9", "version_major": 2, "version_minor": 0 }, @@ -1231,7 +916,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dd814f185337467698391a7e19ce73ff", + "model_id": "b3952f77ff4542ada43dd90d7cd71bc3", "version_major": 2, "version_minor": 0 }, @@ -1245,7 +930,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "459d510065eb4bc38b5b58e8cc8b66c4", + "model_id": "6fdf8085a34141a7a06c85b3f23611f0", "version_major": 2, "version_minor": 0 }, @@ -1259,7 +944,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "041b591d40034ed9b1f21d1179d3133e", + "model_id": "f7d0293ff423418e99a698265032c055", "version_major": 2, "version_minor": 0 }, @@ -1273,7 +958,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "228c201c0e5d4ea6a3217fa61fa72222", + "model_id": "6a14db22455848f59a7157c9cef8c64d", "version_major": 2, "version_minor": 0 }, @@ -1287,7 +972,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c54310a75c944908b6f6df5296afca29", + "model_id": "09a9768359264c1aa95a4dc8b2105cb8", "version_major": 2, "version_minor": 0 }, @@ -1301,7 +986,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7331cefaa1184376a186cfb90a4131b7", + "model_id": "9c9adf3dfb4b42acb58f8dcf9d08f608", "version_major": 2, "version_minor": 0 }, @@ -1403,12 +1088,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAciRJREFUeJzt3Xd0FdXexvFvOukhhJ7Qe6ihCAIKIr2oICjFjuVKUwQFrKCCIkWavVy9iogoAlJFpHcSSuidEEpo6f2cef8YzWukJZBkUp7PWlm65+yZ+eUEch5m79njYBiGgYiIiEgh4Wh1ASIiIiI5SeFGREREChWFGxERESlUFG5ERESkUFG4ERERkUJF4UZEREQKFYUbERERKVQUbkRERKRQcba6ACvY7XbOnDmDt7c3Dg4OVpcjIiIiWWAYBnFxcZQrVw5Hx+tfnymS4ebMmTMEBQVZXYaIiIjcgoiICAIDA6/7epEMN97e3oD55vj4+FhcjYiIiGRFbGwsQUFBGZ/j11Mkw83fQ1E+Pj4KNyIiIgXMzaaUaEKxiIiIFCoKNyIiIlKoKNyIiIhIoVIk59xkhd1uJzU11eoyiiQXFxecnJysLkNERAoohZtrSE1N5fjx49jtdqtLKbL8/PwoU6aM1iESEZFsU7j5F8MwOHv2LE5OTgQFBd1wkSDJeYZhkJiYSFRUFABly5a1uCIRESloLA83GzduZPny5cTHxxMcHEzfvn1xd3e/bv/vvvuO1atXZ9pWvnx5xo4dmyP1pKenk5iYSLly5fDw8MiRY0r2/P3zj4qKolSpUhqiEhGRbLE03AwePJgDBw7Qrl07vLy8mD59OhMnTmTTpk0UL178mvusX7+enTt38txzz2Vs8/f3z7GabDYbAK6urjl2TMm+v4NlWlqawo2IiGSLpeFmxIgRVKpUKaP99NNPExAQwJIlS+jfv/9196tUqRIDBw7M1do018Naev9FRORWWRpu/hlsAC5duoTNZqN06dI33O/gwYMMHToUX19fWrduTYcOHXKxyqJrypQpVKpUiZ49e1pdioiISJZZPudm7969TJ06ldjYWLZv38706dO59957r9vfwcGBKlWqUKlSJSIjI+nVqxe9evXiv//973X3SUlJISUlJaMdGxubk99CvvD111+zYcMGwLyVOigoiAceeIDatWtnaf8ZM2ZQqlQpHnrooYxtS5YsoUmTJgo3IiJSoFh+K5Cvry/NmzcnJCQET09Pfv75Z2JiYq7b/4033mDBggUMHz6cyZMns3z5cr799luWLVt23X0mTJiAr69vxldhfCL4mjVrWLduHc2bN6d+/fqEh4dTr1495s+fn6X9ly9fzqZNm3K5ShERkdxn+ZWbwMDAjPkzgwcPpkaNGkydOpW33nrrmv3/fWvwnXfeSVBQEBs3bqRTp07X3Gf06NEMHz48o/33U0ULm7Jly2a8l//5z3+Ij49n3LhxeHh4sGbNGsaPH5+p//fff09kZCQlS5Zk9+7dnDhxImP/d955J6Pf6tWrWblyJTabjd69exMSEpLpOOHh4fz4449cvnyZ+vXr8+ijj2a64+3v4S1/f/8bHkdERAq+XRHRhJ+Jof8dFS2rwfIrN//k5eVF9erVOXLkSLb2S0pKwjCM677u5uaW8QTwovQk8Lp16xIREUGVKlWYMGEC4eHhGa/Z7XZGjx6Ns7MzVatWpXjx4pQtW5bmzZvTvHnzjHDy3Xff8dZbb1GiRAkuXbpE8+bNCQ0NzTjO0qVLCQkJ4ezZs1SqVImZM2fSqlWrTKs7L1myhKFDh97wOCIiUrAZhsGX64/z4Ccbef3XcLafuGxZLZZduUlJSWH16tV07NgxY9v+/fvZsWMHvXv3ztj2zTffcOzYMcaOHUt6ejrLly+na9euGa9//vnnXLhwgc6dO+dKnYZhkJRmy5Vj34y7i9Mt3zVks9n4448/qFu3LtWrV+euu+7iq6++YsqUKQD8/vvvnDt3jkceeYSSJUsSFBREtWrVrroLzd/fnz/++CPjduwjR47wzTffEBISgmEYDB06lKFDhzJp0iTAvOOtcuXKfPbZZwwePDhLxxERkYItJjGNEfN28fu+8wB0Ci5D9dLeltVjWbhxcnLik08+4ZVXXqFOnTpER0ezZs0aHnroIZ599tmMfuvWrWPz5s2MHTsWBwcHvvzyS8aMGUOdOnU4deoUu3btYurUqdx55525UmdSmo06byzPlWPfzL5xHfFwzfqP6ODBgwwcOJD09HQ2b95MTEwMixcvBszQMXz4cN5//31cXFz46quv6NatGyVLlrzhMdu2bZtpnZmaNWty+vRpACIjIzly5Ah9+/bNeN3Pz4+uXbuyZs2aTOHmRscREZGCK+zUFQbPDiMyOglXJ0de7VqbR1tUtHRJD8vCjbOzM/Pnz+fQoUOEhYXh6enJJ598QoUKFTL1e/zxx+nSpQtgBqJffvmFgwcPsnPnTooXL05ISAgBAQFWfAv5jo+PD82bN8fFxYVHHnmEO++8M2N46cEHH2TIkCEsWrSINm3asGDBAubNm3fTY/57tWgnJ6eMhQ7/fkTCv9//gICAq4acbnQcEREpeAzD4It1x3l/2QHS7QYVS3gws28I9QJ9rS7N+gnFNWrUoEaNGtd9vVWrVldtq1mzJjVr1szNsjK4uzixb1zHm3fMpXNnxz8nFP9bsWLFGDBgAF999RWRkZH4+/tnGsq7lYT996TskydPUrHi/08cO3ny5FUhVURECo8rCamM+GkXfxww/5HbtX5ZJvSsh08xF4srM1kebvI7BweHbA0N5WdPP/00ISEhHDx4kMceeyzTMJG/vz+XL2dv8lfJkiW56667mDZtGq1atcLR0ZH9+/ezZMkS5syZk9Pli4hIPrDj5GWGzA7jTEwyrs6OvNGtDv3vqJCvVpYvHJ/akiX169enUaNGbN++nSeeeCLTa/fddx8DBgwgNTUVLy+vTLeC38hHH31Ehw4dCAkJoVq1aqxcuZJ+/frxwAMP5Ma3ICIiFrHbDT5de4xJKw5isxtUDvBkZr9GBJezfhjq3xRuCoknn3ySuLi4m/Zr1KgRxYoVu2oosGfPnmzfvp1du3aRkJCAu7s7L7300lXzafr3709CQkJGOzg4mMOHD7Nq1SquXLnC66+/ToMGDTLtk5XjiIhI/nUpPoWXftrF6oMXAOjRoBzje9bDyy1/xggH40YLxBRSsbGx+Pr6EhMTc9WaN8nJyRw/fpzKlStTrFgxiyrMHbGxsVSsWJFZs2bRr18/q8u5ocL8cxARKUi2Hr/MkB9COR+bgpuzI2/1CObhpkGWDEPd6PP7n/Jn5JIcN3LkSH7//XeqVKlCnz59rC5HRETyObvd4OM1R5m84iB2A6qU9GRWvxBql83/C+Eq3BQRISEhNGvWjM6dO+PsrB+7iIhc38X4FF78cSfrDl8E4IFG5Xnn/rp45tNhqH8rGFXKbfvnQnsiIiLXs+noJYbNCSMqLoViLo6M61GX3k0C89XdUDejcCMiIiLY7AYzVx1h2h+HsBtQrZQXH/UPoYaFj1G4VQo3IiIiRVxUXDIv/riTDUcuAfBg40DG3RdcYNd5K5hVi4iISI7YcOQiw+bs5GJ8Cu4uTrxzf116NQ60uqzbonAjIiJSBNnsBtP+OMyMVYcxDKhZ2ptZ/RtRrVTBG4b6N4UbERGRIuZ8bDLD5oSx+Zj52J2HmwbxZvdg3F2z90zD/ErhRkREpAhZe+gCL/64k0sJqXi4OjH+gXrc36i81WXlKIWbQmL79u2cOHECABcXFwIDA6lfvz4uLjn3hNbIyEh27NhBjx49cuyYIiKSN9Jtdj5ceZhZq49gGFCrjDez+odQtaSX1aXlOIWbQmLmzJksXryYu+++m/T0dMLCwnB2dmbhwoUEBwfnyDk2bdrEwIEDiY6OzpHjiYhI3jgXk8zQH8LYesIchup3RwXe6FaHYi6FYxjq3xRuCpHg4GDmzZsHQGpqKnfeeSfDhg1j5cqVABw5coTjx4/Tvn37jH3Onz/Phg0b6NmzZ8a22NhYQkNDAXNlYx8fHy5cuMDmzZtJS0vLOEetWrWoW7duXn17IiJyC1YfjGL43F1cTkjFy82Z8T3r0aNBOavLylUKN4WUq6srHTp04PPPP8/Y9ttvv/HFF18QHh6esS0sLIw+ffqQnp4OwJ9//kmvXr2oWbMmXl5eHD16lOnTp1O5cmU2bNhAWloac+bMAeCBBx5QuBERyafSbHYmrzjEJ2uOAhBczoeZ/UKoHOBpcWW5T+HmZgwD0hKtObeLB9zGctfHjh0jICAgW/tMmDCBp556ig8++ACAmJgYtmzZQnBwMC+99BIDBw7MuHIjIiL505noJIb8EMaOk1cAeLRFRcZ0qV1oh6H+TeHmZtISYbxFl+/GnAHXrCfsCxcuMG/ePNLT09myZQu//PIL//vf/7J1Sjc3N06ePElSUhLu7u74+vrSoUOH7FYuIiIW+WP/eV76aRfRiWl4uznz/oP16VKvrNVl5SmFm0IkKiqKOXPmkJKSwsaNG+ncuTMPPPBAto4xceJEnnzySUqWLEnLli3p1q0bTz/9NMWKFculqkVEJCek2exMXHaAz9cdB6BeeV9m9mtExRKFfxjq3xRubsbFw7yCYtW5s+GfE4rPnz9PkyZNGDVqFFOmTAHA0dERu92eaZ/k5ORM7dq1a7Np0ybOnj3LqlWrePfdd1m+fDm//fbbbXwjIiKSm05fSWTw7DB2RkQD8PidlRjdpRZuzkVjGOrfFG5uxsEhW0ND+UXp0qWZPHky/fr14+mnn6Z27dqUL1+eyMhIUlJScHNzA2DNmjWZ9jt79ixly5albNmy9O/fH7vdzrBhwwDw8vIiJSUlz78XERG5vhV7zzHip13EJqfjXcyZDx6sT6e6RWsY6t8UbgqxPn36MGnSJEaPHs2vv/5K+/btKVasGA8//DAPPPAA27dvZ+7cuZn2GTBgAEFBQbRs2RKbzcbUqVPp1asXAPXq1cNms/H666/ToEED3QouImKh1HQ77y09wFcbzGGoBoG+zOwXQpB/9q76F0aOVhcgOaNp06bcfffdV23/8MMPcXFx4ezZs/j4+LBlyxaqVavG6tWrqVmzJgsXLswILwDLly/nnnvuYevWrYSFhfH666/z8ccfA1C+fHmWLl3KxYsX+fHHH9m1a1eefX8iIvL/Ii4n0vuTjRnB5qlWlfnpuTsVbP7iYBiGYXUReS02NhZfX19iYmLw8fHJ9FpycjLHjx+ncuXKmkRrIf0cRESubVn4WUbO201ccjq+7i5M6t2A9nVKW11WnrjR5/c/aVhKRESkAEhJtzF+8X6+2XQSgEYV/JjRtxGBxXW15t8UbkRERPK5k5cSGDw7jD2RMQA8e1cVRnSsiYuTZpdci8KNiIhIPrZ491lG/bybuJR0inu4MLlPA+6pVTSGoW6Vwo2IiEg+lJxm453F+/hu8ykAmlQszvS+jSjn525xZfmfwo2IiEg+c/xiAoO+D2Xf2VgA/tOmKsPb19AwVBYp3FxHEbyJLF/R+y8iRdWCnZGM+WUPCak2/D1dmdKnAW1qlrK6rAJF4eZfnJzMpapTU1Nxd9elP6skJppPYndxcbG4EhGRvJGcZmPson38sNUchmpW2Z/pDzeijK+Ww8guhZt/cXZ2xsPDgwsXLuDi4oKjoy4B5iXDMEhMTCQqKgo/P7+MsCkiUpgdvRDPoO9DOXAuDgcHGNy2GsPaVcdZw1C3ROHmXxwcHChbtizHjx/n5MmTVpdTZPn5+VGmTBmryxARyXXzw07z6vxwElNtBHi5MvWhhrSuXtLqsgo0hZtrcHV1pXr16qSmplpdSpHk4uKiKzYiUuglpdp4c2E4c7efBqBFlRJMe7ghpXw0DHW7FG6uw9HRUcv+i4hIrjh8Po5Bs0M5dD4eBwcYek91hrarjpOjg9WlFQoKNyIiInnop+0RvLFgL0lpNkp6uzHtoYbcWS3A6rIKFUvDjd1uZ968eSxfvpz4+HiCg4N55plnbjrXIiwsjE8++YTz589Tr149hg8fTvHixfOoahERkexLTE3ntV/D+SU0EoBW1QKY+lBDSnq7WVxZ4WPpNOzHHnuMJUuW0KZNG+6//37Wrl1LSEgI586du+4+mzdvpkWLFri4uNC7d29Wr15Ny5YtM24dFhERyW8Onoujx8wN/BIaiaMDDG9fg2+ebKZgk0scDAtXS4uOjsbPzy+jnZSUhI+PD1988QWPPfbYNfe555578PX1Zf78+QDExMRQvnx5JkyYwJAhQ7J03qw+Ml1EROR2GIbB3O0RvLlwL8lpdkp5uzG9byOaVylhdWkFUlY/vy29cvPPYAOwb98+0tPTqVGjxjX7JyUlsXbtWu6///6Mbb6+vtx7770sW7YsFysVERHJnoSUdF78cSev/LyH5DQ7rasHsGRYawWbPGD5hOIdO3bw6quvEhsby5EjR/jxxx9p0aLFNftGRERgs9kICgrKtD0wMJA///zzuudISUkhJSUlox0bG5szxYuIiFzD/rOxDPo+lGMXE3BydGB4+xr85+6qOOpuqDxh+dKHFStW5IUXXuD555+nXr16vPHGG9edc/P3ujP/fiyCh4fHDdekmTBhAr6+vhlf/w5HIiIiOcEwDGZvOcV9szZw7GICZXyKMeeZ5gxqW63oBJsTG2D9VEtLsDzcBAQE0KlTJwYMGMCyZctISUlh6tRrvyl/D2Ndvnw50/ZLly7d8G6p0aNHExMTk/EVERGRY/WLiIgAxCWnMXTOTsbM30Nqup22NUuyZFhrmlbyt7q0vJEcA7+9CP/tAivHQsRWy0qxfFjqn1xcXChfvjxnz5695uuBgYEEBAQQFhZG165dM7aHhYXRuHHj6x7Xzc0NNzfNSBcRkdwRHhnD4NmhnLiUiJOjAy93rMnTrasUnas1BxbD4pcg7q/P75BHIeDa82fzgmVXbpKTk/nyyy/5581aa9euZdu2bdxzzz0Z2z788EOee+65jPajjz7Kl19+ycWLFwFYvnw5YWFh1727SkREJLcYhsH/Np2g50cbOXEpkXK+xZj7bHOeLSrza+LOw9xHYU4/M9j4V4HHFkGP6eDuZ1lZll25cXFxISwsjMDAQKpWrUp0dDQnTpzglVdeyRRUwsPD2bx5c0Z73Lhx7Nmzh+rVq1O9enX27NnD+PHjadWqlRXfhoiIFFGxyWmM+nk3S/aY80TvrV2KDx5sQHFPV4srywOGAWHfwYpXzeEoBydoORTufgVc3G++fy6zdJ0bMNepCQ8Px9PTk+rVq+Pp6Znp9b179xIdHU3Lli0zbd+3bx/nz5+nTp06lC5dOlvn1Do3IiJyO/acjmHQ7FBOXU7E2dGBUZ1r8VSryjg4FIGrNZePwaJhcHyt2S7bAHrMhLL1c/3UWf38tjzcWEHhRkREboVhGHyz8QTjlxwg1WanvJ87M/s1olGFIvAIIFs6bJ4Ff06A9CRwdoe2Y6D58+CUNwNBWf38zlcTikVERPKrmKQ0Xpm3m2V7zWGoDnVK88GDDfD1cLG4sjxwdjcsHAxnd5ntyndB92nmHJt8SOFGRETkJnZGRDN4diinryTh4uTAmC61efzOSoV/GCotCda8Dxumg2GDYr7QcTw07A/5+HtXuBEREbkOwzD4cv1x3l92gDSbQZC/OzP7htAgyM/q0nLf8XWwaKg5xwagzv3QeSJ4Z2+eqxUUbkRERK4hOjGVET/tZuX+8wB0rluG93rVx9e9kA9DJUXD769D6Ldm27ssdJ0MtbrecLf8ROFGRETkX3acvMLQH8KIjE7C1cmR17rV5pHmFQv/MNS+hbBkBMSbgY4mT8K9b5nDUQWIwo2IiMhf7HaDz9cd44PlB0m3G1Qs4cGsfiHULV+wPtyzLfYsLB0J+xeZ7RLVoMcMqHintXXdIoUbERER4EpCKi/9tItVB6IA6Fq/LO/1rId3sUI8DGUYEPoNrHgDUmLA0RlavgB3jQSXYlZXd8sUbkREpMjbfuIyQ34I42xMMq7OjrzRrQ7976hQuIehLh01F+M7sc5slwsxr9aUqWttXTlA4UZERIosu93gk7VHmbziEDa7QeUAT2b2a0RwuUI8DGVLg40zYPV7YEsBFw+45zW44zlwdLK6uhyhcCMiIkXSpfgUhs/dxZpDFwC4r2E53n2gHl5uhfij8UwYLBwC5/aY7SptofuHULySlVXluEL8ExQREbm2LccuMXROGOdjU3BzdmRsj2AeahpUeIehUhNh9XjYNAsMO7gXh44ToMHD+XoxvlulcCMiIkWG3W7w0eojTPn9EHYDqpb0ZFb/EGqVKcTPGTy22pxbc+WE2a7bCzq9D14lrawqVynciIhIkXAhLoXhc3ey7vBFAHqGlOft++riWViHoZKuwPLXYOd3ZtunPHSdAjU7WVtXHiikP1EREZH/t/HoRYbN2cmFuBSKuTjy9n116d0kyOqycodhwL5fYcnLkBAFOEDTgdDuDShWiK9Q/YPCjYiIFFo2u8HMVUeY9oc5DFW9lBez+odQo7S31aXljtgzsHgEHFxstgNqQo/pUKG5tXXlMYUbEREplKLiknlhzk42Hr0EQO/GgYy9LxgP10L40We3w46vYeVbkBILji7Qeji0fgmc3ayuLs8Vwp+wiIgUdRuOmMNQF+NTcHdx4t0H6tIzJNDqsnLHxcOwcCic2mi2yzcxF+MrXcfauiykcCMiIoWGzW4wbeUhZvx5BMOAmqW9mdU/hGqlvKwuLefZ0mDDh7Dmg78W4/M059U0e7rQLMZ3qxRuRESkUDgfm8zQH8LYcvwyAH2bBfFm92CKuRTCD/rIHbBgCETtNdvV7oVuU8GvgrV15RMKNyIiUuCtOXSB4T/u5FJCKp6uTozvWY/7Gpa3uqycl5oAq96FLR//tRifP3R+H+r1LpSL8d0qhRsRESmw0m12pvx+iI9WHwWgdlkfZvVrRJWShXAY6sgf8NsLEH3KbNfrA50mgGeApWXlRwo3IiJSIJ2NSWLoD2FsO3EFgP53VOD1bnUK3zBU4mVY/irsmm22fYPMIajq7a2tKx9TuBERkQLnzwNRDJ+7kyuJaXi5OfNer3p0q1/O6rJylmFA+M+w9BVIvAg4wB3Pmk/wdiuk6/TkEIUbEREpMNJsdiatOMina44BEFzOh1n9QqgU4GlxZTks5jQsfgkOLTPbJWuZt3cHNbO2rgJC4UZERAqEyGhzGGrHSXMY6tEWFRnTpXbhGoay22H7l7ByLKTGmYvx3TUSWr0Izq5WV1dgKNyIiEi+t3LfeUbM20V0Yhrebs68/2B9utQra3VZOevCQVg4BCK2mO2gO6D7dChVy9q6CiCFGxERybdS0+1MXHaAL9YfB6B+oC8z+4ZQoYSHxZXloPRUWD8V1k0CWyq4esG9b0GTp8DR0erqCiSFGxERyZciLicy5IcwdkZEA/BEy0qM6lwLN+dCNAwVsc28WnNhv9mu3gG6TgG/QvrE8jyicCMiIvnO8r3nGPnTLmKT0/Ep5swHvRvQMbiM1WXlnJR4WPUObPkEMMAjwFyMr24vLcaXAxRuREQk30hNtzNh6X6+3nACgIZBfszo24gg/0I0DHV4pbkYX0yE2W7QFzqOBw9/S8sqTBRuREQkXzh1KZHBP4Sy+3QMAE+3rszIjrVwdS4k804SLsGyUbBnrtn2qwDdPoRq7SwtqzBSuBEREcst3XOWl+ftJi4lHV93Fyb3bsC9dUpbXVbOMAzY85MZbBIvgYMj3PEfaDsG3ArhYyLyAYUbERGxTEq6jfGL9/PNppMAhFTwY0a/EMr7uVtcWQ6JPgW/DYcjv5vtUsHmYnyBja2tq5BTuBEREUucuJjA4B9CCY+MBeDZu6swokNNXJwKwTCU3QZbP4c/xkFaAji5wt0vw53DtBhfHlC4ERGRPPfb7jOM+nkP8SnpFPdwYUqfhrStVcrqsnJG1H7z9u7T28x2hRbmYnwla1hbVxGicCMiInkmOc3G27/t4/stpwBoWqk40/s2oqxvIRiGSk+BdZNh3RSwp4GrN7QfC42f0GJ8eUzhRkRE8sSxC/EMmh3G/rPmMNTzbaoyvH0NnAvDMNSpLebVmosHzXbNLtBlEviWt7auIsrScBMZGcnMmTPZuHEjzs7OtGrViuHDh+Pr63vdfd5++21+/PHHTNuqV6/O/Pnzc7tcERG5RQt2RjLmlz0kpNoo4enKlIcacneNklaXdftS4syHXG77AjDAsyR0+QDq3K/F+CxkWbix2WzcddddPPPMM7z99tskJiYyZswYli5dyvr163F1vfaEq8jISMqVK8eUKVMythUrViyvyhYRkWxITrPx1sK9zNlmLlh3R2V/pvdtRGmfQvB7+9By+O1FiI002w0HQIe3tRhfPmBZuHFycmLfvn24ubllbKtQoQLBwcFs3bqVVq1aXXdfHx8f6tatmxdliojILToSFc+g70M5eD4OBwcY0rYaQ9tVL/jDUPEXYNkrEP6z2S5eyVyMr2pbK6uSf7B0WOqfwQbA2dksx26333C/TZs20axZM3x9fWndujUjRozAw6MQLc0tIlLA/RJ6mtd+DScx1UaAlysfPtSIVtUDrC7r9hgG7JoDy0dD0hVzMb4Wg6DNGHDVZ1B+kq8mFL/11lsEBQXRrFmz6/bx8fFh8ODB3H333URGRvLmm2+yYMECNm/ejIuLyzX3SUlJISUlJaMdGxub47WLiAgkpdp4Y0E4P+04DUCLKiWY9nBDShX0YagrJ8whqKOrzHbpenDfDCjXyNKy5NryTbiZMGEC8+fPZ+XKlTecQzN+/PiMKzwAzZo1o1q1avz4448MGDDgusceO3ZsjtcsIiL/7/D5OJ7/PpTDUfE4OMCwdtUZck91nBwL8MRau818cveqdyAtEZzcoM0ouHMIOF37H9RivXwRbqZOncq4ceP49ddfadmy5Q37/jPYAFSsWJGKFSsSHh5+3X1Gjx7N8OHDM9qxsbEEBQXdXtEiIpLhp+0RvL4gnOQ0OyW93Zj2cEPurFrAh6HOhZu3d58JNdsVW0H3aRBQzdq65KYsDzfTpk1jzJgxzJ8/n44dO2Z7/7S0NKKiovDx8bluHzc3t6vm94iIyO1LSEnn9QXh/BJq3jHUunoAU/o0pKR3Af6dm5YMaz+ADR+CPR3cfKHDOGj0qBbjKyAs/SnNmDGDUaNGMX/+fDp16nTNPm+++SYPPPAAAKmpqbz++uvExcUB5lyaoUOHkpqaSu/evfOsbhERgQPnYukxcz2/hEbi6AAjOtTgmyeaFexgc3IjfNIK1k0yg02tbjBoCzR+XMGmALHsys2VK1cYNmwY3t7ejBgxghEjRmS8Nm7cOHr27AmY69ocPnwYABcXF7y8vKhatSqenp5ERUVRrVo1li9fTvXq1S35PkREihrDMPhxWwRvLtxLSrqd0j5uTH+4EXdUKWF1abcuORZWvgnbvzLbXqXNFYbr9LC2LrklDoZhGFac2GazsX///mu+Vr58eYoXLw7AmTNnSExMpFq1/x/jNAyDU6dOUbx48RsOR11PbGwsvr6+xMTE3NL+IiJFVXxKOq/O38OCnWcAuLtGSab0aUAJrwJ8tebAElj8EsSZ3xMhj0L7ceBe3Nq65CpZ/fy2dBG/rCzEV65cuau2OTg4ULFixdwoS0RErmPfmVgGzw7l2MUEnBwdGNGhJs/eVQXHgno3VHwULH0Z9v71+B7/KuaE4cp3WVuX3DbLJxSLiEj+ZhgGs7eeYuyifaSm2ynrW4zpfRvRtFIBfcyAYcDO72H5q5AcDQ5O5q3dbUaBSyF4Orko3IiIyPXFJacx+pc9/Lb7LAD31CrFpN4N8Pe89vP/8r3Lx2HRMDi+xmyXbQA9Zpj/lUJD4UZERK4pPDKGwbNDOXEpEWdHB17uVJOBrQroMJQtHbZ8DKvehfQkcC4GbcdA80HgpI/CwkY/URERycQwDP63+STv/LafVJud8n7uTO/biMYVC+gE27O7zcX4zu4025XvMh90WaKqlVVJLlK4ERGRDLHJaYz6eTdL9pwD4N7apZnUuz5+HgVwGCotCda8Dxumg2GDYr7Q4V1oNAAcCuDVJ8kyhRsREQFg9+loBs0OJeJyEi5ODrzSqRZPtaqMQ0EMAifWw8KhcPmo2a5zH3SeCN5lrK1L8oTCjYhIEWcYBl9vOMGEpftJsxkEFndnZr8QGgb5WV1a9iVFm4vx7fiv2fYuay7GV7ublVVJHlO4EREpwmIS0xg5bxcr9p0HoGNwaSY+2ABf9wL4xOv9i2DxCIg3h9Ro/AS0H2sOR0mRonAjIlJE7YyIZvDsUE5fMYehxnSpzeN3Vip4w1Bx52DJCDPcAJSoBt2nQ6WW1tYlllG4EREpYgzD4Mv1x3lv6QHS7QYV/D2Y2a8R9QP9rC4tewwDQr+FFa9DSgw4OkPLYXDXy+BSzOrqxEIKNyIiRUh0YiojftrFyv1RAHSpV4b3etXHp1gBG4a6dNRcjO/EOrNdrpG5GF+ZetbWJfmCwo2ISBGx4+QVhswO5UxMMq5OjrzerTYDmlcsWMNQtnTYNANWvwfpyeDsDve8Bnc8p8X4JIP+JIiIFHJ2u8Hn647xwfKDpNsNKpXwYGa/EOqWL2ATbc/sNBfjO7fbbFdpYy7G51/ZwqIkP1K4EREpxC4npPLS3J38efACAN0blGP8A3XxLkjDUKmJsHoCbJr112J8ftBpAjToq8X45JoUbkRECqltJy4zZHYY52KTcXV25K3uwfRtFlSwhqGOrTHn1lw5braDe0Ln98GrlLV1Sb6mcCMiUsjY7QYfrznKlN8PYbMbVAnwZFb/EGqX9bG6tKxLugIrXoOw78y2T3noOhlqdra2LikQFG5ERAqRS/EpvDh3F2sPmcNQ9zcsxzsP1MPLrYD8ujcM2LcAloyEBPOOLpoOhHZvQrECFM7EUgXkT7uIiNzMlmOXGDonjPOxKbg5OzLuvmD6NClAw1CxZ8wVhg8uNtsBNczF+Cq2sLYuKXAUbkRECjib3eCjP48wdeUh7AZULenJR/0bU7OMt9WlZY3dDqH/hd/fhJRYczG+VsOh9UtajE9uicKNiEgBdiEuhRd/3Mn6IxcB6BUSyNv3B+PhWkB+vV88bE4YPrnBbJdvAj2mQ+lga+uSAq2A/OkXEZF/23jkIsN+3MmFuBTcXZwYd18wvZsEWV1W1tjSYMM0WDMRbCng4gHt3oBmz4Cjk9XVSQGncCMiUsDY7AbT/zjM9FWHMQyoUdqLWf1CqF66gAxDRYaai/GdDzfbVdtBt6lQvKK1dUmhoXAjIlKARMUmM2zOTjYduwRAnyaBjO1RF3fXAnC1IzUB/hwPmz8Cww7u/tDpPajfR4vxSY5SuBERKSDWHb7Aiz/u5GJ8Kh6uTrz7QF0eaBRodVlZc3QVLHoBok+a7Xq9zWDjGWBpWVI4KdyIiORz6TY70/44zMw/j2AYUKuMNzP7hVCtlJfVpd1c4mVY/irsmm22fQLNIagaHaytSwo1hRsRkXzsfGwyQ34IY+vxywD0bRbEm92DKeaSz4ehDAP2/gJLX4GEC4CDOVm43evgVkDmBkmBpXAjIpJPrTlkDkNdTkjF09WJ8T3rcV/D8laXdXMxkbD4JTi01GyXrAU9ZkBQM2vrkiJD4UZEJJ9Jt9mZ/PshPl59FIDaZX2Y1a8RVUrm82Eoux22fwkrx0JqHDi6wF0joNWL4OxmdXVShCjciIjkI2djkhj6QxjbTlwBYEDzCrzWtU7+H4a6cMi8vTtis9kObGZerSlVy9q6pEhSuBERySf+PBDF8Lk7uZKYhpebM+/1qke3+uWsLuvG0lPNxfjWTgRbKrh6mQ+5bPqUFuMTyyjciIhYLM1mZ9Lyg3y69hgAdcv7MKtfCBVLeFpc2U2c3m5erYnaZ7ard4CuU8CvgKySLIWWwo2IiIUio5MYMjuU0FPRADx+ZyVGd6mFm3M+vuqREg+r3oEtnwAGeJSAzhOhbi8txif5gsKNiIhFft93nhE/7SImKQ3vYs588GB9OtUta3VZN3ZkJSx6EWJOme36D0PH8eBZwtq6RP5B4UZEJI+lptuZuOwAX6w/DkCDQF9m9gshyN/D4spuIOESLB8Du+eYbd8K0H0qVLvX2rpErkHhRkQkD0VcTmTwD2HsiogG4MmWlRnVuRauzo7WFnY9hgF75sGyVyDxEuAAzf8DbV8Ft3x+a7oUWQo3IiJ5ZPnec4z8aRexyen4FHNmUu8GdAguY3VZ1xcdAYuHw+EVZrtUHfP27sAm1tYlchMKNyIiuSwl3caEJQf478YTADQM8mNmv0YEFs+nw1B2G2z7wlyMLy0BnFzhrpeh5TBwdrW6OpGbsvQ66J49e3jiiSeoWbMmwcHBPPvss5w5c+am+3377bc0btyYwMBAOnfuzO7du/OgWhGR7Dt1KZEHP96UEWyebl2Zuc+2yL/BJmo/fNUJlr5sBpsKLeC5DXD3SAUbKTAsCzc2m41HHnmENm3asGjRIr7//nsOHz5Mu3btSEpKuu5+c+fOZeDAgQwZMoQ//viDwMBA2rZty/nz5/OwehGRm1uy5yxdp69jT2QMfh4ufPlYE17tWid/zq9JT4E/J8AnreH0VnD1hq6T4fElULKG1dWJZIuDYRiGVSc3DAOHf6yJcPToUapVq8aqVato27btNfdp0KABzZs359NPPwXMkFSuXDmee+45xo4dm6XzxsbG4uvrS0xMDD4+Prf/jYiI/ENymo13F+/nf5tPAtC4YnFm9G1EOT93iyu7joit5mJ8Fw6Y7RqdzWDjWwAe0ilFSlY/v7M95+bEiRPMnTuXtWvXcvr0aQCCgoK466676NOnDxUrVszysRz+tdjT31dsihUrds3+MTEx7N69m9deey1jm5OTE/fccw/r1q3L7rciIpLjjl9MYPDsUPaeiQXgubur8lKHGrg45cOrNSlx8Mc42Po5YIBnSXMxvuAHtBifFGhZ/tt27NgxHnzwQapXr853331H6dKl6dKlC126dKFUqVJ8++23VKtWjd69e3Ps2LFsF2IYBq+88gq1atWiSZNrz8T/ez5O6dKlM20vXbo0Z8+eve6xU1JSiI2NzfQlIpLTFu06Q/cZ69l7JpbiHi58/URTRnWulT+DzaEVMKs5bP0MMKBhfxi0Fer2VLCRAi/LV25atGjBM888w6RJk6hUqdI1+5w4cYIvv/ySFi1aZHsOzPDhw9mwYQNr167FxcXlmn3+HkFzcsq8LLmzszN2u/26x54wYUKWh6xERLIrOc3GuN/2MXuLuWpv00rFmd63EWV98+EwVMJFWPoKhM8z234Vofs0qHrtqQAiBVGW59xcunSJEiWytrx2dvoCjBo1io8//pjff/+dZs2aXbffhQsXKFWqFPPnz+f+++/P2P7YY49x9OhR1q9ff839UlJSSElJyWjHxsYSFBSkOTcictuOXohn0PehHDgXh4MDPN+mKi/eWwPn/Ha1xjBg94+wbDQkXQYHR2j+PLQdA675/AGdIn/J8Tk3NworhmFw9OhRypQpg5eXV7aCzZgxY/j4449ZsWLFDYMNQMmSJalcuTLr16/PFG7Wrl1Lz549r7ufm5sbbm5uWa5JRCQrfg2LZMz8PSSm2ijh6crUhxpyV42SVpd1tSsn4bcX4egfZrt0XXMxvvIh1tYlkktu6Z8W27ZtY9CgQRntfv36Ub16dcqUKZOtib2vv/46s2bNYsWKFdxxxx3X7PPiiy/SunXrjPbQoUP54osv2LJlC+np6UycOJEzZ87w7LPP3sq3IiKSbUmpNkb9vJsXftxJYqqN5lX8WTKsdf4LNnYbbPoIPmpuBhsnN2j3BjyzWsFGCrVbWqF4xIgRjB8/HoDdu3ezdOlStm/fzvLly3n11VdZu3btTY9x6dIl3nnnHdzc3OjatWum1z788EMGDBgAQFxcHFeuXMl4bdiwYURFRXHvvfeSkpJC+fLl+eWXX6hRQ+swiEjuOxIVx6Dvwzh43hyGGnJPdYa1q46TYz6bhHt+r3l7d+QOs12xJXSfDgHVrK1LJA/c0jo3Xl5eXLhwAXd3dyZPnszevXv56quviI+Pp1y5clm6G8kwDC5dunTN17y9vTOGkeLj40lPT8fPzy9TH7vdTkJCAt7e3tktX+vciMgt+XnHaV77NZykNBsBXm5Me7ghLasFWF1WZmnJsG4SrJ8K9nRw84H24yDkMXDMZ/OARLIp19a5AfDx8eHYsWMEBwezaNEinnrqKQCio6OzHBYcHBwICLj5LwUvr2s/ddbR0fGWgo2ISHYlpqbzxoK9zNthru3VsloJpj7UkFLe116TyzInN8GioXDxkNmu2RW6TgKfctbWJZLHbinc9OnTh65du1KnTh327NlDt27dAFi2bBldunTJ0QJFRKx06Hwcg74P5XBUPI4O8MK9NRjUtlr+GoZKjoU/xpoPuwTwKg1dPoDaPbRmjRRJtxRuJk2aRPXq1Tl58iQTJkygePHigPn4hDfeeCNHCxQRsYJhGPy04zRvLAgnOc1OSW83pj/ciBZVs343aJ44uBR+Gw5xfz10uNEj0OFtcC9ubV0iFrL02VJW0ZwbEbmRhJR0Xv81nF/CIgFoXT2AqQ81JMArHy0pER9lPrl773yzXbyyuRhflbutrUskF2X18zvLs8t69+7NgQMHbtpv37599O7dO6uHFRHJVw6ci6XHzPX8EhaJowOM7FiTb55oln+CjWFA2Pcws6kZbBycoOUw+M9GBRuRv2R5WKp58+Y0b96cRo0a0b17dxo3bkzp0qUxDINz586xbds2Fi5cyJ49e3j99ddzs2YRkRxnGAZztkXw1sK9pKTbKe1jDkPdUSUfDUNdPg6/vQDHVpvtMvXNxfjKNbSwKJH8J1vDUpcuXeLTTz9lzpw5hIeHZzzrycHBgXr16tG3b1+efvrpbK1QbAUNS4nIP8WnpDPmlz0s3GXOW7m7Rkmm9GlAifxytcaWDls+hlXvQnoSOBeDNqOhxWBwuqWpkyIFUlY/v295zk1MTAyRkZE4ODhQrlw5fH19b7nYvKZwIyJ/23smhsGzwzh+MQEnRwdGdKjJs3dVwTG/3A11bo+5GN+ZMLNdqbU5t6ZEVWvrErFArq5zA+Dr61ugAo2IyD8ZhsF3W07x9m/7SE23U9a3GDP6NqJJJX+rSzOlJcPaibBh2l+L8flCx3fMu6F0e7fIDd1yuImLi2PFihUcO3aMkSNHArB//35q1aqFg/7iiUg+Fpucxuhf9rB491kA2tUqxaTeDSju6WpxZX85sR4WDYNLR8x27R7mujXeZaytS6SAuKVhqQMHDtC+fXvsdjtnzpzJmHvz2GOP0bFjR/r165fjheYkDUuJFF3hkTEMmh3KyUuJODs68EqnWgxsXTl//KMsOQZ+fwN2/Ndse5UxVxiu3d3SskTyixy/FfyfXnzxRR555BFOnz6dafvQoUOZNGnSrRxSRCRXGYbBNxtP0POjjZy8lEh5P3fmPteCp++qkj+Czf7fYGaz/w82jR+HQVsUbERuwS1dufHz8+PEiRP4+fnh4OCQceUmISEBf39/UlJScrzQnKQrNyJFS0xSGqN+3s3S8HMA3Fu7NJN618fPIx8MQ8Wdh6UjYd8Cs+1fFXpMh0qtrK1LJB/K1QnFhmFkBJh//ovn2LFjmmQsIvnKrohoBv8QSsTlJFycHBjVuTZPtqxk/dUaw4Cw/8GK18zhqL8X47v7ZXBxt7Y2kQLulsJNhw4dmDhxIpMnT874BREVFcXgwYPp3LlzjhYoInIrDMPg6w0nmLB0P2k2g8Di7szqF0KDID+rS4NLR80JwyfWme2yDeG+mVCmnqVliRQWtzQsFRERQZs2bXB0dOTIkSO0atWKsLAwypQpw7p16yhbtmxu1JpjNCwlUrjFJKYxct4uVuw7D0Cn4DK8/2B9fN1drC3Mlg6bZsLqCZCeDM7ucM+rcMd/tBifSBbk6rBUUFAQu3fvZvbs2Wzfvh273U6/fv145JFH8PLyuuWiRURuV9ipKwyeHUZkdBKuTo682rU2j7aoaP0w1NldsGAwnNtttqu0gW4fgn9lK6sSKZT0VHBduREpFAzD4It1x3l/2QHS7QYVS3gws28I9QItngeYlmReqdk4EwwbFPODjuOhYT8txieSTbm+QjGA3W4nMTHxqu26eiMieelKQiojftrFHweiAOhavywTetbDp5jFw1DH18LCoXDluNkO7gmd3wevUtbWJVLI3VK4OXjwIM899xwbN24kNTX1qteL4MUgEbHIjpOXGTI7jDMxybg6O/JGtzr0v6OCtcNQSVdgxevm3VAA3uWg62So1cW6mkSKkFsKN4899hhlypRhwYIF+Pn55XBJIiI3Z7cbfLbuGB8sP4jNblA5wJOZ/RoRXM7iYah9C2DJSIg3JzPT5Cm4900opmUyRPLKLYWbXbt2sWzZMgUbEbHE5YRUhs/dyeqDFwDo0aAc43vWw8vNwjuOYs/CkhFw4DezXaI69JgBFVtYV5NIEXVLvwkqVapEVFSUwo2I5Lmtxy8z9IcwzsUm4+bsyFs9gnm4aZB1w1B2O4R+Yz4TKiUWHJ2h1YvQegS4FLOmJpEi7pbCzbhx43jiiSd4//33qVq16lW/VMqU0ZNrRSRn2e0GH685ypTfD2GzG1Qp6cmsfiHULmvhHY8Xj5iL8Z1cb7bLNzav1pQOtq4mEbm1cFOiRAnCw8Np3br1NV/XhGIRyUkX41N48cedrDt8EYAHGpXnnfvr4mnVMJQtDTZOh9Xvgy0FXDzgntfhjmfB0cmamkQkwy39Znj++efp2rUrzz//vIamRCRXbTp6iWFzwoiKS6GYiyPjetSld5NA64ahIkPN27vP7zHbVe8xF+MrXtGaekTkKrcUbk6dOsXWrVu1AJ6I5Bqb3WDmqiNM++MQdgOqlfLio/4h1CjtbU1BqQnw53jY/BEYdnAvDp3eg/oPaTE+kXzmlsJN9erVOX36NHXq1MnpekREuBCXwgs/hrHhyCUAHmwcyLj7gvFwtWgY6uif5tya6JNmu+6DZrDxKmlNPSJyQ7f0m2LAgAEMGDCA999/n2rVql11ebhSpUo5UZuIFEEbj1xk6JydXIxPwd3Fibfvr8uDjQOtKSbxsrkY387vzLZPIHSbAjU6WlOPiGTJLT1b6mZj3fl9QrGeLSWS/9jsBtP+OMyMVYcxDKhR2otZ/UKobsUwlGHA3vmw9GVIuAA4QLOnod0b4GbRsJiI5O6zpQ4fPnzLhYmI/FtUbDJD54Sx+dhlAB5qEsRbPYJxd7XgzqOYSFj8EhxaarYDapq3d1e4I+9rEZFbckvhplq1ajldh4gUUesOX+DFH3dyMT4VD1cnxj9Qj/sblc/7Qux22PEV/P4WpMaBowu0fglaDwdnt7yvR0RuWZbDTXh4OAB169bN+P/rqVu37u1VJSKFXrrNzocrDzNr9REMA2qV8WZW/xCqlvTK+2IuHIJFQ+HUJrMd2NS8WlOqdt7XIiK3Lcvhpl69eoA5n+bv/7+e/D7nRkSsdS4mmaE/hLH1hDkM1e+OCrzRrQ7FXPJ4GCo9FTZMg7UTwZYKLp7mQy6bDtRifCIFWJbDzdmzZ6/5/yIi2bH6YBTD5+7ickIqXm7OjO9Zjx4NyuV9Iad3wMIhELXXbFdrD92mgl9Q3tciIjkqy+GmTJkyDBw4kC+++ELPjhKRbEu32Zn8+yE+Xn0UgOByPszsF0LlAM+8LSQ1AVa9C1s+Nhfj8ygBnd6Heg9qMT6RQiJbt4I7ODgUiiEn3QoukrfORCcx9Icwtp+8AsAjzSvyatfaeT8MdWQl/PYiRJ8y2/Ufgo4TwLNE3tYhIrckV28Fz2mGYZCSkoKrqyuOjo437Juenk56enqmbY6Ojri6uuZmiSJyi1YdOM/wubuITkzD282Z93rVp2v9snlbROJlWDYads8x274VzCGo6vfmbR0ikidunCRy2YULF3jvvfeoUqUK7u7urF279qb7DB48GE9PT/z8/DK+WrRokQfVikh2pNnsjF+ynyf/u53oxDTqlfflt6Gt8jbYGAbsmQczm/4VbBzgjv/A85sUbEQKsWxfuXF2vvku/76ycj0ff/wxCQkJfPPNN9x9991ZruGBBx5g3rx5We4vInnr9JVEhvwQRtipaAAev7MSo7vUws05D4ehoiPMxfgOLzfbpeqYt3cHNsm7GkTEEtkONzNnzsyxk7/xxhsAnD59Otv72u32mw5hiUjeW7H3HCPn7SYmKQ3vYs588GB9OtXNw6s1djts+wL+GAup8eDkCneNhJYvgLOGr0WKgmyHm+eeey436siWJUuW4Obmhre3N61atWLy5MlUr17d6rJEirTUdDvvLT3AVxuOA9Ag0JeZ/UII8vfIuyKiDpi3d5/earaDmkOP6VCyZt7VICKWK3CXPmrVqsWCBQuIj49nx44dGIbB3XffzZUrV667T0pKCrGxsZm+RCTnRFxOpPcnGzOCzVOtKvPTc3fmXbBJT4XV78Enrcxg4+oFXSbBE0sVbESKoHxxt1R2vPDCCxn/X7lyZb7//nvKlCnDjz/+eN2rShMmTGDs2LF5VKFI0bIs/Bwj5+0iLjkdX3cXJvVuQPs6pfOugIitsHAoXNhvtmt0gq6TwTcw72oQkXwlW+EmKSkpt+q4ZT4+PgQGBnL06NHr9hk9ejTDhw/PaMfGxhIUpFVIRW5HSrqNCUsO8N+NJwBoVMGPGX0bEVg8j67WpMTBH2/D1s8AAzwCoMtECO6pxfhEirhshZtixYrlVh3XlZ6ejt1uv+46NpcvX+bUqVMEBl7/X2lubm64uempviI55eSlBAbPDmNPZAwAz95VhREda+LilEcj3Yd/Nxfji4kw2w37Q4d3wMM/b84vIvmapXNubDYbycnJpKSkAJCamkpycnKmW8mfe+45QkJCAHPuTJcuXVi7di2XLl0iLCyMBx98kOLFizNgwABLvgeRombx7rN0m76ePZEx+Hm48NXjTRjdpXbeBJuEi/DzQPj+QTPY+FWAR+bD/R8p2IhIBkvDzezZs/Hz8yM4OBg3Nzd69OiBn58f7733XkYfFxeXjKsubm5ujBgxgnfeeYdatWrx0EMPUblyZbZt20aJElo+XSQ3JafZeP3XcAbNDiUuJZ0mFYuzZGhr7qmVB/NrDAN2/WguxrfnJ3BwhBaD4fnNUPWe3D+/iBQo2Xq2VGGhZ0uJZM/xiwkM+j6UfWfNOw3/06Yqw9vXyJurNdGnzCGoIyvNdum65u3d5Rvn/rlFJF8pUM+WEpH8a+GuM4z+eTcJqTb8PV2Z0qcBbWqWyv0T223mZOE/3oa0BHByg7tfhpbDwMkl988vIgWWwo2IXFNymo2xi/bxw1bzCdrNKvsz/eFGlPHNgxsLzu8zF+OL3G62K9xpXq0J0GKdInJzCjcicpWjF+IZ9H0oB87F4eAAg9tWY1i76jjn9jBUegqsnQTrp4I9Ddx8oP1YCHkc9LgVEckihRsRyeTXsEjGzN9DYqqNAC9Xpj7UkNbVS+b+iU9tNq/WXDxktmt2ha6TwKdc7p9bRAoVhRsRASAp1cZbC/fy43Zz7ZjmVcxhqFI+uTwMlRxrPuRy2xdm27MUdPkA6tynxfhE5JYo3IgIR6LiGPR9GAfPm8NQQ++pztB21XFyzOVwcXAZLB4OsZFmu9EAczE+9+K5e14RKdQUbkSKuHk7TvP6r+EkpdkI8HJj+sMNubNaQO6eNP4CLHsFwn8228UrQfdpUKVN7p5XRIoEhRuRIioxNZ3Xf93Lz6GnAWhZrQRTH2pIKe9cHIYyDNj1AywfA0lX/n8xvjajwTWPnkklIoWewo1IEXTwXByDZodyJCoeRwd44d4aDGpbLXeHoa6cgEUvwLE/zXaZetBjJpRrmHvnFJEiSeFGpAgxDIO52yN4c+FektPslPJ2Y3rfRjSvkouPL7HbYPPH8Oe7kJYIzsWgzSjzio0W4xORXKBwI1JEJKSk8+r8Pfy68wwArasHMPWhhgR4ueXeSc+Fm7d3nwk125Vam3NrSlTNvXOKSJGncCNSBOw/G8ug2aEcu5CAk6MDw9vX4D93V8Uxt4ah0pJh7UTYMA3s6eDmCx3ehpBHdXu3iOQ6hRuRQswwDH7YGsHYRXtJSbdTxqcYM/o1omkl/9w76YkNsGgoXDpitmv3MNet8S6Te+cUEfkHhRuRQiouOY0x88NZtMschmpbsyST+zTE39M1d06YHAMr34LtX5ltrzLmCsO1u+fO+URErkPhRqQQCo+MYfDsUE5cSsTJ0YGRHWvyTOsquTcMdWAxLH4J4s6a7ZDHoP04cPfLnfOJiNyAwo1IIWIYBt9tOcXbv+0jNd1OOV9zGKpxxVwahoo7D0tHwr4FZtu/qjlhuHLr3DmfiEgWKNyIFBKxyWmM/nkPi/eYV0/urV2KDx5sQPHcGIYyDAj7Dla8ag5HOThBy2Fw98vg4p7z5xMRyQaFG5FCYM/pGAbNDuXU5UScHR0Y1bkWT7WqjENu3Jl0+RgsGgbH15rtsg3MxfjK1s/5c4mI3AKFG5ECzDAMvtl4gvFLDpBqs1Pez52Z/RrRqEIuPHjSlg6bZ8GfEyA9CZzdoe0YaP48OOlXiYjkH/qNJFJAxSSl8cq83Szbew6ADnVK88GDDfD1yIVVf8/uMhfjO7vLbFe+G7p/CP5Vcv5cIiK3SeFGpADaGRHN4NmhnL6ShIuTA2O61ObxOyvl/DBUWhKsfg82zgDDBsV8oeN4aNhfi/GJSL6lcCNSgBiGwVcbTvDe0v2k2QyC/N2Z2TeEBkF+OX+y4+vMxfguHzPbde6HzhPBu3TOn0tEJAcp3IgUENGJqYyct5vf950HoHPdMrzXqz6+7jk8DJUUDb+/DqHfmm3vstB1MtTqmrPnERHJJQo3IgVA6KkrDJkdRmR0Eq5OjrzWrTaPNK+Y88NQ+xbCkhEQbwYomjwF975pDkeJiBQQCjci+ZjdbvDF+mNMXHaQdLtBxRIezOoXQt3yORw2Ys+aoebAb2a7RDXoMQMq3pmz5xERyQMKNyL51JWEVF76aRerDkQB0LV+Wd7rWQ/vYjk4DGUYEPoNrHgDUmLA0RlavgB3jQSXYjl3HhGRPKRwI5IPbT9xmSE/hHE2JhlXZ0fe6FaH/ndUyNlhqEtHzcX4Tqwz2+VCzKs1Zerm3DlERCygcCOSj9jtBp+sPcrkFYew2Q0qB3gys18jgsvl4DCULc28tXv1e2BLARcPuOc1uOM5cHTKufOIiFhE4UYkn7gUn8LwubtYc+gCAPc1LMe7D9TDyy0H/5qeCTMX4zu3x2xXaWsuxle8Us6dQ0TEYgo3IvnA1uOXGfJDKOdjU3BzdmRsj2AeahqUc8NQqYmwejxsmgWGHdyLQ8cJ0OBhLcYnIoWOwo2Ihex2g49WH2HK74ewG1C1pCez+odQq4xPzp3k2Gpzbs2VE2a77oPQ6T3wKplz5xARyUcUbkQscjE+hRd/3Mm6wxcB6NmoPG/fXxfPnBqGSroCy1+Dnd+ZbZ/y0HUK1OyUM8cXEcmnFG5ELLDp6CWGzQkjKi6FYi6OjLuvLr0bB+bMMJRhwL5fYcnLkBAFOEDTgeZifG7et398EZF8TuFGJA/Z7AYzVx1h2h/mMFT1Ul7M6h9CjdI5FDpiz8DiEXBwsdkOqAk9pkOF5jlzfBGRAkDhRiSPRMUl88KcnWw8egmA3o0DGXtfMB6uOfDX0G6HHV/DyrcgJRYcXaD1cGj9Eji73f7xRUQKEIUbkTyw4chFhs3ZycX4FNxdnHj3gbr0DAnMmYNfPAwLh8KpjWa7fBNzMb7SdXLm+CIiBYzCjUgustkNpq08xIw/j2AYULO0N7P6h1CtlFcOHDwNNnwIaz74azE+T2j3BjR7WovxiUiRli/CTUJCAmfPnqV8+fK4u7tneZ8rV65QtmxZnJz0i1zyn/OxyQz9IYwtxy8D0LdZEG92D6aYSw78eY3cAQuGQNRes13tXug2Ffwq3P6xRUQKOEcrT37o0CEGDx5MpUqVqF69Olu2bLnpPjabjUGDBuHv70/9+vUpU6YMc+bMyYNqRbJu7aELdJm2ji3HL+Pp6sS0hxsyoWf92w82qQmwbAx8ca8ZbNz9oefn0H+ego2IyF8svXKzbNkyatasyerVq6lbN2sP65s4cSJz585l586d1K5dm88++4wBAwZQt27dLB9DJLek2+xMXXmIj1YfxTCgdlkfZvVrRJWSOTAMdeQP+O0FiD5ltus/BB3Hg2fA7R9bRKQQcTAMw7C6iNOnTxMUFMSff/5JmzZtbti3QoUK9O/fnwkTJmRsq1GjBp06dWL69OlZOl9sbCy+vr7ExMTg45ODK8FKkXY2JolhP+xk6wlzGKr/HRV4vVud279ak3gZlr8Ku2abbd8gcwiqevvbrFhEpGDJ6ud3vphzk1Xnz58nIiKCFi1aZNresmVLtm/fblFVIvDnwSiG/7iTK4lpeLk5M6FnPbo3KHd7BzUMCP8Zlr4CiRcBB7jjWbjndXDLgStBIiKFVIEKNxcvmsvUlyhRItP2gIAANmzYcN39UlJSSElJyWjHxsbmToFS5KTZ7ExacZBP1xwDILicD7P6hVApwPP2DhxzGha/BIeWme2Stc3bu4Oa3mbFIiKFX4EKN46O5vzntLS0TNtTU1NveMfUhAkTGDt2bK7WJkVPZHQSQ38IY8fJKwA82qIiY7rUvr1hKLsdtn9pLsaXGg9OrnDXSGj5Aji75kjdIiKFXYEKN4GB5qJn586dy7T93LlzGa9dy+jRoxk+fHhGOzY2lqCgoNwpUoqElfvOM2LeLqIT0/B2c+b9B+vTpV7Z2zvohYOwcAhE/HXXYNAd0H06lKp1+wWLiBQh+T7cXLhwgeTkZIKCgvD29qZx48YsX76chx9+GDCv2qxcuTJTePk3Nzc33Ny0BL3cvjSbnYnLDvD5uuMA1A/0ZWbfECqU8Lj1g6anwvqpsG4S2FLB1QvufQuaPAWOlq7WICJSIFkabuLi4jh//nzGlZjIyEiOHDmCv78//v7+gHnVZfPmzYSHhwPw5ptv0rNnTxo2bEiLFi2YMmUKrq6uPPfcc5Z9H1I0nL6SyODZYeyMiAbgiZaVGNW5Fm7OtzEMFbHNvFpzYb/Zrt4Ruk0B3xx6NIOISBFkabj5/fffefnllwGoWrUqb775JgBDhw5l6NChAJQqVYoKFf5/cbLu3bvz008/MX36dD777DPq1avH2rVrr5pkLJKTVuw9x4ifdhGbnI5PMWc+6N2AjsFlbv2AKfGw6m3Y8ilggEcAdH4f6vYCB4ccq1tEpCjKF+vc5DWtcyNZlZpuZ8LS/Xy94QQADYL8mNm3EUH+tzEMdXiluRhfTITZbtDXXIzPw/+26xURKcwK5To3Inkp4nIig2eHsut0DAADW1Xm5U61cHW+xXkwCZdg2SjYM9ds+1WAbh9CtXY5U7CIiAAKNyLXtCz8LCPn7SYuOR1fdxcm927AvXVK39rBDAP2/GQGm8RL4OAIzZ+HtmPA9TbXwxERkaso3Ij8Q0q6jfGL9/PNppMAhFTwY0a/EMr7Ze1p9VeJPgW/DYcjv5vtUsHmYnyBjXOoYhER+TeFG5G/nLiYwOAfQgmPNFewfvbuKozoUBMXp1sYhrLbYOvn8Mc4SEswF+O7+2VzMT4nl5wtXEREMlG4EQF+232GUT/vIT4lneIeLkzp05C2tUrd2sGi9pu3d5/eZrYr3Andp0HJGjlXsIiIXJfCjRRpyWk23lm8j+82nwKgaaXiTO/biLK+tzAMlZ4C6ybDuilgTwNXb2g/Fho/ocX4RETykMKNFFnHLyYw6PtQ9p01h6Geb1OV4e1r4Hwrw1CntphXay4eNNs1u0DXyeBzm08GFxGRbFO4kSJpwc5Ixvyyh4RUG/6erkx9qCF31yiZ/QOlxMHKsbDtC8AAz5LQ5QOoc78W4xMRsYjCjRQpyWk2xi7ayw9bzQX0mlX2Z/rDjSjjWyz7Bzu0HH57EWIjzXajAdD+bS3GJyJiMYUbKTKORMUzeHYoB87F4eAAg9tWY1i76tkfhoq/AMtegfCfzXbxSuaE4SptcrpkERG5BQo3UiT8Enqa134NJzHVRoCXKx8+1IhW1QOydxDDgF1zYPloSLpiLsbXYhC0GQOut/E4BhERyVEKN1KoJaXaeGNBOD/tOA1AiyolmPZwQ0r5ZHMY6soJcwjq6CqzXboe3DcDyjXK2YJFROS2KdxIoXX4fBzPfx/K4ah4HBxgWLvqDLmnOk6O2Zjoa7fBlk9g1TuQlghObtBmFNw5RIvxiYjkUwo3Uij9tD2CNxbsJSnNRklvN6Y93JA7q2ZzGOpcuHl795lQs12xFfSYDiWq5nzBIiKSYxRupFBJTE3ntV/D+SXUvIOpdfUApvRpSElvt6wfJC0Z1n4AGz4Eezq4+UKHcdDoUS3GJyJSACjcSKFx8Fwcz3+/g6MXEnB0gOHta/B8m2o4ZmcY6uRGWDgULh0227W6QZdJ4FM2d4oWEZEcp3AjBZ5hGMz9axgqJd1OaR83pj3ciOZVSmT9IMkxsPIt2P6V2fYqbYaaOj1ypWYREck9CjdSoMWnpPPa/D38uvMMAHfVKMnUPg0o4ZWNYagDS2DxSxBnHoOQx6D9OHD3y/mCRUQk1yncSIG170wsg2eHcuxiAk6ODrzUoQbP3VU168NQ8VGw9GXYO99s+1cxF+OrfFfuFS0iIrlO4UYKHMMwmL31FGMX7SM13U5Z32JM79uIppWy+NgDw4Cd38PyVyE5GhyczFu724wCl1t4GriIiOQrCjdSoMQlpzH6lz38tvssAPfUKsWk3g3w93TN2gEuH4NFL8DxNWa7bAPoMcP8r4iIFAoKN1JghEfGMHh2KCcuJeLs6MDLnWoysFWVrA1D2dJh80fw53hITwJnd2g7Bpo/D076ayAiUpjot7rke4Zh8N3mk7z9235SbXbK+7kzvW8jGlcsnrUDnN1tLsZ3dqfZrnyXObfGv0qu1SwiItZRuJF8LTY5jVE/72bJnnMA3Fu7NJN618fPIwvDUGlJsOZ92DAdDBsU84UO70KjAeCQjbVvRESkQFG4kXxr9+loBs8O49RlcxhqVOdaPNWqMg5ZCSYn1puL8V0+arbr3A+dJ4J36VytWURErKdwI/mOYRj8d+MJxi/ZT5rNoLyfOzP7NaJRhSwMQyVFw+9vQOg3Ztu7LHSdDLW65mrNIiKSfyjcSL4Sk5jGyz/vYvne8wB0qFOaDx5sgK9HFp7AvX8RLB4B8eYQFo2fgPZjzeEoEREpMhRuJN/YGRHN4NmhnL6ShIuTA2O61ObxOyvdfBgq7hwsGWGGG4AS1aD7dKjUMveLFhGRfEfhRixnGAZfrj/Oe0sPkG43qODvwcx+jagf6HezHSH0W1jxOqTEgKMztHwB7hoJLsXyonQREcmHFG7EUtGJqYz4aRcr90cB0KVeGd7rVR+fYjcZhrp0FBYNgxPrzHa5RuZifGXq5XLFIiKS3ynciGV2nLzC0B/CiIxOwtXJkde71WZA84o3HoaypcOmGbD6PUhPNhfju+c1aP4fcHTKu+JFRCTfUriRPGe3G3y+7hgfLD9Iut2gUgkPZvYLoW75m0z8PbPTXIzv3G6zXaUtdJsK/pVzvWYRESk4FG4kT11OMIehVh0wh6G6NyjH+Afq4n2jYajURFg9ATbN+msxPj/oNAEa9NVifCIichWFG8kz205cZugPYZyNScbV2ZG3ugfTt1nQjYehjq0x59ZcOW626/aCTu+BV6m8KVpERAochRvJdXa7wSdrjzJ5xSFsdoMqAZ7M7BdCnXI+198p6QqseA3CvjPbPuWh6xSo2SlvihYRkQJL4UZy1aX4FIbP3cWaQxcAuL9hOd55oB5ebtf5o2cYsG8BLBkJCebQFU2fhnZvQLEbhCEREZG/KNxIrtly7BJD54RxPjYFN2dHxt0XTJ8mNxiGij1jrjB8cLHZDqhh3t5doXneFS0iIgVevgg3x48f5/z589SsWZPixW/8/KBDhw5x5syZTNs8PT1p2rRpbpYo2WCzG3z05xGmrjyE3YCqJT35qH9japbxvvYOdjuE/hd+fxNSYsHRBVoPh9YvgbNbntYuIiIFn6XhJikpiYcffpg//viDypUrc+TIEcaPH8+LL7543X2mTJnCzz//THBwcMa2ypUr8/XXX+dFyXITF+JSePHHnaw/chGAXiGBvH1/MB6u1/mjdvGwOWH45AazXb6JebWmdJ08qlhERAobS8PNW2+9RVhYGEePHqV06dIsWrSIHj160KJFC5o3v/5QxN133828efPysFLJio1HLzJszk4uxKXg7uLEuPuC6d0k6NqdbWmwYRqsmQi2FHDxhHavQ7NntBifiIjcFkvDzX//+18GDRpE6dKlAejevTv169fn66+/vmG4SUpKYuvWrfj6+lK1alWcnfPF6FqRZbMbzFh1mOl/HMZuQI3SXszqF0L10tcZhooMNRfjOx9utqu2MxfjK14x74oWEZFCy7JUEBkZSVRUFI0bN860vXHjxoSFhd1w35UrV3L27FnOnTuHg4MDn3zyCd27d79u/5SUFFJSUjLasbGxt1e8ZIiKS+aFOTvZePQSAH2aBDK2R13cXa9x9SU1Af4cD5s/AsMO7v7Q+X2o11uL8YmISI5xtOrEV65cAcDf3z/T9oCAgIzXrqVLly6cOXOG0NBQTp8+zWOPPcZDDz3E4cOHr7vPhAkT8PX1zfgKCrrOUIlky/rDF+kybR0bj17Cw9WJKX0aMPHBBtcONkdXwUctYNNMM9jU6wODt0H9Pgo2IiKSoywLN66uroA5xPRPiYmJGa9dS48ePShRogQAjo6OvP3227i5ubFo0aLr7jN69GhiYmIyviIiInLgOyi60m12Jq84yCNfbeFifCq1ynizcHAreoYEXt058TLM/w/87wGIPgk+gdDvJ+j1OXgG5H3xIiJS6Fk2LBUYGIijoyORkZGZtkdGRlKxYtbnXjg5OeHv73/V7eH/5ObmhpubbinOCedjkxnyQxhbj18GoG+zIN7sHkwxl39drTEM2PsLLH0FEi4ADnDHs+YTvN2uMxdHREQkB1h25cbDw4OWLVuycOHCjG3x8fGsXLmS9u3bZ2w7ePAg27ZtA8AwDBISEjId5+DBg5w4cYJ69erlTeFF2JpDF+g8bR1bj1/G09WJaQ83ZELP+lcHm5hI+KEvzHvSDDYla8FTK8z5NQo2IiKSyxwMwzCsOvm6deto164dw4YNo0WLFsycOZOIiAjCwsLw8vICYODAgWzevJnw8HBSU1Np2LAhjz/+OMHBwZw6dYr33nuPcuXKsWbNmhsOZ/1TbGwsvr6+xMTE4OOjJf1vJt1mZ8rvh/ho9VEAapf1YVa/RlQp6ZW5o90O27+ElWMhNc5cjO+uEdDqRS3GJyIity2rn9+WXbkBaN26NWvXruX8+fN8+umnhISEsGHDhoxgA1CzZs2M1YddXV35888/iY+P55NPPmHTpk289tprrFu3LsvBRrLnbEwSfT/fnBFsBjSvwPzn77w62Fw4CF93hiUjzGAT2AyeWw9tRinYiIhInrL0yo1VdOUma/48EMXwuTu5kpiGl5sz7/WqR7f65TJ3Sk+FDR/C2g/AlgquXnDvW9DkKXC0NDuLiEghk9XPb61+J1dJs9mZtPwgn649BkDd8j7M6hdCxRKemTue3m4uxhe1z2xX7wBdp4CfbrUXERHrKNxIJpHRSQyZHUroqWgAHr+zEqO71MLN+R+ThlPiYdU7sOUTwACPEtB5ItTtpTVrRETEcgo3kmHlvvO89NMuYpLS8C7mzMRe9elcr2zmTodXwm8vQswps92gL3R4FzxL5H3BIiIi16BwI6Sm25m47ABfrD8OQINAX2b0DaFCCY//75RwCZaPht0/mm3fCtB9KlS714KKRURErk/hpoiLuJzI4B/C2BURDcCTLSszqnMtXJ3/mgxsGLBnHix7BRIvAQ7Q/D/Q9lVw87rucUVERKyicFOELd97jpE/7SI2OR2fYs5M6t2ADsFl/r9DdAQsHg6HV5jtUnWgxwwIbGJNwSIiIlmgcFMEpabbmbB0P19vOAFAwyA/ZvZrRGDxv4ah7DbY9oW5GF9aAji5wt0vw53DwFnrCYmISP6mcFPEnLqUyOAfQtl9OgaAp1tXZmTHfwxDRe03b+8+bT7yggotoPt0KFnDoopFRESyR+GmCFm06wxjftlDXEo6fh4uTO7dgHa1S5svpqfAuimwbjLY08DVG9q/BY2f1GJ8IiJSoCjcFAGJqemMXbiPH7dHANC4YnFm9G1EOT93s0PEVvNqzYUDZrtGZ+g6GXzLW1SxiIjIrVO4KeT2n41l8OxQjl5IwMEBBretxrB21XF2coSUOPhjHGz9HDDAs6S5GF/wA1qMT0RECiyFm0LKMAz+t/kk7yzeT2q6ndI+bkx9qCF3Vg0wOxxaYS7GF3vabDccAB3eBg9/64oWERHJAQo3hVB0Yioj5+3m933nAWhXqxQf9G6Av6crJFyEpa9A+Dyzs19F6D4Nqra1sGIREZGco3BTyGw9fplhc8I4G5OMq5MjozrX4omWlXAw7Obt3X+8DcnR4OAILQZBm9Hg6nnT44qIiBQUCjeFhM1uMGPVYab/cRi7AZUDPJnRtxF1y/tCxDZY8hKc3WV2LlPPvL27fIi1RYuIiOQChZtC4GxMEsPm7GTr8csA9AoJZNx9wXimR8OCQRD2ndnRzRfueQ2aPAlO+tGLiEjhpE+4Am7F3nO8/PNuohPT8HR14p0H6vJAg7Kw/StY9TYkm4v10XAA3PsWeJW0tF4REZHcpnBTQCWn2ZiwZD/fbDoJQL3yvszo24hKSXvhs75wbrfZsUw96DoFgppZWK2IiEjeUbgpgI5ExTPkhzD2n40F/nqEQqsSuP75Muz8awiqmC/c87o5BOXoZGG1IiIieUvhpgAxDIOftp/mzYV7SUqzUcLTlUkP1qVt3G/w8T+GoBoNgHZvaQhKRESKJIWbAiI2OY1X54ezaNcZAFpWK8GMVmn4r+4N5/aYncrUNx+boCEoEREpwhRuCoCdEdEM+SGUiMtJODk68OrdATyR+DUOc2abHTQEJSIikkHhJh+z2w0+W3eMScsPkm43qODryncN91Ih9DlI+XsI6hHzLijPAEtrFRERyS8UbvKpqLhkXpq7i3WHLwIwpNpFXkj9DKct4WaHsg2gy2QIamphlSIiIvmPwk0+tPbQBYbP3cnF+FTKu8TyvwpLqHJ6ofliMT9o9zo0fkJDUCIiItegcJOPpKbbmbziIJ+uPYYTNkb6reM5+xycIs1bvjUEJSIicnMKN/nEqUuJDJkTxq6IaJo4HGCG7/eUTT5qvqghKBERkSxTuMkHFuyM5NX54RRLucT0Yj/Qg7WQzF9DUG9A48c1BCUiIpJFCjcWSkxN580Fe/llx0kecfqdke7z8DQSAQcIeRTavQmeJawuU0REpEBRuLHI3jMxDPkhjBIXd/Cb63+p7XgKDKBcI3MIKrCx1SWKiIgUSAo3ecwwDL7ddJJPF2/iJcfv6OW23nzBvbg5BBXymIagREREboPCTR66kpDKKz+FUf7w/1jmPA8fhyQMHHDQEJSIiEiOUbjJI5uPXeLr2bN5MfVTartEAGCUa4SDhqBERERylMJNLku32flq2WZKbn6XT53WgyOku/nh3P4t84qNhqBERERylMJNLjpzOY4VX79N39hv8XZKwo4DtoaP4tLhLfDwt7o8ERGRQknhJpdsW70Iv9WjeZwIcIArfvUo3nsajuU1BCUiIpKbFG5yWPLlSA7+7wWaXlkBQKyDN2lt3qBE64Hg6GhxdSIiIoWf5eHGZrOxceNGzp8/T7169ahZs2au7JPrbGlcWDUDjw0TaUASdsOBnaXuo+4jk/Hx0bOgRERE8oql4ebKlSt07NiRc+fOERwczPr163n22WeZNGlSju6TFy5cvoTT+il4OiQRTjWSO06kyZ3tLK1JRESkKLI03Lz66qvExsayd+9evL292bhxI61ataJjx460b98+x/bJCyVLluHXqi9x8UoMPR5/mVK+HpbVIiIiUpQ5GIZhWHFiwzDw9/dnzJgxjBw5MmN78+bNqVWrFv/9739zZJ9riY2NxdfXl5iYGHx8fG73W8mQZrPj5OCAo6NDjh1TRERETFn9/Lbsyk1ERATR0dHUrVs30/Z69eoRGhqaY/sApKSkkJKSktGOjY29jcqvz8VJE4ZFRESsZtmncUxMDADFixfPtN3f3z/jtZzYB2DChAn4+vpmfAUFBd1O6SIiIpKPWRZu3N3dAYiPj8+0PS4uLuO1nNgHYPTo0cTExGR8RURE3E7pIiIiko9ZNiwVFBSEi4sLJ0+ezLT95MmTVKlSJcf2AXBzc8PNze32ixYREZF8z7IrN25ubrRr1465c+dmbLtw4QKrVq2ia9euGds2b97Mb7/9lq19REREpOiy7G4pgN27d9OyZUu6detGixYt+Oqrr3BxcWHDhg24uroCMHDgQDZv3kx4eHiW97mZ3LpbSkRERHJPVj+/Lb29p379+uzcuZPKlSuza9cuHn/8cdasWZMppLRo0YLu3btnax8REREpuiy9cmMVXbkREREpeArElRsRERGRnKZwIyIiIoWKwo2IiIgUKgo3IiIiUqgo3IiIiEihYtkKxVb6+wax3HqApoiIiOS8vz+3b3ajd5EMN3FxcQB6gKaIiEgBFBcXh6+v73VfL5Lr3Njtds6cOYO3tzcODg63fJzY2FiCgoKIiIjQejm5TO913tF7nXf0Xucdvdd5Jzffa8MwiIuLo1y5cjg6Xn9mTZG8cuPo6EhgYGCOHc/Hx0d/WfKI3uu8o/c67+i9zjt6r/NObr3XN7pi8zdNKBYREZFCReFGREREChWFm9vg5ubGm2++iZubm9WlFHp6r/OO3uu8o/c67+i9zjv54b0ukhOKRUREpPDSlRsREREpVBRuREREpFBRuBEREZFCReHmFl26dIlt27Zx7tw5q0sp0CIjI9m1axfx8fHX7RMTE8P27duJiIi4rT5i2rFjBxs3brzmawkJCezYsYNjx45dd/+s9BGIiooiNDSUxMTEa76ekpJCaGgoBw8evO4xstKnqIuPj2f37t3s27eP5OTka/ZJT09n586d7Nu377rL9melT1ETExPDhg0bOHv27HX7XLhwgW3bthEVFZXrfbLFkGx74403DDc3N6NOnTqGm5ub8dRTTxk2m83qsgqUpUuXGg0aNDDKlStn1K9f3/Dw8DBGjRp1Vb/p06cb7u7uRu3atQ13d3ejZ8+eRnJycrb7iGnBggWGo6Oj4ebmdtVr33//veHt7W3UqFHD8Pb2Ntq2bWtER0dnu09RFx0dbfTq1cvw9PQ0mjRpYlSoUMH49ttvM/VZsmSJUaJECaNKlSpG8eLFjcaNGxtnzpzJdp+i7p133jE8PT2NevXqGdWqVTP8/f2N//3vf5n6rF+/3ihbtqxRoUIFo2TJkkadOnWMI0eOZLtPUXL8+HHj6aefNsqUKWM4OTkZM2bMuGa/ESNGZPosHDJkiGG323OlT3Yp3GTTr7/+ari4uBgbNmwwDMMwDhw4YPj6+hrTpk2zuLKCZdasWcauXbsy2ps2bTLc3NyMb775JmPb5s2bDQcHB2PhwoWGYRhGZGSkUa5cOWP06NHZ6iOmiIgIIzAw0BgyZMhV4ebw4cOGi4uL8dlnnxmGYRhXrlwxatasaTzxxBPZ6iOGce+99xohISHGhQsXDMMwjISEBOPrr7/OeP3ChQuGt7e3MW7cOMMwDCMpKclo3ry50blz52z1KepCQ0MNwJg/f37GtnfeecdwdnY2YmNjDcMwjPj4eKNMmTLG0KFDDcMwjPT0dKNjx45G06ZNM/bJSp+iZtmyZcann35qxMXFGb6+vtcMN999953h7u5u7NixwzAMw9i1a5fh4eFhfPnllzne51Yo3GRTjx49jE6dOmXaNnDgQKNBgwbWFFSING/e3Hj66acz2s8884zRsGHDTH1ee+01o3Tp0tnqI+Yv7LvuusuYOXOm8fHHH18Vbt544w2jbNmymf61NHPmTKNYsWJGYmJilvsUdWvWrDEAY+PGjdft89FHHxkeHh5GQkJCxrZ58+YZDg4OGVdmstKnqFu+fLkBGOfOncvY9ueffxqAcfLkScMwDGPu3LmGo6Ojcf78+Yw+q1evNgBjz549We5TlF0v3Nxzzz3Ggw8+mGnbww8/bLRs2TLH+9wKzbnJprCwMBo3bpxpW7NmzQgPDyctLc2iqgq+uLg4Dh48SLVq1TK2Xe+9Pn/+fMYYcFb6CIwbNw4vLy8GDRp0zdfDwsIICQnJ9CDZZs2akZyczIEDB7Lcp6j7448/KFGiBC1atODQoUOEh4dfNQ8kLCyM2rVr4+HhkbGtWbNmGIbBzp07s9ynqLvnnnvo2LEjTz75JEuXLmX+/Pm89NJLDBkyhAoVKgDm+xgUFESpUqUy9mvWrFnGa1ntI1e73u/ef75nOdXnVijcZNPly5cpUaJEpm0lSpTAZrMRGxtrUVUF33/+8x+KFSvGU089lbHteu/1369ltU9Rt2bNGj7//HO++uqr6/bRe50zzpw5Q8mSJenSpQtdu3alV69elC1blm+//Tajj97rnOHs7MzgwYPZvXs3I0eOZOTIkaSlpfHoo49m9LnW++ju7o67u/sN3+t/95HMDMMgOjr6mn9GExMTSUlJybE+t0rhJptcXFyu+pdYUlISAK6urlaUVOCNHDmS3377jYULF2b6Q56V91o/jxszDIP+/fvz+OOPc/jwYdavX8/Ro0cxDIP169dnXN3Se50zXFxcOHDgAG3btuXw4cMcPHiQcePGMXDgQI4cOZLRR+/17Vu/fj333Xcfn376KeHh4Rw5coQnnniCNm3acPr0aeDa76NhGKSmpt7wvf53H8nMwcEBZ2fn6/4ZdXFxybE+t0rhJpsqVqxIZGRkpm2RkZH4+fnh7e1tUVUF1+jRo/nss89Yvnw5TZo0yfTa9d5rR0dHAgMDs9ynKLPb7VSqVIm1a9cyatQoRo0axfz580lLS2PUqFFs2rQJuP77CGRc4s9Kn6KuUqVKADz33HMZ25555hnS09PZvHkzoPc6pyxevJhKlSrRpUuXjG3PP/88iYmJrFq1CjDfx7Nnz2a6tfvs2bPYbLZM7/XN+sjVKlSocM0/o4GBgTg6OuZon1uhcJNN7du3Z8mSJdhstoxtCxYsoH379hZWVTCNGTOGjz76iOXLl3PHHXdc9Xr79u1ZuXJlpnVCFixYQMuWLXF3d89yn6LMycmJ9evXZ/oaMWIErq6urF+/np49ewLm+7hly5ZMa0wsWLCA6tWrU7FixSz3Keo6duwIkOmX9ZkzZzAMg5IlSwLm+3j06FH27duX0WfBggX4+/sTEhKS5T5FXcmSJbl06VKmf/VHRkZe9V5fuXKFdevWZfRZsGABxYoVo3Xr1lnuI1dr3749v/32W0YoNAyDhQsXZvoszKk+t+S2piMXQWfOnDFKlSplPPjgg8bChQuNZ5991vDw8NCs+mx69913DQcHB2PSpEnGunXrMr727t2b0Sc2NtaoUqWK0aFDB2PBggXGK6+8Yjg7Oxtr1qzJVh/J7Fp3S6WlpRkhISFG8+bNjV9++cV49913DScnJ2PevHnZ6iOG8cgjjxgNGzY0fv75Z+OXX34xmjRpYjRt2tRITU3N6NOhQwejTp06xk8//WRMmzbNcHNzMz766KNMx8lKn6LszJkzRkBAgNGpUydj0aJFxk8//WQ0atTICA4ONpKSkjL69e3b16hUqZIxe/Zs47PPPst0i312+hQlcXFxGb+Tvby8jBdffNFYt26dsX///ow+x48fN4oXL27079/fWLhwofHYY48ZPj4+xuHDh3O8z63QU8FvwfHjx5k4cSIHDx6kQoUKvPjiizRo0MDqsgqU559/nt27d1+1vWXLlrz//vsZ7XPnzvHee++xZ88eSpcuzaBBg2jZsmWmfbLSR/7fggULmD59On/88Uem7dHR0bz//vts27aN4sWLM3DgwIwrEdnpU9Slp6fz8ccfs3TpUpydnWnevDnDhg3D09Mzo09iYiJTpkxh7dq1eHh40L9/f3r37p3pOFnpU9SdPn2aadOmsXfvXlxcXGjSpAlDhgzBz88vo09qaiozZsxgxYoVuLq60qtXLx5//PFMx8lKn6Lk4MGDmW7u+Fvbtm15++23M9qHDh3igw8+4OjRo1SuXJkRI0ZQu3btTPvkVJ/sUrgRERGRQkVzbkRERKRQUbgRERGRQkXhRkRERAoVhRsREREpVBRuREREpFBRuBEREZFCReFGREREChWFGxHJEQcPHmT58uVWl4HNZmPdunXMnTuXQ4cOWV2OiFjA2eoCRKTg2LNnDydOnKB06dI0aNAANze3jNcWLVrEd999Z+mKxYZhcO+993L+/Hnq16+Pt7c3NWrUsKweEbGGwo2I3FRUVBQ9evTg+PHjNG3alCtXrnDmzBlef/11nnzySQBq1apFp06dLK3z0KFDrF69mjNnzlC2bFlLaxER6yjciMhNvfzyyyQlJXHixImMp61fvHiRlStXZvSpXr06Li4uGe05c+ZcdRxHR0f69OmT0T5y5Ajh4eGULl2akJCQTFeCrmfHjh2cPHmSoKAgmjZtmrH90KFDGedcuXIlLi4u3H///RQrVizT/idPnmTTpk0AeHp6UqdOHapWrZqpT3h4OOfPn6dVq1Zs3LiRixcv0rt3b1atWkXJkiUpV64cW7ZswcPDgzZt2rBt2zaOHj0KQEBAAA0aNMh4MjXA7t27OXfuHB06dMh0np07d3LhwoXbfwKyiGSicCMiNxUeHk6LFi0ygg2YH+IPP/xwRvvfw1K//vprpmOEhoZy8uRJ+vTpQ3p6OgMHDmTJkiXccccdnD59moSEBBYsWHDdB+YlJibSo0cPdu/eTZMmTQgNDaVWrVosWrQIb29vjh49yrp16zJqcXR0pHPnzleFm4iIiIza4uLiWLduHY899hgzZszI6DNv3jz+97//4enpScmSJSlTpgy9e/dm3LhxpKenExkZSXBwMC1atKBNmzaEhYWxatUqwHyQ644dO/j4448ZMGAAYF756t69O5GRkQQEBGSc54knnqBDhw4KNyI57baeKS4iRcKgQYMMPz8/4+uvvzbOnz9/zT4ffPCB0aBBg2u+tmfPHsPLy8uYOHGiYRiGMX78eKNhw4ZGbGxsRp8XXnjBaNmy5XVreOutt4wKFSpknP/ChQtGpUqVjNGjR2f0WbdunQEYSUlJWf7eTp48afj6+hqrV6/O2Pbmm28agLFo0aJMfe+++27Dz8/PiIiIuOExFyxYYPj4+GR8f3a73ahSpYoxderUjD5hYWEGYBw4cCDLtYpI1uhuKRG5qffee49HHnmE4cOHU7p0aapUqcLgwYM5d+7cTfe9fPky9913H/fddx8jR44E4Ouvv6ZBgwYsX76cn376iblz51KiRAk2bdpEcnLyNY8zZ84cBg4cSKlSpQDzytFzzz13zeGvm0lOTmbDhg3MmzePjRs3Uq5cObZu3ZqpT+XKlenWrdtV+z7wwAMEBgZetf3ixYusWrWKuXPnEh8fT3x8PAcOHADAwcGBJ598kq+//jqj/5dffknLli2pWbNmtusXkRvTsJSI3JSXlxfTp09n6tSp7Nmzh7Vr1zJp0iQWL17Mnj178PLyuuZ+6enp9OnTB39/f7744ouM7SdOnCAgIIB58+Zl6t+7d28SExOvGkoCc65MlSpVMm2rWrUqp06dwjAMHBwcsvS9bNiwgZ49exIQEEDVqlXx8PDgypUrREVFZep3vQnJ19o+Y8YMRo8eTf369SlbtmzG3KN/HvOJJ57gzTffZPv27dSrV4/Zs2fzwQcfZKlmEckehRsRyTInJycaNmxIw4YNueOOO2jevDkbN268aqLs31566SX27t3L9u3bMwUWHx8f7r//fl5++eUsnzsgIIDLly9n2nb58mVKlCiR5WADMHLkSAYMGMDkyZMztjVp0gTDMDL1u94x/709MTGRF198kfnz59O9e3cA4uPj+fHHHzMds1y5cnTp0oWvvvqKu+++m9TU1EyTq0Uk52hYSkRu6vjx41dt+3v4yM/P75r7fP3113z66afMnz+f8uXLZ3qtU6dOfPXVV6SmpmbaHhkZed0aWrVqxS+//JJp27x582jVqlVWvoUM586dyzQUdPjwYXbv3p2tY/zTxYsXsdlsmY757ytSfxs4cCA//PADH3/8MX369LnuFS8RuT26ciMiN/XKK68QFRVFu3btqFChAidPnuTjjz+mU6dONG7c+Kr+Z8+e5T//+Q9dunThxIkTnDhxAvj/W8Hff/99WrduzR133MFjjz2Gs7Mz69evJykpiQULFlyzhrfffpumTZvSq1cvOnXqxO+//86WLVvYsmVLtr6X+++/n7Fjx5KSkkJaWhpTp07Fw8Mj2+/J34KCgggJCeGxxx5j4MCBHDlyhC+//BJHx6v/7di1a1c8PDxYs2YN77777i2fU0RuTOFGRG5q7ty5bNiwgRUrVvDnn38SEBDARx99RI8ePXBycgIyL+JnGAb3338/kPmWcCcnJ/r06UP58uXZtWsX3377LTt27MDb25tevXrRq1ev69ZQtWpVdu7cyeeff866deuoXr0677//PpUrV87oU7JkSR566KGMmq5l4sSJ1KxZky1btuDp6cn//vc/Nm/eTFBQUEafunXrXnPfe+65h1q1amXa5uDgwO+//87MmTNZs2YN5cuXZ+PGjYwbN+6qK1ZOTk5069aNNWvW0LJly+vWKCK3x8H490CziIjkCrvdTtWqVRk0aBAjRoywuhyRQktXbkRE8sCvv/7K4sWLSUxM5JlnnrG6HJFCTROKRUTywLJly3BycmLFihX4+PhYXY5IoaZhKRERESlUdOVGREREChWFGxERESlUFG5ERESkUFG4ERERkUJF4UZEREQKFYUbERERKVQUbkRERKRQUbgRERGRQkXhRkRERAqV/wN5/hje4AMilwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1427,12 +1112,801 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 5: Semantic Segmentations As Annotations\n", + "\n" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import numpy as np\n", + "\n", + "from tiatoolbox.annotation.storage import AnnotationStore, SQLiteStore\n", + "from tiatoolbox.type_hints import JSON\n", + "\n", + "\n", + "def process_contours(\n", + " contours: list[np.ndarray],\n", + " hierarchy: np.ndarray,\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " offset: np.ndarray | None = None,\n", + " properties: dict[str, JSON] | None = None,\n", + ") -> list[Annotation]:\n", + " \"\"\"Process contours and hierarchy to create annotations.\n", + "\n", + " Args:\n", + " contours (list[np.ndarray]):\n", + " A list of contours.\n", + " hierarchy (list[np.ndarray]):\n", + " A list of hierarchy.\n", + " scale_factor (tuple[float, float]):\n", + " The scale factor to use when loading the annotations.\n", + " offset (np.ndarray | None):\n", + " Optional offset to be added to the coordinates of the annotations.\n", + " properties (dict | None):\n", + " Optional properties to include with each annotation type.\n", + "\n", + " Returns:\n", + " list:\n", + " A list of annotations.\n", + "\n", + " \"\"\"\n", + " annotations_list: list[Annotation] = []\n", + " outer_contours: dict[int, np.ndarray] = {}\n", + " holes_dict: dict[int, list[np.ndarray]] = {}\n", + " base_props: dict[str, JSON] = {\"type\": \"mask\"}\n", + " if properties:\n", + " base_props.update(properties)\n", + "\n", + " for i, layer_ in enumerate(contours):\n", + " coords: np.ndarray = layer_.squeeze()\n", + " scaled_coords: np.ndarray = np.array([np.array(scale_factor) * coords])\n", + " if offset is not None:\n", + " scaled_coords += offset\n", + "\n", + " # save one points as a line, otherwise save the Polygon\n", + " if len(layer_) > 2: # noqa: PLR2004\n", + " if int(hierarchy[0][i][3]) == -1: # Outer contour\n", + " outer_contours[i] = scaled_coords[0]\n", + " else: # Hole\n", + " parent_idx: int = int(hierarchy[0][i][3])\n", + " if parent_idx not in holes_dict:\n", + " holes_dict[parent_idx] = []\n", + " holes_dict[parent_idx].append(scaled_coords[0])\n", + " # if two points, save as a line string\n", + " elif len(layer_) == 2: # noqa: PLR2004\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"linestring\",\n", + " \"coordinates\": scaled_coords[0],\n", + " },\n", + " )\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + " # if single point, save it is a point\n", + " else:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"point\",\n", + " \"coordinates\": scaled_coords,\n", + " },\n", + " )\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + "\n", + " for idx, outer in outer_contours.items():\n", + " holes: list[np.ndarray] = holes_dict.get(idx, [])\n", + " if len(holes) != 0:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": [outer, *holes],\n", + " },\n", + " )\n", + " else:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": [outer],\n", + " },\n", + " )\n", + " feature_geom = make_valid_poly(feature_geom)\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + "\n", + " return annotations_list" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def py_semantic_segmentations_as_annotations(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + " offset: np.ndarray | None = None,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> AnnotationStore | Path:\n", + " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", + " store = SQLiteStore()\n", + " annotations_list: list[Annotation] = []\n", + "\n", + " tqdm_loop = tqdm(\n", + " layer_list,\n", + " leave=False,\n", + " desc=\"Converting outputs to AnnotationStore.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for type_class in tqdm_loop:\n", + " class_id = int(type_class)\n", + " class_label = class_dict.get(class_id, class_id)\n", + " layer = da.where(preds == type_class, 1, 0).astype(\"uint8\").compute()\n", + " contours, hierarchy = cv2.findContours(\n", + " layer,\n", + " cv2.RETR_CCOMP,\n", + " cv2.CHAIN_APPROX_NONE,\n", + " )\n", + "\n", + " contours = cast(\"list[np.ndarray]\", contours)\n", + "\n", + " annotations_list_ = process_contours(\n", + " contours=contours,\n", + " hierarchy=hierarchy,\n", + " scale_factor=scale_factor,\n", + " offset=offset,\n", + " properties={\"type\": class_label, \"class\": class_id},\n", + " )\n", + " annotations_list.extend(annotations_list_)\n", + "\n", + " _ = store.append_many(\n", + " annotations_list, [str(i) for i in range(len(annotations_list))]\n", + " )\n", + "\n", + " # # if a save directory is provided, then dump store into a file\n", + " if save_path:\n", + " return save_annotations(\n", + " save_path=save_path,\n", + " store=store,\n", + " )\n", + "\n", + " return store" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import dask.array as da\n", + "import numpy as np\n", + "\n", + "\n", + "def rust_semantic_segmentations_as_annotations(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + " offset: np.ndarray | None = None,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> AnnotationStore | Path:\n", + " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", + " store = SQLiteStore()\n", + " annotations_list: list[Annotation] = rmisc.semantic_segmentations_as_annotations(\n", + " layer_list, preds, scale_factor, class_dict, offset, cv2, process_contours\n", + " )\n", + "\n", + " _ = store.append_many(\n", + " annotations_list, [str(i) for i in range(len(annotations_list))]\n", + " )\n", + "\n", + " # # if a save directory is provided, then dump store into a file\n", + " if save_path:\n", + " return save_annotations(\n", + " save_path=save_path,\n", + " store=store,\n", + " )\n", + "\n", + " return store" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fa5afc63dabb4453be69e16366d78e32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Converting outputs to AnnotationStore.: 0%| | 0/9 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 6: String To Tuple\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def py_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return tuple(substring.strip() for substring in in_str.split(\",\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return tuple(rmisc.string_to_tuple(in_str))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "i = 1\n", + "in_str = \"\"\n", + "max_patches = 100000\n", + "while i <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for j in range(int(len(in_str) / 2), i):\n", + " in_str += \" , \" + str(j)\n", + " for _j in range(10):\n", + " start_time = time.time()\n", + " python_object = py_string_to_tuple(in_str)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_object = rust_string_to_tuple(in_str)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", + " sizeofarray.append(len(in_str))\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Length of string\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w", + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Part 7: Contrast Enhancer\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from skimage import exposure\n", + "\n", + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " # check if image is not uint8\n", + " dimension_for_rust = 3\n", + "\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " if img.ndim == dimension_for_rust:\n", + " return rmisc.contrast_enhancer(img, low_p, high_p)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def py_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "id": "DZBiw_EepT5x" + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 1\n", + "maxarraysize = 10000\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(5):\n", + " rng = np.random.default_rng()\n", + " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", + " start_time = time.time()\n", + " python_result = py_contrast_enhancer(temp, 2, 96)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " if not np.allclose(python_result, rust_result, atol=1):\n", + " print(\"Incorrect result\")\n", + " sizeofarray.append(i)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " i *= 10" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Caution - The rust version differs from the python version by max 1\n", + "\n" + ] } ], "metadata": { From 847989c82abf67aef8d6374d1597c8f675b846c1 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:20:11 +0100 Subject: [PATCH 086/112] Edited to allow for multiple rust libraries --- Cargo.toml | 23 +++----- pyproject.toml | 26 ++++++--- tiatoolbox/rust-library/misc/Cargo.toml | 16 ++++++ tiatoolbox/rust-library/{ => misc/src}/lib.rs | 55 +++++++++++++++++++ tiatoolbox/rust-library/multitask/Cargo.toml | 11 ++++ tiatoolbox/rust-library/multitask/src/lib.rs | 13 +++++ 6 files changed, 122 insertions(+), 22 deletions(-) create mode 100644 tiatoolbox/rust-library/misc/Cargo.toml rename tiatoolbox/rust-library/{ => misc/src}/lib.rs (85%) create mode 100644 tiatoolbox/rust-library/multitask/Cargo.toml create mode 100644 tiatoolbox/rust-library/multitask/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index 2bafb17ab..a527f8914 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,18 +1,13 @@ -[package] -name = "tiatoolbox" +[workspace] +resolver = "3" +members = [ + "tiatoolbox/rust-library/misc", + "tiatoolbox/rust-library/multitask", +] + +[workspace.package] version = "0.1.0" edition = "2024" -autolib = false - -[lib] -path = "tiatoolbox/rust-library/lib.rs" -name = "rmisc" -crate-type = ["cdylib", "rlib"] -[dependencies] -ndarray = "0.17.2" -numpy = "0.29.0" -ordered-float = "5.3.0" +[workspace.dependencies] pyo3 = "0.29.2" -pythonize = "0.29.0" -serde_json = "1.0.151" diff --git a/pyproject.toml b/pyproject.toml index 4d6335c91..f25c1bd1c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -134,8 +134,11 @@ torchvision = [ omit = ['tests/*', 'tiatoolbox/__main__.py', '*/utils/env_detection.py', 'tiatoolbox/typing.py'] [build-system] - requires = ["maturin>=1.5,<2.0", "setuptools"] - build-backend = "maturin" + requires = [ + "setuptools", + "setuptools-rust", + ] + build-backend = "setuptools.build_meta" [tool.distutils.bdist_wheel] universal = true @@ -300,9 +303,16 @@ ignore_missing_imports = true # CI overrides this per job with --python-version for 3.12-3.14. python_version = "3.12" -[tool.maturin] -python-source = "." -include = ["tiatoolbox/**/*"] -module-name = "tiatoolbox.rmisc" -#Delete the following line when releasing, only to be used to run codecov -editable-profile = "dev" +[tool.setuptools.packages.find] +where = ["."] +include = ["tiatoolbox*"] + +[[tool.setuptools-rust.ext-modules]] +target = "tiatoolbox.rmisc" +path = "tiatoolbox/rust-library/misc/Cargo.toml" +binding = "PyO3" + +[[tool.setuptools-rust.ext-modules]] +target = "tiatoolbox.rmultitask" +path = "tiatoolbox/rust-library/multitask/Cargo.toml" +binding = "PyO3" diff --git a/tiatoolbox/rust-library/misc/Cargo.toml b/tiatoolbox/rust-library/misc/Cargo.toml new file mode 100644 index 000000000..49113959b --- /dev/null +++ b/tiatoolbox/rust-library/misc/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "rmisc" +version.workspace = true +edition.workspace = true + +[lib] +name = "rmisc" +crate-type = ["cdylib", "rlib"] + +[dependencies] +ndarray = "0.17.2" +numpy = "0.29.0" +ordered-float = "5.3.0" +pyo3 = { workspace = true, features = ["extension-module"] } +pythonize = "0.29.0" +serde_json = "1.0.151" diff --git a/tiatoolbox/rust-library/lib.rs b/tiatoolbox/rust-library/misc/src/lib.rs similarity index 85% rename from tiatoolbox/rust-library/lib.rs rename to tiatoolbox/rust-library/misc/src/lib.rs index 006d695db..fb42b27af 100644 --- a/tiatoolbox/rust-library/lib.rs +++ b/tiatoolbox/rust-library/misc/src/lib.rs @@ -104,6 +104,60 @@ fn semantic_segmentations_as_qupath_json( Ok(features.unbind()) } +#[pyfunction] +fn semantic_segmentations_as_annotations( + py: Python<'_>, + layer_list: &Bound<'_, PyList>, + preds: &Bound<'_, PyAny>, + scale_factor: (f64, f64), + class_dict: &Bound<'_, PyDict>, + offset: &Bound<'_, PyAny>, + cv2: &Bound<'_, PyAny>, + process_contours: &Bound<'_, PyAny>, +) -> PyResult> { + /*Helper function to save semantic segmentation as annotations.*/ + let annotations_list = PyList::empty(py); + let retr_ccomp = cv2.getattr("RETR_CCOMP")?; + let chain_approx_none = cv2.getattr("CHAIN_APPROX_NONE")?; + let find_contours = cv2.getattr("findContours")?; + for type_class in layer_list.iter() { + let class_id: f64 = type_class.extract()?; + let class_label = match class_dict.get_item(class_id)? { + Some(value) => value, + None => class_id.into_pyobject(class_dict.py())?.into_any(), + }; + let layer = preds + .rich_compare(class_id, CompareOp::Eq)? + .call_method1("astype", ("uint8",))? + .call_method0("compute")?; + let result = find_contours.call1((layer, retr_ccomp.clone(), chain_approx_none.clone()))?; + + let result = result.cast::()?; + + let contours = result.get_item(0)?; + + let hierarchy = result.get_item(1)?; + + let mut properties = PyDict::new(py); + properties.set_item("type", class_label)?; + properties.set_item("class", class_id)?; + + let kwargs = PyDict::new(py); + + kwargs.set_item("contours", contours)?; + kwargs.set_item("hierarchy", hierarchy)?; + kwargs.set_item("scale_factor", scale_factor)?; + kwargs.set_item("offset", offset)?; + kwargs.set_item("properties", properties)?; + + let processed_contours = process_contours.call((), Some(&kwargs))?; + for annotation in processed_contours.try_iter()? { + annotations_list.append(annotation?)?; + } + } + Ok(annotations_list.unbind()) +} + #[pyfunction] fn json_dump_python_object(save_path: String, obj: &Bound<'_, PyAny>) -> PyResult<()> { //Equilivent to json.dump(obj, save_path) @@ -351,5 +405,6 @@ fn rmisc(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(json_dump_python_object, m)?)?; m.add_function(wrap_pyfunction!(string_to_tuple, m)?)?; m.add_function(wrap_pyfunction!(semantic_segmentations_as_qupath_json, m)?)?; + m.add_function(wrap_pyfunction!(semantic_segmentations_as_annotations, m)?)?; Ok(()) } diff --git a/tiatoolbox/rust-library/multitask/Cargo.toml b/tiatoolbox/rust-library/multitask/Cargo.toml new file mode 100644 index 000000000..6114038a8 --- /dev/null +++ b/tiatoolbox/rust-library/multitask/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "rmultitask" +version.workspace = true +edition.workspace = true + +[lib] +name = "rmultitask" +crate-type = ["cdylib", "rlib"] + +[dependencies] +pyo3 = { workspace = true, features = ["extension-module"] } diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs new file mode 100644 index 000000000..bd6fec82d --- /dev/null +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -0,0 +1,13 @@ +use pyo3::prelude::*; + +#[pyfunction] +fn add(a: i32, b: i32) -> i32 { + a + b +} + +#[pymodule] +fn rmultitask(m: &Bound<'_, PyModule>) -> PyResult<()> { + m.add_function(wrap_pyfunction!(add, m)?)?; + + Ok(()) +} From a21bd78e97b2c438f267297da951332e5372fc0e Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:23:42 +0100 Subject: [PATCH 087/112] Edited to allow for multiple rust libraries --- tiatoolbox/rust-library/misc/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiatoolbox/rust-library/misc/src/lib.rs b/tiatoolbox/rust-library/misc/src/lib.rs index fb42b27af..aca4c88f0 100644 --- a/tiatoolbox/rust-library/misc/src/lib.rs +++ b/tiatoolbox/rust-library/misc/src/lib.rs @@ -138,7 +138,7 @@ fn semantic_segmentations_as_annotations( let hierarchy = result.get_item(1)?; - let mut properties = PyDict::new(py); + let properties = PyDict::new(py); properties.set_item("type", class_label)?; properties.set_item("class", class_id)?; From 22c59987f92b654700b86da73f2e0ced61a38c59 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:29:58 +0100 Subject: [PATCH 088/112] Improved benchmarking --- ...ring_misc_functions_in_rust_v_python.ipynb | 29 +++++++++++++++---- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index 99fd05b5e..bd74d28a4 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -133,8 +133,7 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w", - "jp-MarkdownHeadingCollapsed": true + "id": "b6S8vzFipT5w" }, "source": [ "# Part 2: Patch Predictions As Annotations\n", @@ -143,9 +142,7 @@ }, { "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "### Patch predictions as annotations written fully in python\n", "\n" @@ -1120,6 +1117,27 @@ "\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tiatoolbox.annotation.storage import AnnotationStore\n", + "\n", + "\n", + "def save_annotations(\n", + " save_path: Path,\n", + " store: AnnotationStore,\n", + ") -> Path:\n", + " \"\"\"Saves Annotation Store to disk.\"\"\"\n", + " # ensure proper db extension\n", + " save_path = save_path.parent.absolute() / (save_path.stem + \".db\")\n", + " store.commit()\n", + " store.dump(save_path)\n", + " return save_path" + ] + }, { "cell_type": "code", "execution_count": 18, @@ -1327,6 +1345,7 @@ " verbose: bool = True,\n", ") -> AnnotationStore | Path:\n", " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", + " _ = verbose\n", " store = SQLiteStore()\n", " annotations_list: list[Annotation] = rmisc.semantic_segmentations_as_annotations(\n", " layer_list, preds, scale_factor, class_dict, offset, cv2, process_contours\n", From 775fac81c1251794f203dd8745696ba89b6a9fff Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:39:49 +0100 Subject: [PATCH 089/112] Corrected types --- tiatoolbox/rmisc.pyi | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tiatoolbox/rmisc.pyi b/tiatoolbox/rmisc.pyi index e6dde435b..147daa3c3 100644 --- a/tiatoolbox/rmisc.pyi +++ b/tiatoolbox/rmisc.pyi @@ -2,8 +2,9 @@ from collections.abc import Callable from types import ModuleType from typing import Any +import dask.array as da import numpy as np -from numpy.typing import NDArray, npt +from numpy.typing import NDArray from shapely.geometry import Polygon from tiatoolbox.annotation.storage import Annotation @@ -11,7 +12,7 @@ from tiatoolbox.annotation.storage import Annotation def string_to_tuple(in_str: str) -> list[str]: ... def semantic_segmentations_as_qupath_json( layer_list: list[Any], - preds: npt.NDArray[np.generic], + preds: da.Array, scale_factor: tuple[float, float], class_dict: dict[Any, Any], class_colours: dict[Any, Any], From cd895cfe15a016a96997e623e62cb1dd0f9e7ed7 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 11:49:40 +0100 Subject: [PATCH 090/112] Edited so that it can locate rust tests --- tiatoolbox/rust-library/misc/Cargo.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tiatoolbox/rust-library/misc/Cargo.toml b/tiatoolbox/rust-library/misc/Cargo.toml index 49113959b..f6eeaa2c7 100644 --- a/tiatoolbox/rust-library/misc/Cargo.toml +++ b/tiatoolbox/rust-library/misc/Cargo.toml @@ -14,3 +14,7 @@ ordered-float = "5.3.0" pyo3 = { workspace = true, features = ["extension-module"] } pythonize = "0.29.0" serde_json = "1.0.151" + +[[test]] +name = "misc_tests" +path = "../../../tests/test_misc.rs" From 715d08e223765245e7a003190668f50dd61a35c9 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 12:17:30 +0100 Subject: [PATCH 091/112] Added new test --- tests/test_rust.py | 83 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/tests/test_rust.py b/tests/test_rust.py index b9139cf34..6ea110f9d 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -3,12 +3,14 @@ import json import tempfile from pathlib import Path +from typing import cast import cv2 import dask.array as da import numpy as np from tiatoolbox import rmisc, utils +from tiatoolbox.type_hints import JSON def test_contrast_enhancer() -> None: @@ -413,3 +415,84 @@ def test_semantic_segmentations_as_qupath_json() -> None: ] assert result == expected + + +def dummy_process_contours( + contours: list[np.ndarray], + hierarchy: np.ndarray, + scale_factor: tuple[float, float] = (1, 1), + offset: np.ndarray | None = None, + properties: dict[str, JSON] | None = None, +) -> list[DummyAnnotation]: + """Used for test_semantic_segmentations_as_annotations().""" + annotations = [] + _ = offset + _ = scale_factor + _ = hierarchy + + for contour in contours: + points = contour.reshape(-1, 2) + annotations.append( + DummyAnnotation( + polygon=( + points[:, 0].min(), + points[:, 1].min(), + points[:, 0].max(), + points[:, 1].max(), + ), + properties=cast("dict[str, str | float]", properties.copy()), + ) + ) + + return annotations + + +def test_semantic_segmentations_as_annotations() -> None: + """Test semantic_segmentations_as_annotations. + + Ensure the Rust implementation returns the expected result. + """ + class_dict = { + 0.0: "Tumour", + 1.0: "Normal", + } + + preds = da.from_array( + np.array( + [ + [0, 0, 0, 1, 1], + [0, 0, 0, 1, 1], + [0, 0, 0, 1, 1], + [1, 1, 1, 1, 1], + ] + ) + ) + + scale_factor = (0.5, 0.5) + layer_list = [0.0, 1.0] + + result = rmisc.semantic_segmentations_as_annotations( + layer_list, + preds, + scale_factor, + class_dict, + None, + cv2, + dummy_process_contours, + ) + + assert len(result) == 2 + + assert isinstance(result[0], DummyAnnotation) + assert result[0].polygon == (0.0, 0.0, 2.0, 2.0) + assert result[0].properties == { + "type": "Tumour", + "class": 0.0, + } + + assert isinstance(result[1], DummyAnnotation) + assert result[1].polygon == (0.0, 0.0, 4.0, 3.0) + assert result[1].properties == { + "type": "Normal", + "class": 1.0, + } From b48cd68e0a195b0ef0dfcffbefd366db812a66fe Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 12:28:46 +0100 Subject: [PATCH 092/112] Added new tests for save_qupath_json --- tests/test_utils.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tests/test_utils.py b/tests/test_utils.py index 4fd3a25bc..059240b94 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -8,6 +8,7 @@ import re import shutil import sys +import tempfile from pathlib import Path from typing import TYPE_CHECKING, NoReturn from unittest.mock import patch @@ -2816,3 +2817,27 @@ def test_patch_predictions_as_annotations() -> None: ) assert len(annotations) == 0 + + +def test_save_qupath_json() -> None: + """Tests whether save_qupath_json works.""" + obj = { + 2: "no_years", + "name": "Alice", + "age": 30, + "active": True, + "numbers": [1, 2, 3], + } + + with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tmp: + path = Path(tmp.name) + + try: + utils.misc.save_qupath_json(path, obj) + with path.open() as f: + result = json.load(f) + obj["2"] = obj.pop(2) + assert result == obj + + finally: + path.unlink() From 8a6f9c73ad9819dd284b9de9be19210b33380acc Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 12:36:47 +0100 Subject: [PATCH 093/112] Added rust to readthedocs --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index 066757443..c13e44792 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -10,6 +10,7 @@ build: os: ubuntu-24.04 tools: python: "3.12" + rust: "latest" apt_packages: - libopenjp2-7-dev - libopenjp2-tools From c60584b00b17fadedd1c881dd2b8668eb963343a Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 12:46:41 +0100 Subject: [PATCH 094/112] Edited to have a new test for multitask rust --- tests/test_rust.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index 6ea110f9d..3361872d3 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -9,10 +9,15 @@ import dask.array as da import numpy as np -from tiatoolbox import rmisc, utils +from tiatoolbox import rmisc, rmultitask, utils from tiatoolbox.type_hints import JSON +def test_add() -> None: + """Temp test to test function add.""" + assert rmultitask.add(5, 4) == 9 + + def test_contrast_enhancer() -> None: """Test contrast enhancement functionality.""" input_array = np.array( From 652b152e41a798c311d839dc79a8372efd0dab19 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 12:55:21 +0100 Subject: [PATCH 095/112] Edited to have more tests for patch_predictions_as_annotations --- tests/test_rust.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/tests/test_rust.py b/tests/test_rust.py index 3361872d3..650edd659 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -8,6 +8,7 @@ import cv2 import dask.array as da import numpy as np +import pytest from tiatoolbox import rmisc, rmultitask, utils from tiatoolbox.type_hints import JSON @@ -333,6 +334,32 @@ def test_patch_predictions_as_annotations() -> None: assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) assert annotations[1].properties == {} + with pytest.raises(TypeError): + annotations = rmisc.patch_predictions_as_annotations( + None, + DummyPolygon, + [], + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) + with pytest.raises(TypeError): + annotations = rmisc.patch_predictions_as_annotations( + DummyAnnotation, + None, + [], + keys_contains_labels, + keys_contains_probabilities, + class_dict, + class_probs, + patch_coords, + [0.0, 1.0], # classes_predicted + [1.0, 0.0], # labels + ) def test_json_dump_python_object() -> None: From 3366d60a5ed0aab07adbef64c656f91e77ef271b Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 13:03:22 +0100 Subject: [PATCH 096/112] Improved tests --- tests/test_rust.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/test_rust.py b/tests/test_rust.py index 650edd659..3e63d86e4 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -334,9 +334,9 @@ def test_patch_predictions_as_annotations() -> None: assert annotations[1].polygon == (50.0, 60.0, 70.0, 80.0) assert annotations[1].properties == {} - with pytest.raises(TypeError): + with pytest.raises((TypeError, AttributeError)): annotations = rmisc.patch_predictions_as_annotations( - None, + DummyPolygon, DummyPolygon, [], keys_contains_labels, @@ -347,10 +347,10 @@ def test_patch_predictions_as_annotations() -> None: [0.0, 1.0], # classes_predicted [1.0, 0.0], # labels ) - with pytest.raises(TypeError): + with pytest.raises((TypeError, AttributeError)): annotations = rmisc.patch_predictions_as_annotations( DummyAnnotation, - None, + DummyAnnotation, [], keys_contains_labels, keys_contains_probabilities, From 91f268f5fb3edad0c1c9ba5c698d0c6c755f0fd2 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 13:23:09 +0100 Subject: [PATCH 097/112] Improved tests to cover all possibilities --- tests/test_rust.py | 64 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/tests/test_rust.py b/tests/test_rust.py index 3e63d86e4..a75dc2701 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -391,6 +391,30 @@ def poly_geo_func(_coords: list) -> list: return [] +class DummyCV2: + """Dummy cv2 module returning a contour with fewer than 3 points.""" + + RETR_CCOMP = 0 + CHAIN_APPROX_NONE = 1 + + @staticmethod + @typing.override + def findContours( + _layer: np.ndarray, + _mode: int, + _method: int, + ) -> tuple[list[np.ndarray], None]: + """Dummy cv2 findContours eturning a contour with fewer than 3 points.""" + contour = np.array( + [ + [[0, 0]], + [[1, 1]], + ], + dtype=np.int32, + ) + return [contour], None + + def test_semantic_segmentations_as_qupath_json() -> None: """Test semantic_segmentations_as_qupath_json. @@ -448,6 +472,18 @@ def test_semantic_segmentations_as_qupath_json() -> None: assert result == expected + result = rmisc.semantic_segmentations_as_qupath_json( + layer_list, + preds, + scale_factor, + class_dict, + class_colours, + DummyCV2, + poly_geo_func, + ) + + assert result == [] + def dummy_process_contours( contours: list[np.ndarray], @@ -528,3 +564,31 @@ def test_semantic_segmentations_as_annotations() -> None: "type": "Normal", "class": 1.0, } + + class_dict = {0.0: "Tumour"} + + result = rmisc.semantic_segmentations_as_annotations( + layer_list, + preds, + scale_factor, + class_dict, + None, + cv2, + dummy_process_contours, + ) + + assert len(result) == 2 + + assert isinstance(result[0], DummyAnnotation) + assert result[0].polygon == (0.0, 0.0, 2.0, 2.0) + assert result[0].properties == { + "type": "Tumour", + "class": 0.0, + } + + assert isinstance(result[1], DummyAnnotation) + assert result[1].polygon == (0.0, 0.0, 4.0, 3.0) + assert result[1].properties == { + "type": 1.0, + "class": 1.0, + } From 74133da397336280655a0f8c033a7ae4b95bc3d2 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 13:26:14 +0100 Subject: [PATCH 098/112] Correct to ignore error message --- tests/test_rust.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_rust.py b/tests/test_rust.py index a75dc2701..200fde5e2 100644 --- a/tests/test_rust.py +++ b/tests/test_rust.py @@ -2,6 +2,7 @@ import json import tempfile +import typing from pathlib import Path from typing import cast From 01e779456b1aaaea441f2188ea8a6b1dcfdd0c02 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 14:54:16 +0100 Subject: [PATCH 099/112] Updated formatting --- .github/workflows/rust.yml | 14 -------------- pyproject.toml | 5 ++++- 2 files changed, 4 insertions(+), 15 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 4fe1b752b..6740884a6 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -36,25 +36,11 @@ jobs: - name: Run Rust coverage shell: bash run: | - # Configure Rust builds for LLVM coverage source <(cargo llvm-cov show-env --sh) - - # Important: clean BEFORE rebuilding the Python extension cargo llvm-cov clean --workspace - - # Rebuild the PyO3/Maturin extension WITH coverage instrumentation python -m pip install --force-reinstall --no-deps -e . - - # Verify which native extension Python actually loads - python -c "import tiatoolbox.rmisc as r; print(r.__file__)" - - # Run Python tests that exercise the Rust extension python -m pytest tests/test_rust.py -v - - # Run normal native Rust tests too cargo test --all-features - - # Generate one Rust coverage report cargo llvm-cov report --lcov --output-path lcov.info - name: Upload Rust coverage to Codecov uses: codecov/codecov-action@v4 diff --git a/pyproject.toml b/pyproject.toml index f25c1bd1c..5c9f29278 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,7 +36,6 @@ dependencies = [ "opencv-python>=4.6.0", "openslide-bin>=4.0.0.2", "openslide-python>=1.4.0", - "maturin>=1.14.1", "pandas>=2.0.0", "pillow>=9.3.0", "pydicom>=2.3.1", @@ -311,8 +310,12 @@ include = ["tiatoolbox*"] target = "tiatoolbox.rmisc" path = "tiatoolbox/rust-library/misc/Cargo.toml" binding = "PyO3" +#Uncomment below for release +#debug = false [[tool.setuptools-rust.ext-modules]] target = "tiatoolbox.rmultitask" path = "tiatoolbox/rust-library/multitask/Cargo.toml" binding = "PyO3" +#Uncomment below for release +#debug = false From 87cc4df66964251d2edc313385c2d3197827b52c Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 17:05:45 +0100 Subject: [PATCH 100/112] Edited to have build single qupath feature to use rust --- .../models/engine/multi_task_segmentor.py | 52 ++------------ tiatoolbox/rust-library/multitask/src/lib.rs | 69 ++++++++++++++++++- 2 files changed, 72 insertions(+), 49 deletions(-) diff --git a/tiatoolbox/models/engine/multi_task_segmentor.py b/tiatoolbox/models/engine/multi_task_segmentor.py index fec5aebe9..3316b7153 100644 --- a/tiatoolbox/models/engine/multi_task_segmentor.py +++ b/tiatoolbox/models/engine/multi_task_segmentor.py @@ -136,7 +136,7 @@ from shapely.strtree import STRtree from tqdm.auto import tqdm -from tiatoolbox import logger +from tiatoolbox import logger, rmultitask from tiatoolbox.annotation import SQLiteStore from tiatoolbox.annotation.storage import Annotation from tiatoolbox.tools.patchextraction import PatchExtractor @@ -3572,53 +3572,9 @@ def _build_single_qupath_feature( ) geo_map = mapping(geom) - props = {} - class_value = None - class_name = None - - for key, arr in self._processed_predictions.items(): - value = arr[i].tolist() if hasattr(arr[i], "tolist") else arr[i] - - if key == "type": - # Handle None class name - if value is None: - # Assign default class 0 - class_value = 0 - class_name = class_dict.get(0, 0) - props["type"] = class_name - continue - - # Safe class lookup - if class_dict is not None and value in class_dict: - class_name = class_dict[value] - else: - # Already a name or no mapping available - class_name = value - - props["type"] = class_name - class_value = value - else: - if value is None: - continue - props[key] = np.array(value).tolist() - - # Classification block - if class_name is not None and class_value in class_colors: - color = class_colors[class_value] - props["classification"] = { - "name": class_name, - "color": color, - } - props["class_value"] = class_value - - return { - "type": "Feature", - "id": f"object_{i}", - "geometry": geo_map, - "properties": props, - "objectType": "annotation", - "name": class_name if class_name is not None else "object", - } + return rmultitask.build_single_qupath_feature( + np, geo_map, self._processed_predictions, i, class_dict, class_colors + ) def compute_annotations( self: DaskDelayedJSONStore, diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index bd6fec82d..e017d2f54 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,13 +1,80 @@ use pyo3::prelude::*; +use pyo3::types::PyDict; #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b } +#[pyfunction] +fn build_single_qupath_feature(py: Python<'_>, + np: &Bound<'_, PyAny>, + geo_map: &Bound<'_, PyAny>, + processed_predictions: &Bound<'_, PyDict>, + i: i32, + class_dict: &Bound<'_, PyDict>, + class_colours: &Bound<'_, PyDict> +) -> PyResult> { + let props = PyDict::new(py); + let mut class_value: Option = None; + let mut class_name: Option = None; + for (key, arr) in processed_predictions.iter() { + let item = arr.get_item(i)?; + let value = if item.hasattr("tolist")? { + item.call_method0("tolist")? + } else { + item + }; + if key.eq("type")? { + if value.is_none() { + class_value = Some(0); + class_name = match class_dict.get_item(0)? { + Some(value) => Some(value.to_string()), + None => Some("0".to_string()), + }; + props.set_item("type", &class_name)?; + } else { + if !class_dict.is_none() && class_dict.contains(&value)? { + if let Some(item) = class_dict.get_item(&value)? { + class_name = Some(item.extract::()?); + } + } else { + class_name = Some(value.to_string()); + } + props.set_item("type", &class_name)?; + class_value = value.extract::>()?; + } + } else if !value.is_none() { + props.set_item(key, + np.call_method1("array", (value,))? + .call_method0("tolist")?)?; + } + } + if !class_name.is_none() && class_colours.contains(&class_value)? { + let color = class_colours.get_item(class_value)?; + let classification_dict = PyDict::new(py); + classification_dict.set_item("name", &class_name)?; + classification_dict.set_item("color", color)?; + props.set_item("classification", classification_dict)?; + props.set_item("class_value", class_value)?; + } + let single_qupath_feature = PyDict::new(py); + single_qupath_feature.set_item("type", "Feature")?; + single_qupath_feature.set_item("id", format!("object_{}", i))?; + single_qupath_feature.set_item("geometry", geo_map)?; + single_qupath_feature.set_item("properties", props)?; + single_qupath_feature.set_item("objectType", "annotation")?; + if class_name.is_none() { + single_qupath_feature.set_item("name", "object")?; + } else { + single_qupath_feature.set_item("name", class_name)?; + } + Ok(single_qupath_feature.unbind()) +} + #[pymodule] fn rmultitask(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; - + m.add_function(wrap_pyfunction!(build_single_qupath_feature, m)?)?; Ok(()) } From 5841098b296ddb05935ccc2d9d9fafbad1f4c436 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Thu, 27 Aug 2026 17:09:52 +0100 Subject: [PATCH 101/112] Updated build_single_qupath_feature to have improved formatting --- tiatoolbox/rust-library/multitask/src/lib.rs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index e017d2f54..c781f8639 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -7,13 +7,14 @@ fn add(a: i32, b: i32) -> i32 { } #[pyfunction] -fn build_single_qupath_feature(py: Python<'_>, +fn build_single_qupath_feature( + py: Python<'_>, np: &Bound<'_, PyAny>, geo_map: &Bound<'_, PyAny>, processed_predictions: &Bound<'_, PyDict>, i: i32, class_dict: &Bound<'_, PyDict>, - class_colours: &Bound<'_, PyDict> + class_colours: &Bound<'_, PyDict>, ) -> PyResult> { let props = PyDict::new(py); let mut class_value: Option = None; @@ -45,9 +46,10 @@ fn build_single_qupath_feature(py: Python<'_>, class_value = value.extract::>()?; } } else if !value.is_none() { - props.set_item(key, - np.call_method1("array", (value,))? - .call_method0("tolist")?)?; + props.set_item( + key, + np.call_method1("array", (value,))?.call_method0("tolist")?, + )?; } } if !class_name.is_none() && class_colours.contains(&class_value)? { From 7c4fb06924a3c8b7a5385e0cdf42791e1f61ccc9 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 18:12:48 +0100 Subject: [PATCH 102/112] Updated types in build single qupath feature --- tiatoolbox/rust-library/multitask/src/lib.rs | 127 ++++++++++++++++--- 1 file changed, 112 insertions(+), 15 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index c781f8639..00a8a082f 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,11 +1,19 @@ use pyo3::prelude::*; use pyo3::types::PyDict; +use pyo3::ffi::PyObject; + +#[derive(Clone)] +enum StringOrFloat { + String(String), + Float(f64), +} #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b } + #[pyfunction] fn build_single_qupath_feature( py: Python<'_>, @@ -17,8 +25,8 @@ fn build_single_qupath_feature( class_colours: &Bound<'_, PyDict>, ) -> PyResult> { let props = PyDict::new(py); - let mut class_value: Option = None; - let mut class_name: Option = None; + let mut class_value: Option = None; + let mut class_name: Option = None; for (key, arr) in processed_predictions.iter() { let item = arr.get_item(i)?; let value = if item.hasattr("tolist")? { @@ -28,22 +36,68 @@ fn build_single_qupath_feature( }; if key.eq("type")? { if value.is_none() { - class_value = Some(0); + class_value = Some(StringOrFloat::Float(0.0)); class_name = match class_dict.get_item(0)? { - Some(value) => Some(value.to_string()), - None => Some("0".to_string()), + Some(value) => { + if let Ok(s) = value.extract::() { + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } + }, + None => Some(StringOrFloat::Float(0.0)), }; - props.set_item("type", &class_name)?; + match class_name.as_ref() { + Some(StringOrFloat::String(s)) => { + props.set_item("type", s)?; + } + Some(StringOrFloat::Float(i)) => { + props.set_item("type", i)?; + } + None => { + props.set_item("type", py.None())?; + } + } } else { if !class_dict.is_none() && class_dict.contains(&value)? { if let Some(item) = class_dict.get_item(&value)? { - class_name = Some(item.extract::()?); + class_name = if let Ok(s) = item.extract::() { + Some(StringOrFloat::String(s)) + } else if let Ok(f) = item.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } } } else { - class_name = Some(value.to_string()); + class_name = if let Ok(s) = value.extract::() { + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } + } + match class_name.as_ref() { + Some(StringOrFloat::String(s)) => { + props.set_item("type", s)?; + } + Some(StringOrFloat::Float(i)) => { + props.set_item("type", i)?; + } + None => { + props.set_item("type", py.None())?; + } } - props.set_item("type", &class_name)?; - class_value = value.extract::>()?; + class_value = if let Ok(s) = value.extract::() { + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + }; } } else if !value.is_none() { props.set_item( @@ -52,13 +106,46 @@ fn build_single_qupath_feature( )?; } } - if !class_name.is_none() && class_colours.contains(&class_value)? { - let color = class_colours.get_item(class_value)?; + let class_colours_contains_class_value = match class_value { + Some(StringOrFloat::String(ref s)) => class_colours.contains(&s)?, + Some(StringOrFloat::Float(i)) => class_colours.contains(&i)?, + None => false, + }; + let class_name_is_none = match class_name { + Some(ref _s) => false, + None => true, + }; + if !class_name_is_none && class_colours_contains_class_value { + let color = match class_value { + Some(StringOrFloat::String(ref s)) => class_colours.get_item(&s)?, + Some(StringOrFloat::Float(i)) => class_colours.get_item(&i)?, + None => None, + }; let classification_dict = PyDict::new(py); - classification_dict.set_item("name", &class_name)?; + match class_name.as_ref() { + Some(StringOrFloat::String(s)) => { + classification_dict.set_item("name", s)?; + } + Some(StringOrFloat::Float(i)) => { + classification_dict.set_item("name", i)?; + } + None => { + classification_dict.set_item("name", py.None())?; + } + } classification_dict.set_item("color", color)?; props.set_item("classification", classification_dict)?; - props.set_item("class_value", class_value)?; + match class_value.as_ref() { + Some(StringOrFloat::String(s)) => { + props.set_item("class_value", s)?; + } + Some(StringOrFloat::Float(i)) => { + props.set_item("class_value", i)?; + } + None => { + props.set_item("class_value", py.None())?; + } + } } let single_qupath_feature = PyDict::new(py); single_qupath_feature.set_item("type", "Feature")?; @@ -69,7 +156,17 @@ fn build_single_qupath_feature( if class_name.is_none() { single_qupath_feature.set_item("name", "object")?; } else { - single_qupath_feature.set_item("name", class_name)?; + match class_name.as_ref() { + Some(StringOrFloat::String(s)) => { + single_qupath_feature.set_item("name", s)?; + } + Some(StringOrFloat::Float(i)) => { + single_qupath_feature.set_item("name", i)?; + } + None => { + single_qupath_feature.set_item("name", py.None())?; + } + } } Ok(single_qupath_feature.unbind()) } From 6b6578d13ea559a538dc4b5c2df8acc9cae112a5 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Thu, 27 Aug 2026 18:16:31 +0100 Subject: [PATCH 103/112] Updated formatting of multitask rust library --- tiatoolbox/rust-library/multitask/src/lib.rs | 53 ++++++++++---------- 1 file changed, 26 insertions(+), 27 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index 00a8a082f..862afdbf5 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,6 +1,6 @@ +use pyo3::ffi::PyObject; use pyo3::prelude::*; use pyo3::types::PyDict; -use pyo3::ffi::PyObject; #[derive(Clone)] enum StringOrFloat { @@ -13,7 +13,6 @@ fn add(a: i32, b: i32) -> i32 { a + b } - #[pyfunction] fn build_single_qupath_feature( py: Python<'_>, @@ -40,13 +39,13 @@ fn build_single_qupath_feature( class_name = match class_dict.get_item(0)? { Some(value) => { if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } - }, + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } + } None => Some(StringOrFloat::Float(0.0)), }; match class_name.as_ref() { @@ -64,21 +63,21 @@ fn build_single_qupath_feature( if !class_dict.is_none() && class_dict.contains(&value)? { if let Some(item) = class_dict.get_item(&value)? { class_name = if let Ok(s) = item.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = item.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } + Some(StringOrFloat::String(s)) + } else if let Ok(f) = item.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } } } else { class_name = if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + } } match class_name.as_ref() { Some(StringOrFloat::String(s)) => { @@ -92,12 +91,12 @@ fn build_single_qupath_feature( } } class_value = if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - }; + Some(StringOrFloat::String(s)) + } else if let Ok(f) = value.extract::() { + Some(StringOrFloat::Float(f)) + } else { + None + }; } } else if !value.is_none() { props.set_item( From 3a20764c583c221130c193f8e41e91959b65d174 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Thu, 27 Aug 2026 18:20:45 +0100 Subject: [PATCH 104/112] Updated formatting --- tiatoolbox/rust-library/multitask/src/lib.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index 862afdbf5..792e43374 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,4 +1,3 @@ -use pyo3::ffi::PyObject; use pyo3::prelude::*; use pyo3::types::PyDict; @@ -106,8 +105,8 @@ fn build_single_qupath_feature( } } let class_colours_contains_class_value = match class_value { - Some(StringOrFloat::String(ref s)) => class_colours.contains(&s)?, - Some(StringOrFloat::Float(i)) => class_colours.contains(&i)?, + Some(StringOrFloat::String(ref s)) => class_colours.contains(s)?, + Some(StringOrFloat::Float(i)) => class_colours.contains(i)?, None => false, }; let class_name_is_none = match class_name { @@ -116,8 +115,8 @@ fn build_single_qupath_feature( }; if !class_name_is_none && class_colours_contains_class_value { let color = match class_value { - Some(StringOrFloat::String(ref s)) => class_colours.get_item(&s)?, - Some(StringOrFloat::Float(i)) => class_colours.get_item(&i)?, + Some(StringOrFloat::String(ref s)) => class_colours.get_item(s)?, + Some(StringOrFloat::Float(i)) => class_colours.get_item(i)?, None => None, }; let classification_dict = PyDict::new(py); From fe54f6b8693be40900c354aa2b0c8a71fca310c3 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Fri, 28 Aug 2026 11:58:00 +0100 Subject: [PATCH 105/112] Improved benchmarking to include more tests --- ...ring_misc_functions_in_rust_v_python.ipynb | 51462 +++++++++++++++- 1 file changed, 50564 insertions(+), 898 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index bd74d28a4..daf4a4c10 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -55,8 +55,7 @@ { "cell_type": "markdown", "metadata": { - "id": "b6S8vzFipT5w", - "jp-MarkdownHeadingCollapsed": true + "id": "b6S8vzFipT5w" }, "source": [ "# Part 1: Json.dump\n", @@ -66,7 +65,14 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:46:50.190055Z", + "iopub.status.busy": "2026-08-28T10:46:50.189985Z", + "iopub.status.idle": "2026-08-28T10:46:52.298252Z", + "shell.execute_reply": "2026-08-28T10:46:52.297778Z" + } + }, "outputs": [], "source": [ "import json\n", @@ -81,7 +87,7 @@ "sizeofarray = []\n", "timings = []\n", "i = 10\n", - "maxarraysize = 10000\n", + "maxarraysize = 1000\n", "with Path.open(\"example.txt\", \"w\") as handle: # skipcq: PTC-W6004\n", " json.dump({\"a\": 1}, handle)\n", "while i <= maxarraysize:\n", @@ -101,17 +107,24 @@ " rust_times = np.append(rust_times, rust_end_time)\n", " sizeofarray.append(len(example_dict))\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" + " i += 10" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:46:52.299448Z", + "iopub.status.busy": "2026-08-28T10:46:52.299327Z", + "iopub.status.idle": "2026-08-28T10:46:52.778899Z", + "shell.execute_reply": "2026-08-28T10:46:52.778471Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -151,7 +164,14 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:46:52.795635Z", + "iopub.status.busy": "2026-08-28T10:46:52.795515Z", + "iopub.status.idle": "2026-08-28T10:46:53.358334Z", + "shell.execute_reply": "2026-08-28T10:46:53.357796Z" + } + }, "outputs": [], "source": [ "import numpy as np\n", @@ -199,9 +219,7 @@ }, { "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "### Patch Predictions As Annotations with some code written in rust\n", "\n" @@ -210,7 +228,14 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:46:53.359443Z", + "iopub.status.busy": "2026-08-28T10:46:53.359283Z", + "iopub.status.idle": "2026-08-28T10:46:53.361675Z", + "shell.execute_reply": "2026-08-28T10:46:53.361280Z" + } + }, "outputs": [], "source": [ "def rust_patch_predictions_as_annotations(\n", @@ -243,9 +268,7 @@ }, { "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "## Comparison of speed it takes to run code in rust vs python\n", "\n" @@ -254,7 +277,14 @@ { "cell_type": "code", "execution_count": 5, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:46:53.362393Z", + "iopub.status.busy": "2026-08-28T10:46:53.362315Z", + "iopub.status.idle": "2026-08-28T10:47:06.355888Z", + "shell.execute_reply": "2026-08-28T10:47:06.355277Z" + } + }, "outputs": [], "source": [ "import time\n", @@ -262,8 +292,8 @@ "sizeofarray = []\n", "timings = []\n", "timings = []\n", - "num_patches = 1\n", - "num_classes = 1\n", + "num_patches = 10\n", + "num_classes = 10\n", "max_patches = 1000\n", "while num_patches <= max_patches:\n", " python_times = np.empty(0)\n", @@ -315,18 +345,29 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " num_patches *= 10\n", - " num_classes *= 10" + " if num_patches < 100:\n", + " num_patches += 10\n", + " num_classes += 10\n", + " else:\n", + " num_patches += 100\n", + " num_classes += 100" ] }, { "cell_type": "code", "execution_count": 6, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:06.357131Z", + "iopub.status.busy": "2026-08-28T10:47:06.357041Z", + "iopub.status.idle": "2026-08-28T10:47:06.401017Z", + "shell.execute_reply": "2026-08-28T10:47:06.400627Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -366,7 +407,14 @@ { "cell_type": "code", "execution_count": 7, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:06.401908Z", + "iopub.status.busy": "2026-08-28T10:47:06.401755Z", + "iopub.status.idle": "2026-08-28T10:47:06.404747Z", + "shell.execute_reply": "2026-08-28T10:47:06.404436Z" + } + }, "outputs": [], "source": [ "import numpy as np\n", @@ -438,7 +486,14 @@ { "cell_type": "code", "execution_count": 8, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:06.405491Z", + "iopub.status.busy": "2026-08-28T10:47:06.405416Z", + "iopub.status.idle": "2026-08-28T10:47:06.407591Z", + "shell.execute_reply": "2026-08-28T10:47:06.407257Z" + } + }, "outputs": [], "source": [ "from tiatoolbox import rmisc\n", @@ -481,7 +536,14 @@ { "cell_type": "code", "execution_count": 9, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:06.408253Z", + "iopub.status.busy": "2026-08-28T10:47:06.408183Z", + "iopub.status.idle": "2026-08-28T10:47:09.858264Z", + "shell.execute_reply": "2026-08-28T10:47:09.857756Z" + } + }, "outputs": [], "source": [ "import time\n", @@ -530,18 +592,29 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " num_patches *= 10\n", - " num_classes *= 10" + " if num_patches < 100:\n", + " num_patches += 10\n", + " num_classes += 10\n", + " else:\n", + " num_patches += 100\n", + " num_classes += 100" ] }, { "cell_type": "code", "execution_count": 10, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:09.859447Z", + "iopub.status.busy": "2026-08-28T10:47:09.859361Z", + "iopub.status.idle": "2026-08-28T10:47:09.903377Z", + "shell.execute_reply": "2026-08-28T10:47:09.902965Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -562,9 +635,7 @@ }, { "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "# Part 4: Semantic Segmentations As QuPath Json\n", "\n" @@ -573,7 +644,14 @@ { "cell_type": "code", "execution_count": 11, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:09.904165Z", + "iopub.status.busy": "2026-08-28T10:47:09.904083Z", + "iopub.status.idle": "2026-08-28T10:47:09.906254Z", + "shell.execute_reply": "2026-08-28T10:47:09.905892Z" + } + }, "outputs": [], "source": [ "from shapely.affinity import translate\n", @@ -609,7 +687,14 @@ { "cell_type": "code", "execution_count": 12, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:09.906914Z", + "iopub.status.busy": "2026-08-28T10:47:09.906841Z", + "iopub.status.idle": "2026-08-28T10:47:09.908623Z", + "shell.execute_reply": "2026-08-28T10:47:09.908293Z" + } + }, "outputs": [], "source": [ "from pathlib import Path\n", @@ -626,7 +711,14 @@ { "cell_type": "code", "execution_count": 13, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:09.909252Z", + "iopub.status.busy": "2026-08-28T10:47:09.909183Z", + "iopub.status.idle": "2026-08-28T10:47:09.910841Z", + "shell.execute_reply": "2026-08-28T10:47:09.910526Z" + } + }, "outputs": [], "source": [ "def poly_geo_func(coords: list) -> list:\n", @@ -646,7 +738,14 @@ { "cell_type": "code", "execution_count": 14, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:09.911486Z", + "iopub.status.busy": "2026-08-28T10:47:09.911418Z", + "iopub.status.idle": "2026-08-28T10:47:10.459011Z", + "shell.execute_reply": "2026-08-28T10:47:10.458536Z" + } + }, "outputs": [], "source": [ "from pathlib import Path\n", @@ -744,7 +843,14 @@ { "cell_type": "code", "execution_count": 15, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:10.460012Z", + "iopub.status.busy": "2026-08-28T10:47:10.459822Z", + "iopub.status.idle": "2026-08-28T10:47:10.462290Z", + "shell.execute_reply": "2026-08-28T10:47:10.461941Z" + } + }, "outputs": [], "source": [ "def rust_semantic_segmentations_as_qupath_json(\n", @@ -782,12 +888,19 @@ { "cell_type": "code", "execution_count": 16, - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:47:10.462965Z", + "iopub.status.busy": "2026-08-28T10:47:10.462892Z", + "iopub.status.idle": "2026-08-28T10:49:46.196237Z", + "shell.execute_reply": "2026-08-28T10:49:46.195820Z" + } + }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b66ebe7cd3e641ef8b5a51a726b3fbcc", + "model_id": "393b37c2fb0c4f5dafcc3aea04998786", "version_major": 2, "version_minor": 0 }, @@ -801,7 +914,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d7b559fce7ea492183c80a62cd3da495", + "model_id": "d65ca456eec34b87992aa27dc021c7b0", "version_major": 2, "version_minor": 0 }, @@ -815,7 +928,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eae152e3c916458da55349aa6e0fcdf5", + "model_id": "ddbe68e1a1064b2d8c3a9d8a267a67c8", "version_major": 2, "version_minor": 0 }, @@ -829,7 +942,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4d7dcd4747d046c3b199e1f94644b4a5", + "model_id": "ba73e26ed5a943ac938e140c55843c02", "version_major": 2, "version_minor": 0 }, @@ -843,7 +956,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6640117ea0c34548a819d31d62b5dec4", + "model_id": "51c47b104e7a40a1a949ecdf24c4b360", "version_major": 2, "version_minor": 0 }, @@ -857,12 +970,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a09eae9f8e054e84a3bc13c4a6a566d7", + "model_id": "0563ab96bb5f4cd0a9f2ce2da290a240", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Converting outputs to QuPath JSON.: 0%| | 0/99 [00:00" + "Converting outputs to QuPath JSON.: 0%| | 0/39 [00:00 Path:\n", - " \"\"\"Saves Annotation Store to disk.\"\"\"\n", - " # ensure proper db extension\n", - " save_path = save_path.parent.absolute() / (save_path.stem + \".db\")\n", - " store.commit()\n", - " store.dump(save_path)\n", - " return save_path" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "from tiatoolbox.annotation.storage import AnnotationStore, SQLiteStore\n", - "from tiatoolbox.type_hints import JSON\n", - "\n", - "\n", - "def process_contours(\n", - " contours: list[np.ndarray],\n", - " hierarchy: np.ndarray,\n", - " scale_factor: tuple[float, float] = (1, 1),\n", - " offset: np.ndarray | None = None,\n", - " properties: dict[str, JSON] | None = None,\n", - ") -> list[Annotation]:\n", - " \"\"\"Process contours and hierarchy to create annotations.\n", - "\n", - " Args:\n", - " contours (list[np.ndarray]):\n", - " A list of contours.\n", - " hierarchy (list[np.ndarray]):\n", - " A list of hierarchy.\n", - " scale_factor (tuple[float, float]):\n", - " The scale factor to use when loading the annotations.\n", - " offset (np.ndarray | None):\n", - " Optional offset to be added to the coordinates of the annotations.\n", - " properties (dict | None):\n", - " Optional properties to include with each annotation type.\n", - "\n", - " Returns:\n", - " list:\n", - " A list of annotations.\n", - "\n", - " \"\"\"\n", - " annotations_list: list[Annotation] = []\n", - " outer_contours: dict[int, np.ndarray] = {}\n", - " holes_dict: dict[int, list[np.ndarray]] = {}\n", - " base_props: dict[str, JSON] = {\"type\": \"mask\"}\n", - " if properties:\n", - " base_props.update(properties)\n", - "\n", - " for i, layer_ in enumerate(contours):\n", - " coords: np.ndarray = layer_.squeeze()\n", - " scaled_coords: np.ndarray = np.array([np.array(scale_factor) * coords])\n", - " if offset is not None:\n", - " scaled_coords += offset\n", - "\n", - " # save one points as a line, otherwise save the Polygon\n", - " if len(layer_) > 2: # noqa: PLR2004\n", - " if int(hierarchy[0][i][3]) == -1: # Outer contour\n", - " outer_contours[i] = scaled_coords[0]\n", - " else: # Hole\n", - " parent_idx: int = int(hierarchy[0][i][3])\n", - " if parent_idx not in holes_dict:\n", - " holes_dict[parent_idx] = []\n", - " holes_dict[parent_idx].append(scaled_coords[0])\n", - " # if two points, save as a line string\n", - " elif len(layer_) == 2: # noqa: PLR2004\n", - " feature_geom = feature2geometry(\n", - " {\n", - " \"type\": \"linestring\",\n", - " \"coordinates\": scaled_coords[0],\n", - " },\n", - " )\n", - " annotations_list.extend(\n", - " [\n", - " Annotation(\n", - " geometry=feature_geom,\n", - " properties=base_props,\n", - " )\n", - " ]\n", - " )\n", - " # if single point, save it is a point\n", - " else:\n", - " feature_geom = feature2geometry(\n", - " {\n", - " \"type\": \"point\",\n", - " \"coordinates\": scaled_coords,\n", - " },\n", - " )\n", - " annotations_list.extend(\n", - " [\n", - " Annotation(\n", - " geometry=feature_geom,\n", - " properties=base_props,\n", - " )\n", - " ]\n", - " )\n", - "\n", - " for idx, outer in outer_contours.items():\n", - " holes: list[np.ndarray] = holes_dict.get(idx, [])\n", - " if len(holes) != 0:\n", - " feature_geom = feature2geometry(\n", - " {\n", - " \"type\": \"Polygon\",\n", - " \"coordinates\": [outer, *holes],\n", - " },\n", - " )\n", - " else:\n", - " feature_geom = feature2geometry(\n", - " {\n", - " \"type\": \"Polygon\",\n", - " \"coordinates\": [outer],\n", - " },\n", - " )\n", - " feature_geom = make_valid_poly(feature_geom)\n", - " annotations_list.extend(\n", - " [\n", - " Annotation(\n", - " geometry=feature_geom,\n", - " properties=base_props,\n", - " )\n", - " ]\n", - " )\n", - "\n", - " return annotations_list" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "def py_semantic_segmentations_as_annotations(\n", - " layer_list: list,\n", - " preds: da.Array,\n", - " scale_factor: tuple[float, float],\n", - " class_dict: dict,\n", - " save_path: Path | None = None,\n", - " offset: np.ndarray | None = None,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> AnnotationStore | Path:\n", - " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", - " store = SQLiteStore()\n", - " annotations_list: list[Annotation] = []\n", - "\n", - " tqdm_loop = tqdm(\n", - " layer_list,\n", - " leave=False,\n", - " desc=\"Converting outputs to AnnotationStore.\",\n", - " disable=not verbose,\n", - " )\n", - "\n", - " for type_class in tqdm_loop:\n", - " class_id = int(type_class)\n", - " class_label = class_dict.get(class_id, class_id)\n", - " layer = da.where(preds == type_class, 1, 0).astype(\"uint8\").compute()\n", - " contours, hierarchy = cv2.findContours(\n", - " layer,\n", - " cv2.RETR_CCOMP,\n", - " cv2.CHAIN_APPROX_NONE,\n", - " )\n", - "\n", - " contours = cast(\"list[np.ndarray]\", contours)\n", - "\n", - " annotations_list_ = process_contours(\n", - " contours=contours,\n", - " hierarchy=hierarchy,\n", - " scale_factor=scale_factor,\n", - " offset=offset,\n", - " properties={\"type\": class_label, \"class\": class_id},\n", - " )\n", - " annotations_list.extend(annotations_list_)\n", - "\n", - " _ = store.append_many(\n", - " annotations_list, [str(i) for i in range(len(annotations_list))]\n", - " )\n", - "\n", - " # # if a save directory is provided, then dump store into a file\n", - " if save_path:\n", - " return save_annotations(\n", - " save_path=save_path,\n", - " store=store,\n", - " )\n", - "\n", - " return store" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "\n", - "import dask.array as da\n", - "import numpy as np\n", - "\n", - "\n", - "def rust_semantic_segmentations_as_annotations(\n", - " layer_list: list,\n", - " preds: da.Array,\n", - " scale_factor: tuple[float, float],\n", - " class_dict: dict,\n", - " save_path: Path | None = None,\n", - " offset: np.ndarray | None = None,\n", - " *,\n", - " verbose: bool = True,\n", - ") -> AnnotationStore | Path:\n", - " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", - " _ = verbose\n", - " store = SQLiteStore()\n", - " annotations_list: list[Annotation] = rmisc.semantic_segmentations_as_annotations(\n", - " layer_list, preds, scale_factor, class_dict, offset, cv2, process_contours\n", - " )\n", - "\n", - " _ = store.append_many(\n", - " annotations_list, [str(i) for i in range(len(annotations_list))]\n", - " )\n", - "\n", - " # # if a save directory is provided, then dump store into a file\n", - " if save_path:\n", - " return save_annotations(\n", - " save_path=save_path,\n", - " store=store,\n", - " )\n", - "\n", - " return store" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fa5afc63dabb4453be69e16366d78e32", + "model_id": "8ef6227139994ec2b5879afe2a1294e7", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Converting outputs to AnnotationStore.: 0%| | 0/9 [00:00" + "Converting outputs to QuPath JSON.: 0%| | 0/49 [00:00 tuple[str, ...]:\n", - " \"\"\"Splits input string to tuple at ','.\n", - "\n", - " Args:\n", - " in_str (str):\n", - " input string.\n", - "\n", - " Returns:\n", - " tuple[str, ...]:\n", - " Return a tuple of strings by splitting in_str at ','.\n", - "\n", - " \"\"\"\n", - " return tuple(substring.strip() for substring in in_str.split(\",\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "from tiatoolbox import rmisc\n", - "\n", - "\n", - "def rust_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", - " \"\"\"Splits input string to tuple at ','.\n", - "\n", - " Args:\n", - " in_str (str):\n", - " input string.\n", - "\n", - " Returns:\n", - " tuple[str, ...]:\n", - " Return a tuple of strings by splitting in_str at ','.\n", - "\n", - " \"\"\"\n", - " return tuple(rmisc.string_to_tuple(in_str))" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "\n", - "import numpy as np\n", - "\n", - "sizeofarray = []\n", - "timings = []\n", - "timings = []\n", - "i = 1\n", - "in_str = \"\"\n", - "max_patches = 100000\n", - "while i <= max_patches:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for j in range(int(len(in_str) / 2), i):\n", - " in_str += \" , \" + str(j)\n", - " for _j in range(10):\n", - " start_time = time.time()\n", - " python_object = py_string_to_tuple(in_str)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_object = rust_string_to_tuple(in_str)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " if python_object != rust_object:\n", - " print(\"Incorrect result\")\n", - " sizeofarray.append(len(in_str))\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "cebf00b01b754b50978d3e6b980d98b4", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Converting outputs to QuPath JSON.: 0%| | 0/59 [00:00 np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " # check if image is not uint8\n", - " dimension_for_rust = 3\n", - "\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " if img.ndim == dimension_for_rust:\n", - " return rmisc.contrast_enhancer(img, low_p, high_p)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Contrast Enhancer written fully in python\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "def py_contrast_enhancer(\n", - " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", - ") -> np.ndarray:\n", - " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", - "\n", - " This method uses both image low and high percentiles.\n", - "\n", - " Args:\n", - " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", - " Image should be uint8.\n", - " low_p (scalar): low percentile of image values to be saturated to 0.\n", - " high_p (scalar): high percentile of image values to be saturated to 255.\n", - " high_p should always be greater than low_p.\n", - "\n", - " Returns:\n", - " img (:class:`numpy.ndarray`):\n", - " Image (uint8) with contrast enhanced.\n", - "\n", - " Raises:\n", - " AssertionError: Internal errors due to invalid img type.\n", - "\n", - " Examples:\n", - " >>> from tiatoolbox import utils\n", - " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", - "\n", - " \"\"\"\n", - " # check if image is not uint8\n", - " if img.dtype != np.uint8:\n", - " msg = \"Image should be uint8.\"\n", - " raise AssertionError(msg)\n", - " img_out = img.copy()\n", - " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", - " p_low, p_high = percentiles[0], percentiles[1]\n", - " if p_low >= p_high:\n", - " p_low, p_high = np.min(img_out), np.max(img_out)\n", - " if p_high > p_low:\n", - " img_out = exposure.rescale_intensity(\n", - " img_out,\n", - " in_range=(p_low, p_high),\n", - " out_range=(0.0, 255.0),\n", - " )\n", - " return img_out.astype(np.uint8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Comparison of speed it takes to run code in rust vs python\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "id": "DZBiw_EepT5x" - }, - "outputs": [], - "source": [ - "import time\n", - "\n", - "sizeofarray = []\n", - "timings = []\n", - "i = 1\n", - "maxarraysize = 10000\n", - "while i <= maxarraysize:\n", - " python_times = np.empty(0)\n", - " rust_times = np.empty(0)\n", - " for _j in range(5):\n", - " rng = np.random.default_rng()\n", - " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", - " start_time = time.time()\n", - " python_result = py_contrast_enhancer(temp, 2, 96)\n", - " python_end_time = time.time() - start_time\n", - " python_times = np.append(python_times, python_end_time)\n", - " start_time = time.time()\n", - " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", - " rust_end_time = time.time() - start_time\n", - " rust_times = np.append(rust_times, rust_end_time)\n", - " if not np.allclose(python_result, rust_result, atol=1):\n", - " print(\"Incorrect result\")\n", - " sizeofarray.append(i)\n", - " timings.append([np.average(python_times), np.average(rust_times)])\n", - " i *= 10" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "b7ced44e9d9145e69c0f7cd2a3ab33fd", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Converting outputs to QuPath JSON.: 0%| | 0/59 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 5: Semantic Segmentations As Annotations\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:49:46.237061Z", + "iopub.status.busy": "2026-08-28T10:49:46.236982Z", + "iopub.status.idle": "2026-08-28T10:49:46.238684Z", + "shell.execute_reply": "2026-08-28T10:49:46.238435Z" + } + }, + "outputs": [], + "source": [ + "from tiatoolbox.annotation.storage import AnnotationStore\n", + "\n", + "\n", + "def save_annotations(\n", + " save_path: Path,\n", + " store: AnnotationStore,\n", + ") -> Path:\n", + " \"\"\"Saves Annotation Store to disk.\"\"\"\n", + " # ensure proper db extension\n", + " save_path = save_path.parent.absolute() / (save_path.stem + \".db\")\n", + " store.commit()\n", + " store.dump(save_path)\n", + " return save_path" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:49:46.239371Z", + "iopub.status.busy": "2026-08-28T10:49:46.239303Z", + "iopub.status.idle": "2026-08-28T10:49:46.244509Z", + "shell.execute_reply": "2026-08-28T10:49:46.244234Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from tiatoolbox.annotation.storage import AnnotationStore, SQLiteStore\n", + "from tiatoolbox.type_hints import JSON\n", + "\n", + "\n", + "def process_contours(\n", + " contours: list[np.ndarray],\n", + " hierarchy: np.ndarray,\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " offset: np.ndarray | None = None,\n", + " properties: dict[str, JSON] | None = None,\n", + ") -> list[Annotation]:\n", + " \"\"\"Process contours and hierarchy to create annotations.\n", + "\n", + " Args:\n", + " contours (list[np.ndarray]):\n", + " A list of contours.\n", + " hierarchy (list[np.ndarray]):\n", + " A list of hierarchy.\n", + " scale_factor (tuple[float, float]):\n", + " The scale factor to use when loading the annotations.\n", + " offset (np.ndarray | None):\n", + " Optional offset to be added to the coordinates of the annotations.\n", + " properties (dict | None):\n", + " Optional properties to include with each annotation type.\n", + "\n", + " Returns:\n", + " list:\n", + " A list of annotations.\n", + "\n", + " \"\"\"\n", + " annotations_list: list[Annotation] = []\n", + " outer_contours: dict[int, np.ndarray] = {}\n", + " holes_dict: dict[int, list[np.ndarray]] = {}\n", + " base_props: dict[str, JSON] = {\"type\": \"mask\"}\n", + " if properties:\n", + " base_props.update(properties)\n", + "\n", + " for i, layer_ in enumerate(contours):\n", + " coords: np.ndarray = layer_.squeeze()\n", + " scaled_coords: np.ndarray = np.array([np.array(scale_factor) * coords])\n", + " if offset is not None:\n", + " scaled_coords += offset\n", + "\n", + " # save one points as a line, otherwise save the Polygon\n", + " if len(layer_) > 2: # noqa: PLR2004\n", + " if int(hierarchy[0][i][3]) == -1: # Outer contour\n", + " outer_contours[i] = scaled_coords[0]\n", + " else: # Hole\n", + " parent_idx: int = int(hierarchy[0][i][3])\n", + " if parent_idx not in holes_dict:\n", + " holes_dict[parent_idx] = []\n", + " holes_dict[parent_idx].append(scaled_coords[0])\n", + " # if two points, save as a line string\n", + " elif len(layer_) == 2: # noqa: PLR2004\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"linestring\",\n", + " \"coordinates\": scaled_coords[0],\n", + " },\n", + " )\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + " # if single point, save it is a point\n", + " else:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"point\",\n", + " \"coordinates\": scaled_coords,\n", + " },\n", + " )\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + "\n", + " for idx, outer in outer_contours.items():\n", + " holes: list[np.ndarray] = holes_dict.get(idx, [])\n", + " if len(holes) != 0:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": [outer, *holes],\n", + " },\n", + " )\n", + " else:\n", + " feature_geom = feature2geometry(\n", + " {\n", + " \"type\": \"Polygon\",\n", + " \"coordinates\": [outer],\n", + " },\n", + " )\n", + " feature_geom = make_valid_poly(feature_geom)\n", + " annotations_list.extend(\n", + " [\n", + " Annotation(\n", + " geometry=feature_geom,\n", + " properties=base_props,\n", + " )\n", + " ]\n", + " )\n", + "\n", + " return annotations_list" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:49:46.245229Z", + "iopub.status.busy": "2026-08-28T10:49:46.245115Z", + "iopub.status.idle": "2026-08-28T10:49:46.247613Z", + "shell.execute_reply": "2026-08-28T10:49:46.247388Z" + } + }, + "outputs": [], + "source": [ + "def py_semantic_segmentations_as_annotations(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + " offset: np.ndarray | None = None,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> AnnotationStore | Path:\n", + " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", + " store = SQLiteStore()\n", + " annotations_list: list[Annotation] = []\n", + "\n", + " tqdm_loop = tqdm(\n", + " layer_list,\n", + " leave=False,\n", + " desc=\"Converting outputs to AnnotationStore.\",\n", + " disable=not verbose,\n", + " )\n", + "\n", + " for type_class in tqdm_loop:\n", + " class_id = int(type_class)\n", + " class_label = class_dict.get(class_id, class_id)\n", + " layer = da.where(preds == type_class, 1, 0).astype(\"uint8\").compute()\n", + " contours, hierarchy = cv2.findContours(\n", + " layer,\n", + " cv2.RETR_CCOMP,\n", + " cv2.CHAIN_APPROX_NONE,\n", + " )\n", + "\n", + " contours = cast(\"list[np.ndarray]\", contours)\n", + "\n", + " annotations_list_ = process_contours(\n", + " contours=contours,\n", + " hierarchy=hierarchy,\n", + " scale_factor=scale_factor,\n", + " offset=offset,\n", + " properties={\"type\": class_label, \"class\": class_id},\n", + " )\n", + " annotations_list.extend(annotations_list_)\n", + "\n", + " _ = store.append_many(\n", + " annotations_list, [str(i) for i in range(len(annotations_list))]\n", + " )\n", + "\n", + " # # if a save directory is provided, then dump store into a file\n", + " if save_path:\n", + " return save_annotations(\n", + " save_path=save_path,\n", + " store=store,\n", + " )\n", + "\n", + " return store" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:49:46.248234Z", + "iopub.status.busy": "2026-08-28T10:49:46.248164Z", + "iopub.status.idle": "2026-08-28T10:49:46.250187Z", + "shell.execute_reply": "2026-08-28T10:49:46.249973Z" + } + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import dask.array as da\n", + "import numpy as np\n", + "\n", + "\n", + "def rust_semantic_segmentations_as_annotations(\n", + " layer_list: list,\n", + " preds: da.Array,\n", + " scale_factor: tuple[float, float],\n", + " class_dict: dict,\n", + " save_path: Path | None = None,\n", + " offset: np.ndarray | None = None,\n", + " *,\n", + " verbose: bool = True,\n", + ") -> AnnotationStore | Path:\n", + " \"\"\"Helper function to save semantic segmentation as annotations.\"\"\"\n", + " _ = verbose\n", + " store = SQLiteStore()\n", + " annotations_list: list[Annotation] = rmisc.semantic_segmentations_as_annotations(\n", + " layer_list, preds, scale_factor, class_dict, offset, cv2, process_contours\n", + " )\n", + "\n", + " _ = store.append_many(\n", + " annotations_list, [str(i) for i in range(len(annotations_list))]\n", + " )\n", + "\n", + " # # if a save directory is provided, then dump store into a file\n", + " if save_path:\n", + " return save_annotations(\n", + " save_path=save_path,\n", + " store=store,\n", + " )\n", + "\n", + " return store" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:49:46.250784Z", + "iopub.status.busy": "2026-08-28T10:49:46.250714Z", + "iopub.status.idle": "2026-08-28T10:50:48.228195Z", + "shell.execute_reply": "2026-08-28T10:50:48.227827Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c34e8f0b5774faca5891cd7a6239b88", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Converting outputs to AnnotationStore.: 0%| | 0/9 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Part 6: String To Tuple\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.268675Z", + "iopub.status.busy": "2026-08-28T10:50:48.268597Z", + "iopub.status.idle": "2026-08-28T10:50:48.270166Z", + "shell.execute_reply": "2026-08-28T10:50:48.269963Z" + } + }, + "outputs": [], + "source": [ + "def py_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return tuple(substring.strip() for substring in in_str.split(\",\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.270917Z", + "iopub.status.busy": "2026-08-28T10:50:48.270837Z", + "iopub.status.idle": "2026-08-28T10:50:48.272328Z", + "shell.execute_reply": "2026-08-28T10:50:48.272103Z" + } + }, + "outputs": [], + "source": [ + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_string_to_tuple(in_str: str) -> tuple[str, ...]:\n", + " \"\"\"Splits input string to tuple at ','.\n", + "\n", + " Args:\n", + " in_str (str):\n", + " input string.\n", + "\n", + " Returns:\n", + " tuple[str, ...]:\n", + " Return a tuple of strings by splitting in_str at ','.\n", + "\n", + " \"\"\"\n", + " return tuple(rmisc.string_to_tuple(in_str))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.272923Z", + "iopub.status.busy": "2026-08-28T10:50:48.272856Z", + "iopub.status.idle": "2026-08-28T10:50:48.413147Z", + "shell.execute_reply": "2026-08-28T10:50:48.412877Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "timings = []\n", + "i = 10\n", + "in_str = \"\"\n", + "max_patches = 10000\n", + "while i <= max_patches:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for j in range(int(len(in_str) / 2), i):\n", + " in_str += \" , \" + str(j)\n", + " for _j in range(10):\n", + " start_time = time.time()\n", + " python_object = py_string_to_tuple(in_str)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_object = rust_string_to_tuple(in_str)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " if python_object != rust_object:\n", + " print(\"Incorrect result\")\n", + " sizeofarray.append(len(in_str))\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " if i < 100:\n", + " i += 10\n", + " else:\n", + " i += 100" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.414060Z", + "iopub.status.busy": "2026-08-28T10:50:48.413988Z", + "iopub.status.idle": "2026-08-28T10:50:48.459197Z", + "shell.execute_reply": "2026-08-28T10:50:48.458946Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[np.float64(7.152557373046875e-07), np.float64(5.7220458984375e-07)]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "print(timings[1])\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Length of string\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 7: Contrast Enhancer\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.459957Z", + "iopub.status.busy": "2026-08-28T10:50:48.459883Z", + "iopub.status.idle": "2026-08-28T10:50:48.472521Z", + "shell.execute_reply": "2026-08-28T10:50:48.472253Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from skimage import exposure\n", + "\n", + "from tiatoolbox import rmisc\n", + "\n", + "\n", + "def rust_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " # check if image is not uint8\n", + " dimension_for_rust = 3\n", + "\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " if img.ndim == dimension_for_rust:\n", + " return rmisc.contrast_enhancer(img, low_p, high_p)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contrast Enhancer written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.473287Z", + "iopub.status.busy": "2026-08-28T10:50:48.473214Z", + "iopub.status.idle": "2026-08-28T10:50:48.475262Z", + "shell.execute_reply": "2026-08-28T10:50:48.475039Z" + } + }, + "outputs": [], + "source": [ + "def py_contrast_enhancer(\n", + " img: np.ndarray, low_p: int = 2, high_p: int = 98\n", + ") -> np.ndarray:\n", + " \"\"\"Enhance contrast of the input image using intensity adjustment.\n", + "\n", + " This method uses both image low and high percentiles.\n", + "\n", + " Args:\n", + " img (:class:`numpy.ndarray`): input image used to obtain tissue mask.\n", + " Image should be uint8.\n", + " low_p (scalar): low percentile of image values to be saturated to 0.\n", + " high_p (scalar): high percentile of image values to be saturated to 255.\n", + " high_p should always be greater than low_p.\n", + "\n", + " Returns:\n", + " img (:class:`numpy.ndarray`):\n", + " Image (uint8) with contrast enhanced.\n", + "\n", + " Raises:\n", + " AssertionError: Internal errors due to invalid img type.\n", + "\n", + " Examples:\n", + " >>> from tiatoolbox import utils\n", + " >>> img = utils.misc.contrast_enhancer(img, low_p=2, high_p=98)\n", + "\n", + " \"\"\"\n", + " # check if image is not uint8\n", + " if img.dtype != np.uint8:\n", + " msg = \"Image should be uint8.\"\n", + " raise AssertionError(msg)\n", + " img_out = img.copy()\n", + " percentiles = np.array(np.percentile(img_out, (low_p, high_p)))\n", + " p_low, p_high = percentiles[0], percentiles[1]\n", + " if p_low >= p_high:\n", + " p_low, p_high = np.min(img_out), np.max(img_out)\n", + " if p_high > p_low:\n", + " img_out = exposure.rescale_intensity(\n", + " img_out,\n", + " in_range=(p_low, p_high),\n", + " out_range=(0.0, 255.0),\n", + " )\n", + " return img_out.astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:50:48.475921Z", + "iopub.status.busy": "2026-08-28T10:50:48.475818Z", + "iopub.status.idle": "2026-08-28T10:52:51.192692Z", + "shell.execute_reply": "2026-08-28T10:52:51.192214Z" + }, + "id": "DZBiw_EepT5x" + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "sizeofarray = []\n", + "timings = []\n", + "i = 10\n", + "maxarraysize = 10000\n", + "while i <= maxarraysize:\n", + " python_times = np.empty(0)\n", + " rust_times = np.empty(0)\n", + " for _j in range(5):\n", + " rng = np.random.default_rng()\n", + " temp = rng.uniform(0, 255, size=(i, i, 3)).astype(np.uint8)\n", + " start_time = time.time()\n", + " python_result = py_contrast_enhancer(temp, 2, 96)\n", + " python_end_time = time.time() - start_time\n", + " python_times = np.append(python_times, python_end_time)\n", + " start_time = time.time()\n", + " rust_result = rust_contrast_enhancer(temp, 2, 96)\n", + " rust_end_time = time.time() - start_time\n", + " rust_times = np.append(rust_times, rust_end_time)\n", + " if not np.allclose(python_result, rust_result, atol=1):\n", + " print(\"Incorrect result\")\n", + " sizeofarray.append(i)\n", + " timings.append([np.average(python_times), np.average(rust_times)])\n", + " if i < 100:\n", + " i += 10\n", + " elif i < 1000:\n", + " i += 100\n", + " else:\n", + " i += 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T10:52:51.194003Z", + "iopub.status.busy": "2026-08-28T10:52:51.193913Z", + "iopub.status.idle": "2026-08-28T10:52:51.233367Z", + "shell.execute_reply": "2026-08-28T10:52:51.233067Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(sizeofarray, timings)\n", + "plt.xlabel(\"Size of array\")\n", + "plt.ylabel(\"Time(s)\")\n", + "plt.legend([\"Python\", \"Rust\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Caution - The rust version differs from the python version by max 1\n", + "\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "interpreter": { + "hash": "a3ed8fb525a8bde66cc7655a5df08d8d0f8699a69b9eb5ccab28dc0a7837eec6" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0060847d73ee4413b4770132aad88aa5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0072758cb5a441a189c874088e2e4f9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0099e0eed0af4be88b3d64f9e7069ca0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d3358f971f0d48f88a5d44c91d3fb7a6", + "placeholder": "​", + "style": "IPY_MODEL_8b95af3fe6ec49b6a2f3d7edfd4172a5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" + } + }, + "00c2ce8137c8400d8a248a035dec5b14": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "00fa80e77f7741519634dfcf9bad01de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_776ad76aba9548ff87f451346ffe5e6e", + "IPY_MODEL_a355e395f10040dfa002089118841303", + "IPY_MODEL_f1e87e57b914424cbcfa344bfadcb60e" + ], + "layout": "IPY_MODEL_eed9040d31db4bd1bec29339e53e3306", + "tabbable": null, + "tooltip": null + } + }, + "0126894018224984b563e8bcb410d05d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01276c00429544beacdb0a66b06f7676": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01364955bb824efb8419965b3dfd964d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0194287cfbf349ba9a6b415bea46ab81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e40fe9987f85442296584419162dd149", + "IPY_MODEL_6a241b90ea934dfbb7681056ccf7de62", + "IPY_MODEL_b87b207d94984923a25fde279d144d9a" + ], + "layout": "IPY_MODEL_1d0be30994da4e6798e43238564de104", + "tabbable": null, + "tooltip": null + } + }, + "01fe3f8bfc9441f3a6db7a92d65dcdab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e7478027f5ad4cd1bbc0960ace565444", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5a2877cdbaf34cfdad1e409dc8f388e7", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "0252dffdfd354d2a8150275e552ebee0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "026f1affcc3f4093bef8fd601c5e9a78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_46aedaa7a7d34779837b93dcf3916e32", + "placeholder": "​", + "style": "IPY_MODEL_606fb842ff3c4ffc8dddc6b281d2c021", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "02c55abb74db4006924148d88a1b3732": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8ab9fcd143bf46919318a3bb77aa3e1c", + "placeholder": "​", + "style": "IPY_MODEL_fe0f230185f2470c963a01e6393ced04", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "030a6f3fea224c8a82f8cdce0b082606": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0320460434d44245b2d484162e67183c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0328cc2d5ff04b8498744959cf91e87d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "033245f09b9b44d89d4679e28ace6ef2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "034be21e4dd04b29b643eaa1a9df3b11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "03620e83b2a54d48974c46c04af50a11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d6c2a38346e4a50b1c140774709c45c", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fe833ec08ef84467be5a41bc49e84336", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "03cdefc6bcc3441c96d965034eb1c6f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03ecefcfa09d4e8384ff3a8c933522bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ba05376918f94f348dcc480f6bce817a", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8428758943004c549e3fc8419c1af086", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "044dfc445e544deaaf2bc132418a4ac8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04989c6b1d6d487786b5cc6185bbe9f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04f8f3ecb7ab4726a414c4953afd14f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_85b2264e560f4dfaa64ee77e144a3d20", + "placeholder": "​", + "style": "IPY_MODEL_766f2422c6c14704bbea3fe759a29a31", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "0514849d6d8c4727a4751a7c66a05ca7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "053c536d46334f02bcc1be9ebad98279": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0563ab96bb5f4cd0a9f2ce2da290a240": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0ddc57e0e4f04cbb9469b145769e8c2d", + "IPY_MODEL_632bda88d5834271a6286cec2918ae51", + "IPY_MODEL_c1d5610dee5a455094329f5deb02f19d" + ], + "layout": "IPY_MODEL_a06fa235eb974b11919167dc583e4409", + "tabbable": null, + "tooltip": null + } + }, + "059d0fbaeccd4aeea43f24e93d191b08": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f22d03c204a342288dd7efe8a22d48ed", + "IPY_MODEL_ddf2ca4ebb8741399cdcd4dc0c972dc3", + "IPY_MODEL_e5d527029e744ec6b36b963d68e2c649" + ], + "layout": "IPY_MODEL_fd0a818a3abe4d83b5db0d8cebfb7225", + "tabbable": null, + "tooltip": null + } + }, + "05ae8b0f921d49dcacef411f7595984c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "062dda88b8404d12a8d6f135b976191f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_66e9d77edd784b41a9b35a676021b82d", + "IPY_MODEL_e01c4b3ba4ea4da5849828f855afbb7a", + "IPY_MODEL_d600dbd8924f4d409c5e5a110d276ee5" + ], + "layout": "IPY_MODEL_85a29b2dd1634be7ad97027681f62fb0", + "tabbable": null, + "tooltip": null + } + }, + "0638947f16b941a39beb81ecb130627f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "064f561913a64aa18e47a14c7d705634": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "067db5ac65ff4bd989a502badf2ccead": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "067ef8d9b43f475c8bafd8641e82b903": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "06971c04a2ae4553bf2088ce320a6a02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "070410c8505741cb9d891b61db4b1d67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2ce5391336384dce9727c24bebd9cf25", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_09080df737fc4ffe8e8bb62b25f949d2", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "0722cdd68ced4db8ac1516a4c8e0852b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "075e2975edcc4b538157b98ef22e4ad1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "07847480e58a43e9ae3aa39669ceb5a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f60661654b89466394e752e2c5aafd51", + "placeholder": "​", + "style": "IPY_MODEL_bf3b64c6daf34adb94322fe66be5485c", + "tabbable": null, + "tooltip": null, + "value": " 74/99 [00:00<00:00, 273.30it/s]" + } + }, + "07b2a8bef0984a42a8b9bd4f68671314": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "07d17c41ab2d4770bb6098c26363e34b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_39d947fbc8bc4b239cfdb1a73869ec61", + "placeholder": "​", + "style": "IPY_MODEL_edbc56fcfef44c16a94f76c9082fe44f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "0866b3ae2bb64864bc472d1e3501d49b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f038310c56d84ff98cd045fc75d74752", + "IPY_MODEL_9fc95f811a0643df88cf59a88f77e44e", + "IPY_MODEL_5dc8a57043634ef88b6a71d614a0e786" + ], + "layout": "IPY_MODEL_7021866ffaf74b48b951a0d457173c2e", + "tabbable": null, + "tooltip": null + } + }, + "0870533661634ff0aba3af61c7d1f45b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08925efaf2434c049defe77e47ce5277": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "089482d21d104b2091c8783589513134": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08a4c1252645469aab123b139f486913": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08b2544827604ac88f95a23a1587e481": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08cf7d4ce5764be7a8d1a0d02365cd19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_12492cb92bbf4157a0bdff36097e517e", + "placeholder": "​", + "style": "IPY_MODEL_10f63dcb334a4b37ae3e23201fdad024", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "08edb965c1a0472287c034112093d682": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1b359157d85a4f4b8e7b457e72ef4b20", + "placeholder": "​", + "style": "IPY_MODEL_7249d35604ea4dd5ad74f2f58dc166b8", + "tabbable": null, + "tooltip": null, + "value": " 72/89 [00:00<00:00, 355.19it/s]" + } + }, + "09080df737fc4ffe8e8bb62b25f949d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0936de0747cb4882ab7e6f256d7aa4eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09758263bc224d42ab0415b16f594e8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c04222edb66a41d89829c004a0a610ba", + "placeholder": "​", + "style": "IPY_MODEL_59ffdeae8b104c3fad63490531b041ea", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "09896c1482f9411ead4ab9b1e53033df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09b6451b6d2a470a99ecf69281636987": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09d89a1d3bb64595a47d85dfecf2fe5e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a320e2aa9eb4d89afaf9573cfcc5216": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e4f00fc898ac4023b7ff5b6a84d59c44", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e0bb0891085947018543e0b25fe6a5dd", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "0aa5d390f8884c5483607403b475ec17": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ab0066603cf4d5995c04bf52784df9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0ab84b3feb0e4fb9b398271421a62892": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b1fe2bfddaf432e8689aa62f0b7a7fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_37aa79bf53a44b3aba45d335e01a52c4", + "placeholder": "​", + "style": "IPY_MODEL_5343a2a9a0d145e9b772c8a2bd7f9c3e", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "0b20702be4c64ecd98b5e0d942983f28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b3333a3f2d242eeab9043467a135115": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9994d11815364fe0a205a24457276f26", + "placeholder": "​", + "style": "IPY_MODEL_2b89575e8d774ab289d214e70fc2ee7d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "0b5a2fd13fcf4d4b8845daec25f835c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b9d5860db89472eafcd3106dc31cdeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bc9005f8c1c4516afe4fa8b208fb1eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d5fb1762b5754525b2dfdefa48b7826a", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_296269f997e44a7081d95fa892581460", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "0bcedd3d0a1647868942cd10b21bdc7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c358a0b1a04406b8c14c18ae63b7091": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c35d03637944273aea93bb69924aabc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "0c5255b8243149c3a080248829a09f85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ebfc2591c3ff485e803aee787d8ed593", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_204c00aaed314746bba9ba40a91e8dea", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "0c6502ee8c2c42b7ba21f18ca572eac0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c83849d2aac453b9384639ee6bb8cca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_33fb7da188e444138750822e841e9b94", + "IPY_MODEL_0c5255b8243149c3a080248829a09f85", + "IPY_MODEL_40e2610cd39e4eeaa107c8784ab9323a" + ], + "layout": "IPY_MODEL_1cf274d7bb2f4275b01d4ef77e61d5cd", + "tabbable": null, + "tooltip": null + } + }, + "0d1f00eccad145d18d77ffacd34fdcfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0d50d58d19724a3da81062fd5cb4b2c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "0d5640937572475e883381477c91ee26": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d5b733a0be84859b36df24d1a76e762": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_68433c7916cc4732a85ef3ed3a3c6e56", + "IPY_MODEL_10e7fae882104853a4eb4c34f69caed3", + "IPY_MODEL_a8e1874938074203ac81d478fd1e201d" + ], + "layout": "IPY_MODEL_d9af00f60d5446acb1d9c1cc0cfe770a", + "tabbable": null, + "tooltip": null + } + }, + "0d6c2a38346e4a50b1c140774709c45c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d9da7bf768a43f7ad3e279838a2bfce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0db8d88810a3451c80f64a5362480743": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6e31475de7ac433caaf1847bea3ee857", + "IPY_MODEL_cc625e16f1c64d55a0d24ea0984f4d81", + "IPY_MODEL_5ea60f460a0e482182651d158dcb90f1" + ], + "layout": "IPY_MODEL_9cdf78cc7bd642e0b9d7982209392e22", + "tabbable": null, + "tooltip": null + } + }, + "0ddc57e0e4f04cbb9469b145769e8c2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea5e890d80d74f688eb8f80994f47716", + "placeholder": "​", + "style": "IPY_MODEL_3a6c6ab14c9948da847a706bc8b1d7cb", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "0e483bb542e74106a15fecceb78d8e19": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0eb06dd7112d444185d8378055502557": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f8c19883440b464ea6907f88ecc20cb6", + "placeholder": "​", + "style": "IPY_MODEL_7e4e24585c9349c498bbd58bbdcc7254", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "0ec6c1a9fa2a4df48758b1978a5a2fd4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6866a64e6a494644ae47e04fbe9567af", + "placeholder": "​", + "style": "IPY_MODEL_0b20702be4c64ecd98b5e0d942983f28", + "tabbable": null, + "tooltip": null, + "value": " 590/599 [00:01<00:00, 363.42it/s]" + } + }, + "0eff6eb6b0464bb99d15ed98f3c6528a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "0f5169afe8414d4a8f7c9c1aac77f5dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f52b0bb14a2422f8255a59614352d54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1bf227c4b0f642bab9bc53c6b7c7746a", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_0ab0066603cf4d5995c04bf52784df9b", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "0f7a69eb5e3a4dc39b672b48028fa0dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0c358a0b1a04406b8c14c18ae63b7091", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b8decf0a9fb24d29aa2988e1f1347b5f", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "0fd9e4cf02f640b28c1218a6c408a1eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d5640937572475e883381477c91ee26", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_318876949a134d929ae4b8120885c81c", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "0fe3cac99b2b4e26a5ae84ed7da87675": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0ff2fe8894674c18a3cb96ccb71fdf21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "102f1848b58d41f892867c43637f8b4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "108807822cd546bf8582c7b3ffaa5591": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1098bcfa42894381a07c5883849c651c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4acc29a2907645d7a33c08f06a804407", + "placeholder": "​", + "style": "IPY_MODEL_e231ca64eb4a4161bd34c8ec0ce9cf95", + "tabbable": null, + "tooltip": null, + "value": " 778/799 [00:02<00:00, 362.62it/s]" + } + }, + "10d96c31ac9040508c5e8a8efdf66596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "10e7fae882104853a4eb4c34f69caed3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_275651dc7c7f4b0a938d1f4bd41ecf88", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6bb48ac44e154515865180e401f675f3", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "10f63dcb334a4b37ae3e23201fdad024": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "114b76517f2a4cb4aef8905cc5a7c01c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b8c4862861714cb1bb160e7e94a61bc0", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_64e89c05702c45f3ac0558317f9f55d5", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "1188553b527c416585862b84380cf028": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1190eeb17c3f46cbbf57fa9f36f7eca4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d52f7fe0ac544f58b726245383cea7fb", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_adf76844a8d94c318d7b11f124e05ca9", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "11a731d616f640199f64e0145367c5ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5a378788140448aa8817ca9f5373d77c", + "IPY_MODEL_6a2ef554ab7548399ae616331f89d96c", + "IPY_MODEL_7fa4aebf91ec47cc946851ec20bb3700" + ], + "layout": "IPY_MODEL_bdb137f7a4a846c2b65249870ef077a1", + "tabbable": null, + "tooltip": null + } + }, + "11b70c1674db47d8bae8cb991942250b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "11fd9acc6eec4a58b00464a6a6748efa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "120ef5fdd51e4140bb835b9f80ae8b23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fac12ab2299f4eb49e2f2ad4ab157ae7", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2e400fcf8095414483146e907b8025f7", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "1210f02976414c3789c0b00cbe9ff17d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "12492cb92bbf4157a0bdff36097e517e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12a1fd63340146cfaf0b672ecdbde2a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "12a69feb639a449da46fcb07f90a585c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "12a6aba1c13649ce83260edd991ec1cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "12fe1abb25ea47dd9478f195b718974d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "12fe941e2aff47c6af6415035cbe59f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fd7f07c8304e4edc81106a886df8d71c", + "placeholder": "​", + "style": "IPY_MODEL_c883da9f1be14cc7b0994683eb3b6426", + "tabbable": null, + "tooltip": null, + "value": " 592/599 [00:01<00:00, 362.75it/s]" + } + }, + "132a0fb522764f228fc5e2353294c6e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1349031413004abd8f5755f9de81d47c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13f0f814d19d4c7eb8c2a28a50175477": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5e1de8a0d9a44b9a9e4289d02fd4b22c", + "placeholder": "​", + "style": "IPY_MODEL_f0c8be8468434012b19d9f4969a16cad", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  96%" + } + }, + "1467cab00aa44370904975393b23f428": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "148576e0fb2141a0808464ed94b127fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b0683478a18b4a92a1e2c29f78fa8ef4", + "placeholder": "​", + "style": "IPY_MODEL_166e772557624d1bad5b3f093b4f991f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.: 100%" + } + }, + "1498e2383e4b4f8d862f6580681818e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7bb460b12a98451bb3dbb3b6d28548ee", + "placeholder": "​", + "style": "IPY_MODEL_8c71d8800d2440a78faae5237b85fda1", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 357.70it/s]" + } + }, + "149e8cd40de74f6d923525b2e157aac1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "14c4c1d89dbe4de68035c60d5834acff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a7a2d91e2baa48c3a34cbfa0e37672f6", + "placeholder": "​", + "style": "IPY_MODEL_d784ada454e9411dab47048443652156", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.: 100%" + } + }, + "14e7ebfb9a4f49998a14dc5abaaa5802": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15469e8d34ba4a6f80813b8992edbd61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_48ec6902fd1643c6a101327124719189", + "placeholder": "​", + "style": "IPY_MODEL_6d93a53d604049e08e5720f826739d68", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  73%" + } + }, + "15562d5515c54685a0418ac312a70993": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "157298b29fda4f85b5d13b1be48369b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "15bacaaa83cc4d4d8178c97f3132e31d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_21d4798508e247b2b35fb6cf9cb26e84", + "placeholder": "​", + "style": "IPY_MODEL_5ad8c3961cae45b79690253e0124bae9", + "tabbable": null, + "tooltip": null, + "value": " 665/699 [00:01<00:00, 359.39it/s]" + } + }, + "15c9cafd7e2e43548f1d26762b9e26f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1b200bebec8a43fa8f2a8fb9be9b64d6", + "placeholder": "​", + "style": "IPY_MODEL_d55dd11d79a54468980f37f40d4d37c1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "166e772557624d1bad5b3f093b4f991f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "16ccfa99b84c4b9abd8ca4cbbedfa94b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "16d282bd9e0642ebb9e2731ca6c78aa1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7784ced197a241ce8f72d0b75833f4d6", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_191050bf2ded413a901361c405f2bacf", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "16d5f1a63c72466f99b07550fa43ccda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17053bb3933543e69322a36217dd2d99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_14e7ebfb9a4f49998a14dc5abaaa5802", + "placeholder": "​", + "style": "IPY_MODEL_149e8cd40de74f6d923525b2e157aac1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "17301b11d79b48ff90855f239fcd32cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1749fb2f460f4b1d926e6a554d8645d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_48fc3741271344b695c79656379a6962", + "placeholder": "​", + "style": "IPY_MODEL_78c944b5ea5c4cdeb515d72c4eee6022", + "tabbable": null, + "tooltip": null, + "value": " 991/999 [00:02<00:00, 355.71it/s]" + } + }, + "18179e83577c4292a4b0c6264d39ebe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_aa449fc079084c5c855152f32565c1c3", + "placeholder": "​", + "style": "IPY_MODEL_a241f36ed23240d698bc228bebf55681", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "1817cfe1c4d045f38e2e022bf07a9b33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "183774794cb14f0e83961426f95f60be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "187ea56dade04dcf9af1d225eee8ac22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "18f9076b3e5c4efa9772a28815505070": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a0201e82ba4c49d08d45d4dc2a347490", + "IPY_MODEL_9f386df69e474796bb2042258c34baca", + "IPY_MODEL_52ca007a9acd4e478ae895caf88e50ef" + ], + "layout": "IPY_MODEL_2d3b7171c63f4f31aa5dbfd09655dfbe", + "tabbable": null, + "tooltip": null + } + }, + "190e7fa99dad4ca1b3656e8ca37da0db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "191050bf2ded413a901361c405f2bacf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "194308c29a03407fb4ce79fee27689aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "194cd83a23854561931c7f0c17fe6dba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ede85cad6ca14078b9c0f3f17c56b72b", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_493405a5fdc64ee7a63e698014ade54a", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "19892871612e45f6ac1c74d736c4cd2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_19cd0e26132149cebe67f05f53160bf0", + "placeholder": "​", + "style": "IPY_MODEL_bfa9cf76b606481e8c8e2c2e59cde948", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 362.15it/s]" + } + }, + "19a544bf339e4591b7dac54f64ee27a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "19cd0e26132149cebe67f05f53160bf0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "19fdb976dfaf42e8ac15f8a64ab307fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f0dfe5c6ff1147f98d8a9dd72055bf62", + "placeholder": "​", + "style": "IPY_MODEL_3afa6238e67243a99483f24042547e9b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "1a0dc3042dc7417b8ca7c20f1483b07a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d6830f03091b4122bf8a35adb6ef3b8e", + "IPY_MODEL_114b76517f2a4cb4aef8905cc5a7c01c", + "IPY_MODEL_d90671b9538c4f328aa0c02f47852a76" + ], + "layout": "IPY_MODEL_c61c49647d074eafbd5c1537449a6300", + "tabbable": null, + "tooltip": null + } + }, + "1a714d8e6df84f2b8bf9ee0425255741": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a8ca8069f06429e901b97416032595b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1af75f6281d645f2a31d3370ba5191f0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1af8a41f5c224b1e84dc8f3622533e49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7ff2061a53d64858a4966097763166cc", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a2e89e916dd04db9bfd98eee00a49147", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "1b157ac0610f4547bd00b2c6af8c929b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7e68d485ea5947429b58a31ce3fc975b", + "IPY_MODEL_4aadf2868d614294b42a068cbc3fb588", + "IPY_MODEL_ead10f9e718748628b5767cb4fa7f2f0" + ], + "layout": "IPY_MODEL_4dd9dc50534c410cb648a6a74fd3a74b", + "tabbable": null, + "tooltip": null + } + }, + "1b200bebec8a43fa8f2a8fb9be9b64d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b359157d85a4f4b8e7b457e72ef4b20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b3ce017807544c1b918460d658f8161": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6735bb8ce55b4d74a04e686baa7c3894", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e6b5834bbff443c1868868bd4f2da9c3", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "1bed2502aa8c4773b2b33950356f8124": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1bf227c4b0f642bab9bc53c6b7c7746a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c115f9d563f46c1ad7126da2121989e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1c1386ede9054a138b858dc1545ac542": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c33f01e4a684804bb4510536b3192cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1c58af823dc347839514e268e13910ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1c91299ac2294eccaf1a907f5b737b55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1cf274d7bb2f4275b01d4ef77e61d5cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1d0be30994da4e6798e43238564de104": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1d5faaed9b6c423e825a6a573133ae96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f0208ba48bac41138021991cc6fab964", + "IPY_MODEL_6977c8e870d6452fb31d45a02e09d113", + "IPY_MODEL_22db397a2f524b3e9a80885ea5887223" + ], + "layout": "IPY_MODEL_b6234c14756549c19227699e587fa72d", + "tabbable": null, + "tooltip": null + } + }, + "1d7d48573d2544f898b30176610f737f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1d8a9819f75143a792325a6a1e24c888": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1dc5f7a42c654151b547c0c19fb8e969": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1dfd6ca45c2648d4a76b5550135d6d12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d0d6bde4d189485294b8de5496d5badb", + "placeholder": "​", + "style": "IPY_MODEL_7ee8a152f1f64b188e96971d435a98b3", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "1e1926b7480247a28fd62e30ee03d627": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1e42e38b82d640d0b9bcaa8704520e26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1e55dde614fe458d843e223be3c29836": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1e9dc8e16b7442e8b4b6cbd2ef6bfd63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4604ef25e8484ff194b66b76c120ce9e", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4864c39e3a4847a6a2188ded9f10cbf1", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "1ebe8286cec04816be72266652031bea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1eef03ceabf1453ca62cc83a0cc21bd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1f0ecc10f2924d7ca0e7f1b104b9ed8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f2c2c11ebe2411582678f05e8b84732": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "1f3903e21d95428c97d968f475397059": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f5389db68f140c5973775f895865a38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1f53a34375ef477184c006926f62ac15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5365c82a72284806b762b8b39f871c43", + "IPY_MODEL_43b0d4154a0f427199b58b18edc1e713", + "IPY_MODEL_c175f1bc85e342d08c1dd6191c573ad0" + ], + "layout": "IPY_MODEL_c159c6407cff49d4b01c7854215df991", + "tabbable": null, + "tooltip": null + } + }, + "1f5b3ccaf27a481d8288195af1ec372f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c6ca16b56fb84b379b715bfe58d42734", + "placeholder": "​", + "style": "IPY_MODEL_4642f5293b54495da8257c656cffc423", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "1f6a6f57060e425da6a3efdc19c423b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1f8858dbcbf54a4daea0d698396e3d0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d3a2ef735174a10bee2b092d744275e", + "IPY_MODEL_0a320e2aa9eb4d89afaf9573cfcc5216", + "IPY_MODEL_f7829ae2c54e434f9a22005fc3dae290" + ], + "layout": "IPY_MODEL_69af71543bad4eca9e1fc061c2029a09", + "tabbable": null, + "tooltip": null + } + }, + "1f92f0e2d4ca49c58361bab50d093a43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b6f325f9cff2428aa16134558ef6514a", + "placeholder": "​", + "style": "IPY_MODEL_e86dd5462de24a36b290ae8edf850afd", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 355.33it/s]" + } + }, + "1fc31890d70149829ae5cf8efb6ff8ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "200cd5fcaec74d1bb60f371831b3926d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_02c55abb74db4006924148d88a1b3732", + "IPY_MODEL_76570316d23f43809be5856b491f1b0e", + "IPY_MODEL_edc8d6ee12a24ff0953ab319cebabee2" + ], + "layout": "IPY_MODEL_0d50d58d19724a3da81062fd5cb4b2c1", + "tabbable": null, + "tooltip": null + } + }, + "2037dae5bfa342adac4d8a9a4a822809": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1a714d8e6df84f2b8bf9ee0425255741", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_41c64b0d1781437499a7bfce03cd5ff9", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "204c00aaed314746bba9ba40a91e8dea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "205298a761d64130beb1f7385fe7a829": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "20addb377519462bb870e2a0d73d2545": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20c44e454ad94ca4b1ace2b8df13277f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "20e4029fe553444393f77ddd54abcb1d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "211a1375c2a64e3f8c8ce44c3d3896a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_22ba541fb40d41928f18d1e0d9d5aa38", + "placeholder": "​", + "style": "IPY_MODEL_83c7ad2db9f441ec97e8e2ea74cbba91", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "21501175081b4658b0822f3de54dba62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21731e6282aa41e49caa3e7262fc9eac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21cc9aa1a7664ff387d33fa6b0387b97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "21d4798508e247b2b35fb6cf9cb26e84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21df0c639e8440a1a27f799e8e2ab808": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7c90fc17341947eeabc79ee2cc52c82c", + "placeholder": "​", + "style": "IPY_MODEL_552d3ff7b22248b29a022782a04a8d6d", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 363.47it/s]" + } + }, + "22392eb6be534bfda8c55756fe6f84ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f2885b35b3db481fb368939ef8d508ce", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_21cc9aa1a7664ff387d33fa6b0387b97", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "2259bbe9ce08411a90c41377cc330c48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "226b394a4e034a7085a9f6305aa0e2dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "22b46da5eaa648dd88272a46a47b45ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22ba541fb40d41928f18d1e0d9d5aa38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22db397a2f524b3e9a80885ea5887223": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5ace9e3cea30467786e4bdb4f124bdb9", + "placeholder": "​", + "style": "IPY_MODEL_60dae5c3458c4f2490dc11353474cb58", + "tabbable": null, + "tooltip": null, + "value": " 890/899 [00:02<00:00, 367.21it/s]" + } + }, + "22e29211dfe1433793ee2567179c47ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22edab40b3914d349aa684b441522e7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4496b6b73d04e97ae3c28b8a03e85a3", + "IPY_MODEL_03ecefcfa09d4e8384ff3a8c933522bc", + "IPY_MODEL_f85bf7cfc17d422ebacea7480fee420f" + ], + "layout": "IPY_MODEL_6489a182240c431494fe27e8130d66e0", + "tabbable": null, + "tooltip": null + } + }, + "234835fc04c8441ea0afa11669ca3eee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2350789de04c456dac05fa481491a01c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "23544f3341004d698f38b4deb7bc262f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_22e29211dfe1433793ee2567179c47ac", + "placeholder": "​", + "style": "IPY_MODEL_5349dd59be974d739ca43d2befd9aa1b", + "tabbable": null, + "tooltip": null, + "value": " 492/499 [00:01<00:00, 364.27it/s]" + } + }, + "2384ab9a24d54e6ba660d724d28817ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23cbdff2e40843549fb4ecbf3eaccf86": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "23d38259eaad459380bc3c0f4040cec2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "23d407b0c7f74a0c85f8d771e72b3e4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b7de920b2f34f3e908182afe2e48467", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4408ec1204eb40538263096ca57b566e", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "23fdf25c2f62496cb2a46a757859536a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "241c4bc13fed4998b5523c3305c8a032": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f236ca780b3a4051a5992f7b138766f9", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_63d481c2220943d4b7153dbdbbd01710", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "2429619dc67346888ea2f4cc9564a4df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "242d249d623e4070998cfac6f5a7134b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "242e890a22f547c88a91c5ce4029d7a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "248ae7c615c14b5692b719abb04d9f44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "24951e7781bd4944bff41af1367209fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "24beb2defa5a4780ba4dc286afbac5e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fd933da07e674cddb3bcfa7d6eed1d67", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ea671a54605c4fd09b00a497010b515d", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "250b9961e7384b11b02d9fcfca4002ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4af90e24693b48a2b1887129dd8a5444", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4c6c3a4c1b494ba0b5fe71c4c54f4100", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "25239cb5cb2c40b3b9f88c91fa11bfcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "255b617c965b4b66a67b74ce249e7643": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "255c3cb7d7114ad2a8162710a4c06ccb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "256819f1cb0c41b29b446229cfbb74a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2582ee3ecb8f40a4a915e20cf76d3034": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_63f988873c6b4f44890eaf9a6878be72", + "placeholder": "​", + "style": "IPY_MODEL_5f431b448ddf4717bf79b3af34395635", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  99%" + } + }, + "258500a849bf40ce9144c54163b0f70b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "26adc41a09eb4024b14e199b23ee1268": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "26f6decc30544462b6b1487cbab83353": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "271d7987b90b4aa89a8d8df30897064c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da02205a6765423997b76576f7338f55", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e383b2024372464abe591908ce466a8d", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "272c6e13d6bf4f6d91e775b05ba90942": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "275651dc7c7f4b0a938d1f4bd41ecf88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27888a19cb4949a5955db0810887d01c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c7b23113d4dd49cbac62b15e6b6b4c4d", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ee94d2d7c18b4cb8810f14c855e1b2b3", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "283a5ae3c76046ee9011294a32e8d487": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "288fb6b917c54da3a47b962f1c563580": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7ecea0052a7a423db97e345dbf84e1b0", + "placeholder": "​", + "style": "IPY_MODEL_875113f8ea91403f82deffd8f48d689b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" + } + }, + "28d07f56029c49e59ccf4d2e358dd949": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fdb22cf92086422f87a8e173bf688af4", + "placeholder": "​", + "style": "IPY_MODEL_90e083fd95754dbca7d6f77d89a8aac9", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  61%" + } + }, + "28dde8a12e6f41848497e696498220fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "28feb5aac0de4bb490a80c66d22b8daf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "290c3be5b2ff4f278a639007eb07ecb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8154d81442eb4d539c6f9ae3f50d134c", + "placeholder": "​", + "style": "IPY_MODEL_f360e6312e5a4403863bb5ab1ba58459", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "2927b89096ec44288bc314528c24f65f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "2943c575311a4d638cfcf9ae49e165af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "296269f997e44a7081d95fa892581460": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "296b41f78d464b6d8a4c161f5cbcb8ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29ed50dabf784806aad2fe583689beaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "29f90c5cc8e747a0ab22a7d7e6f1817b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_85fb74ae8c21489198b8c41dd88ae229", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_abc32f9329d04aea9313056d069ae33a", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "2a2b49e661b84e3da9663b9390f47aee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2a3a3aa6cd8c4030b0db46dbff2b0422": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a92c6051e9849b9a9fdb69ea34e1a24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d9f6193af70e4e5ca8a48e246903e57e", + "IPY_MODEL_3f8945f19eb24ecaadcd3b7a33cafd0f", + "IPY_MODEL_5741df7837e041efb9c3f5272a447263" + ], + "layout": "IPY_MODEL_a5919878920d41b9b612514c78460e91", + "tabbable": null, + "tooltip": null + } + }, + "2abd18ce78f4431fb12a9068651c4590": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2ae5a381bb6546309986b04b77fa66d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2b1ce2ace64948fe9ebf69eae5e0230f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b45c72793a7403ea28982b692d23f36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b56a0ae92af48a285260a8d75e33180": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_16ccfa99b84c4b9abd8ca4cbbedfa94b", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1c91299ac2294eccaf1a907f5b737b55", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "2b5c7bbcce984435b1cf4c7029aec5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b7e2f2529d3499f9b631e8623105d46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2b89575e8d774ab289d214e70fc2ee7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2c7bfcf515ec40ecadafcd73332df488": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2c87e239c66c41b5ada589a29b583e6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ce5391336384dce9727c24bebd9cf25": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2cfead4a1407452fb847f9fafea1cc18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b732443cad9f4984b424f182f682f953", + "placeholder": "​", + "style": "IPY_MODEL_db506087065141bd9360f9d96b38e047", + "tabbable": null, + "tooltip": null, + "value": " 96/99 [00:00<00:00, 305.80it/s]" + } + }, + "2d3b7171c63f4f31aa5dbfd09655dfbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "2db019ca42504212a3233c8e22ba73fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2db07d5df0234a4cb27f2e7124271ada": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "2dd9ff6d11ad475da767edbca22fde12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2de0d0d0c2f44cf69f01ede67f25b002": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ff2cbdf66e284671a9581f68bbb8a921", + "IPY_MODEL_72040055ac464cc5ae07bbd7b8f42d85", + "IPY_MODEL_d7896b8022424b25b876bfaa8d644595" + ], + "layout": "IPY_MODEL_bf942b0276b340fe97e503e5c27eb4cc", + "tabbable": null, + "tooltip": null + } + }, + "2de0edc89e0048bda7a1a1f4ef9914e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2e14f23461204db0b7c93b459e20c2c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8bce25e51a4f433faf80447c79476251", + "IPY_MODEL_b7ee1f2389c4437f88556be7c5ca20e2", + "IPY_MODEL_42311ad84af442b3ac790c5ba3599136" + ], + "layout": "IPY_MODEL_9ba4c18dcdfc4ed092d98d9596488a6e", + "tabbable": null, + "tooltip": null + } + }, + "2e400fcf8095414483146e907b8025f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2e6558c07cf94401815a790e9d03dcaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e77c5df0a71486c84a989a79338aeaa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e92a5fc089c47d6923d68205e464c19": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "2ea4afc14a0046d198c3a249246a0246": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1f1056fbadf4ef28147dbb1ffd2f01d", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4d883c2504904f56a0248e68d05cce92", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "2ecfa31322e4498d9bdec04ab535b826": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2eee24513db1454dab4e04b9a357172e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e913215a765d411080f03f4b8e81a3c4", + "IPY_MODEL_271d7987b90b4aa89a8d8df30897064c", + "IPY_MODEL_37afdd026ed0419e996968bc98086562" + ], + "layout": "IPY_MODEL_a2366512a78941d9b2e293d1b6fb9c99", + "tabbable": null, + "tooltip": null + } + }, + "2f2549fe184843d3a55c2bdf93bdc1b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2f443fe263424ffba5ee02553a353f13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2f46ec3dd30a44c396902bcac10a18b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2f521620627248e7a4763ba2fde8b384": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f7a26e9f83e4eac93525a1577b6d1cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3a9b70bb24854e7a91dcd87058764675", + "IPY_MODEL_b5d92701d5044ff58eab8aed0910cf31", + "IPY_MODEL_7d46a86b30ac472e819e62c37d28735e" + ], + "layout": "IPY_MODEL_373fe519cbda46eab97207c5ddade7d6", + "tabbable": null, + "tooltip": null + } + }, + "2ffc7c0b499747e4859a41fc0a38a575": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3004d918d6194963b440047a854d88db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3050a1864c2b4706a1df4a5acad077cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "306a8f365de746fb96d9898459d2d185": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3185d1df4262486583b2cce2550716ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "318876949a134d929ae4b8120885c81c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "318ca864920f49929982f4de537a718e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31b52ee3bfe24ec5acdbee1e81fdb110": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_575d06df913048b8813a93292fc7a88b", + "placeholder": "​", + "style": "IPY_MODEL_bbe3b34d52d84712934297054f606fff", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "31c1eb4f79f4459b8125293e0af13fa8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8c149e832c2344a6a13d48e6ca6fba0c", + "placeholder": "​", + "style": "IPY_MODEL_9c6f49d105f14d058f4d932bcc35b4f7", + "tabbable": null, + "tooltip": null, + "value": " 73/89 [00:00<00:00, 359.10it/s]" + } + }, + "31ef47419b114e8e9cf1e4b2bb499aed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f52a08b1ab0e4a889394c121bc328c23", + "placeholder": "​", + "style": "IPY_MODEL_3d4b0780d431468593ed74d9030b494c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "32703beeb6c245ebac7648b6f48b6b3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "33051702a54a44748f00e635574ac265": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50b5e466f90d42ab9e7757c25c95660c", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fbd8b39aab8b4aa197a53ab2f71c37b7", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "3340bd63010b4136a2f321d8fa0c528b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7c00d2df8ba842e7bd57cc122101387e", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ca5ece859f934bc9a25c0452368699cb", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "338e3a49e59d48fbbe5f390aa05d123d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "33ae1b4cc09c4b64a69ea6923a1e5cdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_90afbda5a11b422bbb56317ebe3d3079", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_448dcec6565e4adbb4780924bfa54d7b", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "33fb7da188e444138750822e841e9b94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ad759a9a72194a3d82076c6601322a6e", + "placeholder": "​", + "style": "IPY_MODEL_3d9c5a4d9bff4bc09e5f36ea24a91544", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  76%" + } + }, + "3433e75bb0a540d883d4c418b00b7eb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "34481362e7574831b275eec75beea53d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_39591337b02f45baa78620129d8e1d34", + "placeholder": "​", + "style": "IPY_MODEL_8bbe0e3bc2bc4d59bd35c50e1ad706f0", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 351.90it/s]" + } + }, + "347e13716cac4865a6ff64467313aa11": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34a37b01cd294532a190c763be2a9da8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35490b4a6f6a4f5e847a86296f50a223": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "355304b3dc444dd3a780d3a03dd83d43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "35ff4862dad0431192a71f939e407761": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "361f5bf265d04118866d71ed7620197e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3622146964264166862fb39d34a8603c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_591910cf345e447196e7e7b5443cc2f3", + "placeholder": "​", + "style": "IPY_MODEL_f8e5e573da5347f0bc4ab60584d96b11", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  96%" + } + }, + "367fc8903c0647f88f4a2d046b19d517": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3702144afb8a47dfb8434f24c2e2fff3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "370b92e85a114488afa68e2ed2e2eb67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "371b6730e42945b884be6787e8846e12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fb3a17559779408db0db5cf5aaf39908", + "IPY_MODEL_b4eac108d5154f239da0f9bcf1ac232c", + "IPY_MODEL_a18aac23a7124bcfaeeabff25faa246d" + ], + "layout": "IPY_MODEL_3a7a3093b63340e29f3147b3593e4870", + "tabbable": null, + "tooltip": null + } + }, + "37386a1082ee44b2a296d3b4ecb95a10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "373fe519cbda46eab97207c5ddade7d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "37542e9940544689bb3e60fa786cd796": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "379aee897c594d88abf2047172f5e823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_66649f05b065413fa78b45be339edb0b", + "placeholder": "​", + "style": "IPY_MODEL_527a44be3b034127b1ca387a06a94d0c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "37a6e5822716413888908e9ec0048544": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b24435a8972d41b0b12249bf609467a0", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec0e4b7f69cd46db845078b2c870c8fc", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "37aa79bf53a44b3aba45d335e01a52c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37afdd026ed0419e996968bc98086562": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_574f8d9435724c9993185181b267d024", + "placeholder": "​", + "style": "IPY_MODEL_8913ae8f453543f1b3fbf11078e24087", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 352.60it/s]" + } + }, + "37d7a6888567468bad32bb5eeeb65d68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fde3ed00fb8744af93a13077c0fb90ca", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e9574faea46b46caac536226111891e3", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "38006af591a445688fbb47c5d6e5922e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "38083250e39b41a58a7b8e85ca3992f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3826cf494a024e14aba545a3a1f8a4ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38b3ebd4a29a485f8c3c97a953467b35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ac5149c12508461494509e9c89b33757", + "placeholder": "​", + "style": "IPY_MODEL_d26745479b864b0d84dff122455f8a28", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "38c5fea0d65e4c48aa473f2b762dd8f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d1b7b0961a1f485e9e7b06cdcd9e38fb", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2c7bfcf515ec40ecadafcd73332df488", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "38cc4a5c189b4f09bd10c8d6a0371964": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "393b37c2fb0c4f5dafcc3aea04998786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_211a1375c2a64e3f8c8ce44c3d3896a0", + "IPY_MODEL_0f7a69eb5e3a4dc39b672b48028fa0dc", + "IPY_MODEL_be76a31489ec454aa52489f09467f1b4" + ], + "layout": "IPY_MODEL_c3d0c68500644bae8d230838bc33bc9f", + "tabbable": null, + "tooltip": null + } + }, + "39493560285a4d9d98d4d7c4ac978c05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4ad85d1db6f743e5a3fe0e3e48bad247", + "IPY_MODEL_d9ebbe51225a409096250907c4c2dbf5", + "IPY_MODEL_9d4c58a0443e4f488e244a5ef5648f3c" + ], + "layout": "IPY_MODEL_3d0624c20cf142e1bcb2eb75b82c7de0", + "tabbable": null, + "tooltip": null + } + }, + "39591337b02f45baa78620129d8e1d34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "397918938ea243d4b59c809271032831": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39c042dcb8344985a71093a151c39b1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39d947fbc8bc4b239cfdb1a73869ec61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39fa82def7dd426888453f50351c4ebc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a279b0dabba46cbb4a5c98f0ab0dbda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a2adba6f0604289a9047d5785051169": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_296b41f78d464b6d8a4c161f5cbcb8ce", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e6680f705bb41a892ee641163892bb1", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "3a39e2f5dbab451e95d8290ef656261f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3dfe3f737fe74473994bb89b6894af38", + "placeholder": "​", + "style": "IPY_MODEL_6b081fd7b0d04dbd9a04c9d4ab595589", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "3a6c6ab14c9948da847a706bc8b1d7cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3a7667e3dcbc46f1aa9b38ad16250142": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a7a3093b63340e29f3147b3593e4870": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3a9b70bb24854e7a91dcd87058764675": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a7c73efd6e9e416c85de8edd3c3a1b3d", + "placeholder": "​", + "style": "IPY_MODEL_2350789de04c456dac05fa481491a01c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" + } + }, + "3aa0235ce0ab439fa30d148062415ea2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9f38f2848c3f4144a8f520ed3fe3313b", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_97b8cfee6364472aa65403ca8a153f9f", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "3ae9adb1174549d4ba0765594c21ef94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3aecb2a4a5404d4c838f0c826c3e76ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_21731e6282aa41e49caa3e7262fc9eac", + "placeholder": "​", + "style": "IPY_MODEL_d6d68e4b062d48e596a0c483fd5fda07", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 362.60it/s]" + } + }, + "3afa6238e67243a99483f24042547e9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3b0331d33a3646329714a68beaf02f9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3b4e76ff1f324cffbb30398aa59e8039": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3be06b1781ea4ae891c8f28bc5252120": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c29b17a7070414e8ddec58e9700afad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c45a4aa8ecf448591a298ab54ec7e85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c332cb2d0fd54601a8b7a7da97c30057", + "placeholder": "​", + "style": "IPY_MODEL_f88dc163254c4eb5a3a1a351ce5c07bd", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "3c46f81cd95a46348b7f8ee31dc6c6bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c5184bc80de492e9758c899b7600bc2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3cc5eaf75896480f8dff11ae8a727ed9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4ba4ec5563c04079871c7596c9085182", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a5fbfbb96bd940b6910b8461c35a803a", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "3d016971de9c440299b7164211015a44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3d0624c20cf142e1bcb2eb75b82c7de0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3d4b0780d431468593ed74d9030b494c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3d7e9659a6924121a9f24c8517430a0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3d9c5a4d9bff4bc09e5f36ea24a91544": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3dba60b55ea44aa0bea85513c47993fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4d0966075a484a5d9e5bc9edae8a303c", + "IPY_MODEL_c830aa04c7bc42c6acc672400ef68a90", + "IPY_MODEL_5957ab1f8c284af1ba39c954d66a50b1" + ], + "layout": "IPY_MODEL_6489ac4263e54beb93bcb3b7d91f786d", + "tabbable": null, + "tooltip": null + } + }, + "3dfe3f737fe74473994bb89b6894af38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e6cd27620f240f5a353061313b8b2bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e977a3b67614cfca6d57b2f08f7f3c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3e9ce915539a4db4a50e9139155833ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e9ee89d96554b6fb66cf469af778350": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_632ee97aff484e7e98a12b6192ff4a2d", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_87c85f7b73e34cb2bdc10b8417ceba0e", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "3ee76f44e6c4434cb060a79c2b7db9bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ef923e128e74249a7d86472b4cd4f04": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f037bc37ae64ff685d559b9f354f945": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8fcc39f231c4f45a0dae262217c173c", + "IPY_MODEL_3f8b3789c7e14edfb77ff1542051b71c", + "IPY_MODEL_2cfead4a1407452fb847f9fafea1cc18" + ], + "layout": "IPY_MODEL_35490b4a6f6a4f5e847a86296f50a223", + "tabbable": null, + "tooltip": null + } + }, + "3f0db553b10748598540cde60822e4f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3f36bab9c92040eb997e99f0ca05adaf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3f72018e6e5a46fbbebb5f8d402f7757": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5cb0afb8c6ad4f1c903c3d9c1fd112aa", + "IPY_MODEL_4185729cced148158d9ee7022e9c24da", + "IPY_MODEL_508495eeadbb49a69adb53cb186ab47e" + ], + "layout": "IPY_MODEL_3d016971de9c440299b7164211015a44", + "tabbable": null, + "tooltip": null + } + }, + "3f77a1911c514851a307fd95121fa807": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7dc6b4f355e1474799ad5666985523ca", + "placeholder": "​", + "style": "IPY_MODEL_b7e0716341f74ce181718c62e6d6c208", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  61%" + } + }, + "3f8945f19eb24ecaadcd3b7a33cafd0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_465adb28d55e46cb9ff8ae1fff0d1bbf", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5f12d6bf83394268a8915c4cee34a86d", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "3f8b3789c7e14edfb77ff1542051b71c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6c48de32f8348ff8b82a4c271e979c3", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3702144afb8a47dfb8434f24c2e2fff3", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "3fd50bcca0f145c4b6c8bb0ce641de02": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3ffeb5b78979448caab584c031387936": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "401bfe59ea1b43f081fb0fb8a0d2b5ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0b9d5860db89472eafcd3106dc31cdeb", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9aa3085b168c4a199a60a78c0d67dda4", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "40416f56012a46ed9ed4caa07e74d73d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f382db9ffd234b6f92338797a6a935da", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_74dd164326ee4953a184018186b6d9ea", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "40a68014923346b596b67ac0a4a193f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ddc6cfa799264926b85f97ad463641ce", + "placeholder": "​", + "style": "IPY_MODEL_4d8bbaa3db164dbaae4f3bddb386a035", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "40b2e835983b41fb9019401c0cbfe733": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40bcea7843324063a66654235af0b041": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40e2610cd39e4eeaa107c8784ab9323a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bdedb6a47a414802bd6698cd66f68ffe", + "placeholder": "​", + "style": "IPY_MODEL_efa9f0a8274b4fcf9b5370fda250fa30", + "tabbable": null, + "tooltip": null, + "value": " 37/49 [00:00<00:00, 362.56it/s]" + } + }, + "40e83a61461e46c3b706ba28f53ae68d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_089482d21d104b2091c8783589513134", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ee9292d2cf6246b482f4477a43083366", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "411e610baad644b98be37857503e8deb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_21501175081b4658b0822f3de54dba62", + "placeholder": "​", + "style": "IPY_MODEL_28dde8a12e6f41848497e696498220fb", + "tabbable": null, + "tooltip": null, + "value": " 663/699 [00:01<00:00, 365.20it/s]" + } + }, + "41799e8ed28f4b68a731b96a18ac2380": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_08925efaf2434c049defe77e47ce5277", + "placeholder": "​", + "style": "IPY_MODEL_78a732d26aa746149241725cfeeb95a0", + "tabbable": null, + "tooltip": null, + "value": " 985/999 [00:02<00:00, 364.36it/s]" + } + }, + "4185729cced148158d9ee7022e9c24da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_397918938ea243d4b59c809271032831", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b1587905de344c799dae783551080f27", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "41910242eca542acb39fbd32dd5dec5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "41a7596b7e514adea09b0dc106ab5e41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41c64b0d1781437499a7bfce03cd5ff9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "41e3306dc3e1434383b09f4837ad3d87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_af0e038f4de74c778a7304432a8ae7af", + "placeholder": "​", + "style": "IPY_MODEL_0b5a2fd13fcf4d4b8845daec25f835c2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "420ca366d3f84b8da696529b09e0fb7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "42311ad84af442b3ac790c5ba3599136": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bc851c576c0b4acca0cebbf5bd59eab2", + "placeholder": "​", + "style": "IPY_MODEL_2a2b49e661b84e3da9663b9390f47aee", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 355.69it/s]" + } + }, + "424ad561ee3b419db0c62ec97a88d8f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42a2de20706e40bb8b771300802429da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ee4ec24bdf0946429e1c92a8855fbf3d", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2429619dc67346888ea2f4cc9564a4df", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "42beb3b6bf184a8b9efc062bb0900394": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4307e9357abb49408c2ed54e1ba18eed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "433a22b03c454b08ae34cd8d5ead62fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "438825657f4449708138c78415a3e239": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b5fdda2c579a4cb4b17d2640ee0438f4", + "placeholder": "​", + "style": "IPY_MODEL_efd51c0a5a68438fa2197e5bafdbee2b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "4397aa33d8d94a79950ff8577dde46bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "43a7fa9e28d74fe6984d4bc3504f6d0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43b0d4154a0f427199b58b18edc1e713": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ead4f63dba604c7d921e0673959a38b3", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3ffeb5b78979448caab584c031387936", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "43b744746ec840cabe8da606987564e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_73f0c77a4a99477583c0f2e43d41cf7a", + "placeholder": "​", + "style": "IPY_MODEL_7957afe16ff442eb94130d2c2c2b52ce", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  94%" + } + }, + "4408ec1204eb40538263096ca57b566e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4465fe99e1114f66a001c2770fc06b22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c3d1a25262e345c784d032f453a9354d", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c93a404c543d45a3b916e20eb761958a", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "448dcec6565e4adbb4780924bfa54d7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "449499c388ca4b0f8d1d58604791529b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "449b77da8cb04157b3a1da8bd069de3f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "456fd90eaeb140628da39c6a96f6a7f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_39fa82def7dd426888453f50351c4ebc", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e9b55a0769c74814a9026ecbe81be643", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "45ad0a69cdac48eebb2fe1b7fb7e0b71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "45b0e4c66bc1441bb94932e73f7efb79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4604ef25e8484ff194b66b76c120ce9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4642f5293b54495da8257c656cffc423": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "465adb28d55e46cb9ff8ae1fff0d1bbf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4674e0570d2240518bca3a5d9727bcee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "467f22de5d254df5b5f472b9189b246f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4688f773988748efb9a575ca2855de8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "46aedaa7a7d34779837b93dcf3916e32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "46f4561da5f44b15a2f2ccd81e22474b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_16d5f1a63c72466f99b07550fa43ccda", + "placeholder": "​", + "style": "IPY_MODEL_12a1fd63340146cfaf0b672ecdbde2a2", + "tabbable": null, + "tooltip": null, + "value": " 996/999 [00:02<00:00, 361.46it/s]" + } + }, + "471fd00c254048959ba917062300abe4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fef876ee507e47a9839acc282b271da3", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e8ad29bc62e24720a81201de0fedd77c", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "47a7344563b841ca96d81b0baa41eff3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47c365b75b674b73aa3e5ec64a4dcaaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_65c751148d5942eeb004930ef5dcd52c", + "placeholder": "​", + "style": "IPY_MODEL_fb8ce4e9e22a475eb46cd0bd06bef548", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "47e2f57dad3c43518d3178fbc20e8bf1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47e3ac7c1d894d88a6fcc3d8806f5163": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47ea17bfc0014d8796cce6ce9acde73b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "480053998b7148deafbc6d956a9bb88a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "484eb3d61373421481e5e7cc01b38b03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4864c39e3a4847a6a2188ded9f10cbf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "486681b56e12490180a20aaf942c89aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3c45a4aa8ecf448591a298ab54ec7e85", + "IPY_MODEL_d5ec943cb5124a8aaa8424a839224d71", + "IPY_MODEL_e3d3e60602cd4b009782826748f9bdf7" + ], + "layout": "IPY_MODEL_6f832ffb2e7b482385c6de4ed139a7ae", + "tabbable": null, + "tooltip": null + } + }, + "48924959c23d4d958c4403bd38a9021a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48ec6902fd1643c6a101327124719189": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48fc3741271344b695c79656379a6962": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48fdae60bb784400a806e96dd5cb1294": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "493405a5fdc64ee7a63e698014ade54a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "495733dc2b184e1c8314e2a1d1f93d9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_15469e8d34ba4a6f80813b8992edbd61", + "IPY_MODEL_120ef5fdd51e4140bb835b9f80ae8b23", + "IPY_MODEL_1498e2383e4b4f8d862f6580681818e8" + ], + "layout": "IPY_MODEL_7d969ae053bd4f6f941d7b78b6429da8", + "tabbable": null, + "tooltip": null + } + }, + "49588eb8c2ab4615b4ca1692512c2a4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31b52ee3bfe24ec5acdbee1e81fdb110", + "IPY_MODEL_a6c41bd3946a46eb9f60e521964bde62", + "IPY_MODEL_21df0c639e8440a1a27f799e8e2ab808" + ], + "layout": "IPY_MODEL_c738d79f3d734fe6ba01ac5d9e67d82e", + "tabbable": null, + "tooltip": null + } + }, + "495cb904c28440eaae52abb0f40840f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9c17bfe97cc9428d86e3d378eee8b5d3", + "IPY_MODEL_d8b9fcda56134502b34c74e949c6d3e2", + "IPY_MODEL_586447328c1e47e4834ed69947125932" + ], + "layout": "IPY_MODEL_0c35d03637944273aea93bb69924aabc", + "tabbable": null, + "tooltip": null + } + }, + "496f2d2db8cd4d6c80a59944837c14e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a904c112f7594f0991e7b6c55bde148d", + "placeholder": "​", + "style": "IPY_MODEL_732c72fbd0ac4b9cb68bb1f77d88d4ba", + "tabbable": null, + "tooltip": null, + "value": " 666/699 [00:01<00:00, 307.96it/s]" + } + }, + "4981ad09da8f480e931bddd371b58d83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e24818dc9a7146d99f8348d040d3bb48", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e475f0eabf8d4677a3962363685f4b4d", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "49abcf503bcd43af9c7aa11f4e5a4220": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_63d2a279689449a8a22c76721f8634cd", + "IPY_MODEL_90bd6562f6b74386ac396b89f73f4429", + "IPY_MODEL_52bca6c6fec249689a35c66fdc986472" + ], + "layout": "IPY_MODEL_3b4e76ff1f324cffbb30398aa59e8039", + "tabbable": null, + "tooltip": null + } + }, + "49f8c028aac745818f39efa25ae920b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a306080bd6543b786e5313f8b89fd6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d7d7efe850c24bb0905c4466d5a21ea3", + "IPY_MODEL_7190e2d5f06b494191fac51ea03d3013", + "IPY_MODEL_bf456be96f914092b288ed4e48c561cc" + ], + "layout": "IPY_MODEL_b1bcd5ba576748079cbe5e5af0a7c26a", + "tabbable": null, + "tooltip": null + } + }, + "4a463b8084ad4227bdc5c39992a54d14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_eaa4d7ec8a9e49c7bc4bff6253aa5620", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a2a91473024c4d33913e49a2f8553979", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "4a58cf4738604b3fa8de0aa2929bab25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_92dde195120c458e9d2c1aa2049fdaad", + "placeholder": "​", + "style": "IPY_MODEL_5798190604ad47c5afe697b56f9ca3e9", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "4a599f2d385c4050a97f3d3226bd9823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3e9ce915539a4db4a50e9139155833ef", + "placeholder": "​", + "style": "IPY_MODEL_e87e5e1f902f41dcb9337631b9dd253a", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "4a927ddb4ad34b4d8d266a9e01e26162": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a9b2f8743c545ffb56f3cd00d26b3d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6bdd84f7701b4c47ae60dcfc0bf5b276", + "placeholder": "​", + "style": "IPY_MODEL_030a6f3fea224c8a82f8cdce0b082606", + "tabbable": null, + "tooltip": null, + "value": " 882/899 [00:02<00:00, 365.39it/s]" + } + }, + "4aadf2868d614294b42a068cbc3fb588": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c827f36c27a748fb81618a1d472d47ad", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_12a69feb639a449da46fcb07f90a585c", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "4acc29a2907645d7a33c08f06a804407": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ad85d1db6f743e5a3fe0e3e48bad247": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4e81b6befe5c45ee9836dcb4b35f5203", + "placeholder": "​", + "style": "IPY_MODEL_a71616c00a964b458de213c82e775098", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  82%" + } + }, + "4af90e24693b48a2b1887129dd8a5444": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b299d4ab0424a17821e153a9bf463ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4b5d39cb4bf24420a3590ed904673d3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b66b8c24ea04799aea8281d6bc5a43a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b7de920b2f34f3e908182afe2e48467": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b8f164f462e4a92ba374195a9317657": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4ba4ec5563c04079871c7596c9085182": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bb794dfe1744d55aa533efe8522ebdb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "4c440dd136144f749019ea43419ed99b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_af9caec5dc16457491cb6a0d858c965d", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_194308c29a03407fb4ce79fee27689aa", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "4c6c3a4c1b494ba0b5fe71c4c54f4100": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4c777c780ba240c7b58fd16d8b93b89c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c80b515bdb44d03958857081b7ff066": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ce4d1cb1d5040458b65d731b611043a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "4d0966075a484a5d9e5bc9edae8a303c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_37386a1082ee44b2a296d3b4ecb95a10", + "placeholder": "​", + "style": "IPY_MODEL_0060847d73ee4413b4770132aad88aa5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "4d188c46b28a445889c00508e232c54c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4d883c2504904f56a0248e68d05cce92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4d8bbaa3db164dbaae4f3bddb386a035": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4dd9dc50534c410cb648a6a74fd3a74b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "4e3fbb7d5cdb4fb6afbc384b86e3a3c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e5cdd3c399d4f3aafc93bef4b165447": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b90d8c5687c54433bad6171f9de544db", + "IPY_MODEL_6c1d48561201444f93ca459429f43c09", + "IPY_MODEL_34481362e7574831b275eec75beea53d" + ], + "layout": "IPY_MODEL_1f2c2c11ebe2411582678f05e8b84732", + "tabbable": null, + "tooltip": null + } + }, + "4e6ecc950a50421991cb48d9159de4c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e704ee25e654584b271ff9b52b07d3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0328cc2d5ff04b8498744959cf91e87d", + "placeholder": "​", + "style": "IPY_MODEL_f724380a346142a29ed9d12e57b047af", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "4e81b6befe5c45ee9836dcb4b35f5203": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f210a78887a49fdb4e21d136094f12b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4f2d86db11d94eb3892d396d95488b2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_83c133914ba64a9d8b30afbf629912b9", + "placeholder": "​", + "style": "IPY_MODEL_a255af21947f4e9da8d97d58890a1e1c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "4f50e952c8ee4dfb8727e51c61e0c095": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50adec0592e042138b9b1b30af560d5c", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4b8f164f462e4a92ba374195a9317657", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "4f8324d810b84b8e8d1368fe8de84d8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ab980fad443a46288c7c9020ebcb0454", + "IPY_MODEL_3e9ee89d96554b6fb66cf469af778350", + "IPY_MODEL_5f9e7af82521495394001a5420e06252" + ], + "layout": "IPY_MODEL_fdd0aa39b9ae426093657e1aa7180e8a", + "tabbable": null, + "tooltip": null + } + }, + "502b1a5c327e4b7988044c6fa14c9856": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5068dbbfa0de4c3ba0e259cd8333dc2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "508495eeadbb49a69adb53cb186ab47e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ade3073776f24e57aa8d4acd8b874822", + "placeholder": "​", + "style": "IPY_MODEL_7d917ed562794cc8ab9c188afa2a67cb", + "tabbable": null, + "tooltip": null, + "value": " 368/399 [00:01<00:00, 363.75it/s]" + } + }, + "509d9a27430844dea588744428b1d13d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4c777c780ba240c7b58fd16d8b93b89c", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_65a04c10d10640c79e62e4753df0f393", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "50adec0592e042138b9b1b30af560d5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "50b5e466f90d42ab9e7757c25c95660c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "510d7d38baa440afafb811da674ea47f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a6ec65736570464d8e2b338dba9e0d16", + "IPY_MODEL_cac9c307cd2049a5924027fdbeec1a59", + "IPY_MODEL_846975ec6484423a83c9a2e462d7d933" + ], + "layout": "IPY_MODEL_861fda405f12450ba53a25bfa6a8c240", + "tabbable": null, + "tooltip": null + } + }, + "5189b615168f4e809030de24721404dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4e3fbb7d5cdb4fb6afbc384b86e3a3c6", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a86ef9e81e8d447b96fe630b03dc3170", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "51c47b104e7a40a1a949ecdf24c4b360": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a599f2d385c4050a97f3d3226bd9823", + "IPY_MODEL_9c4a8b5471fb4b2baedb1b273d9434d1", + "IPY_MODEL_b0a58eae94e746e6b407403b1f19364e" + ], + "layout": "IPY_MODEL_a3359f583de74b66847fd6e657baa90c", + "tabbable": null, + "tooltip": null + } + }, + "51f50733a19b4ae6bbbd4420a8a08340": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "524fc73795d24111b5aa33045f0451dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_47e3ac7c1d894d88a6fcc3d8806f5163", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_df0b97971d1b4da784d13950b890ade1", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "527a44be3b034127b1ca387a06a94d0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "52a1c2c1ea774909bcde9522ae401efb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "52b006d485404abb9fc87e2998bea48f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "52bca6c6fec249689a35c66fdc986472": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e86ec14407794006a23d0ee3c05432dc", + "placeholder": "​", + "style": "IPY_MODEL_2ae5a381bb6546309986b04b77fa66d5", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 354.80it/s]" + } + }, + "52ca007a9acd4e478ae895caf88e50ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_876169a19ac84d64b4eaf6b05a42c538", + "placeholder": "​", + "style": "IPY_MODEL_b3a6f71884f8468687c7b586e2cc4d5c", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "530a0ee2ccf1401086c4cc131935356c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5343a2a9a0d145e9b772c8a2bd7f9c3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5349dd59be974d739ca43d2befd9aa1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "534afcd9dbed4095bfed7c1a8d2188ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5365c82a72284806b762b8b39f871c43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_47a7344563b841ca96d81b0baa41eff3", + "placeholder": "​", + "style": "IPY_MODEL_55ec04c16d644ac7be619b0e196f94fc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "53667d101b214cc3b3e40eb7a83c99a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53f6cf534d854995b66a138d82f38f05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "54531304ad2846d09aba8946da77c4a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "54a23534e2fa4254af596b2dd7122cd3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_255c3cb7d7114ad2a8162710a4c06ccb", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5e81a949fcf042fb998f8b7574d18beb", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "551aca7081014f0181381105695a83d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "552d3ff7b22248b29a022782a04a8d6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "55cfa4f5cb9f47e5baa83d7a7be485d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_794a33346ea242d7a5d23a41ad6f1741", + "IPY_MODEL_c77982866f444d27a8a2ea4f78e7e52d", + "IPY_MODEL_847dea10a3b24e3fb69fb7bc20600e97" + ], + "layout": "IPY_MODEL_a08e0f412404497a86f103832e131a4b", + "tabbable": null, + "tooltip": null + } + }, + "55ec04c16d644ac7be619b0e196f94fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5609fd0412844df48ad4d91d90137947": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cedce37f6c804bc587aacc4247b7172e", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_f8c2d3e5712d4833b35ff936ee65278f", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "568c091a7401479aba1cb5f80507730c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56d7f018ddae496abe2b614de1d71831": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_642aeba1abc24ad1875c6af58fc36115", + "placeholder": "​", + "style": "IPY_MODEL_1c58af823dc347839514e268e13910ee", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "57116be0cb5142c59d6bf15babd666c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57207c637ae4438c8db164c201510156": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5723301a17ea4558bbfca3fc8238d906": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ef77acf3363d4105934d4c294dd6e405", + "placeholder": "​", + "style": "IPY_MODEL_ae89dd9343ed4eb8814e10c101143c05", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "57305e3d08fa4b88b8002663ec22ce03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5741df7837e041efb9c3f5272a447263": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_64c00cf3334d4406bbe84b27a6213689", + "placeholder": "​", + "style": "IPY_MODEL_aa68cbb92bf6492a818c9be528955058", + "tabbable": null, + "tooltip": null, + "value": " 18/29 [00:00<00:00, 177.11it/s]" + } + }, + "574f8d9435724c9993185181b267d024": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5750eea408884bc29ffd6453c8f0d628": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c809df67f0f34d61932887bce3873785", + "IPY_MODEL_37a6e5822716413888908e9ec0048544", + "IPY_MODEL_71d61ef4180b4c498e69fdaf5deccb96" + ], + "layout": "IPY_MODEL_ea47ff2930e148d3b73975bbc39c56ed", + "tabbable": null, + "tooltip": null + } + }, + "575d06df913048b8813a93292fc7a88b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5798190604ad47c5afe697b56f9ca3e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "57ad35adfd6d41b49b52590309c70bbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57ef49ed4bb342de9c269a7b1ee5b8e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "584bc0ae47744194895f073406ef9ae1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "586447328c1e47e4834ed69947125932": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0252dffdfd354d2a8150275e552ebee0", + "placeholder": "​", + "style": "IPY_MODEL_4d188c46b28a445889c00508e232c54c", + "tabbable": null, + "tooltip": null, + "value": " 883/899 [00:02<00:00, 361.83it/s]" + } + }, + "58a2d0ed21224b8b8f9e43a4e6a8296a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "58a917f7215c4506b3c7e138ce9ebe16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7c4ab050194a4c5388ddac084f35b483", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c837adf34524549b4fd3ec0c3a4d530", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "58c83d49675b46db82266c261c036f86": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "591910cf345e447196e7e7b5443cc2f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "591c8fa5dd8740c4880a1fc9d020d148": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "5957ab1f8c284af1ba39c954d66a50b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4e6ecc950a50421991cb48d9159de4c8", + "placeholder": "​", + "style": "IPY_MODEL_cfa71870608b4ee39b049c352412631e", + "tabbable": null, + "tooltip": null, + "value": " 968/999 [00:02<00:00, 353.95it/s]" + } + }, + "598b6ac16039453495eae42adabdfc72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59ffdeae8b104c3fad63490531b041ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5a1ab7f2b2ea45bfb9e035d3099cec85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3e6cd27620f240f5a353061313b8b2bc", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_37542e9940544689bb3e60fa786cd796", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "5a2877cdbaf34cfdad1e409dc8f388e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5a378788140448aa8817ca9f5373d77c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a83d2632ae0e490fac1363f9af87a06c", + "placeholder": "​", + "style": "IPY_MODEL_a5407b0a1fa74f35b775c39905a804ae", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "5a8b523400a34072b4ae0e9563294207": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5aad76ecfafd4c83b448e4354f7c6f42": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ace9e3cea30467786e4bdb4f124bdb9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ad8c3961cae45b79690253e0124bae9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5b100a208c634c92acf8aa66b5c26f24": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ec34fa7c1738470ca8918e8677230b63", + "placeholder": "​", + "style": "IPY_MODEL_f7179f3dd1ca4bfa88f3e5f07e45a1dd", + "tabbable": null, + "tooltip": null, + "value": " 72/79 [00:00<00:00, 358.08it/s]" + } + }, + "5b1d8dbe3381429bb94ef4b4290349bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a58cf4738604b3fa8de0aa2929bab25", + "IPY_MODEL_63fff5f4ee614f37a6c514bd9092531a", + "IPY_MODEL_6415484c7f904f95a97273ca8d4e6249" + ], + "layout": "IPY_MODEL_23cbdff2e40843549fb4ecbf3eaccf86", + "tabbable": null, + "tooltip": null + } + }, + "5b98aa6d7b56442db773d661d1569276": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5bbb8ff7901d448eb0f10c47b06f2aa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8559cc625eef4b61b67169eb8b23cdbf", + "placeholder": "​", + "style": "IPY_MODEL_41910242eca542acb39fbd32dd5dec5e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  91%" + } + }, + "5bc1d89e46b14893a48308eda7ca8327": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5be3715daf394859a1394ae797100c33": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c32c6d8cf9042eda7fc17cdb3ef62a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c735f833cca42faa4e621addb0cbe62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f31493e347064f87a4c9af4d899c8338", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_d306a770b70d48ffb43ea52e248b885f", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "5c79d618639c487aadb061349b282f0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "5cb086b732d34ff49205154cd69967d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5cb0afb8c6ad4f1c903c3d9c1fd112aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a7667e3dcbc46f1aa9b38ad16250142", + "placeholder": "​", + "style": "IPY_MODEL_034be21e4dd04b29b643eaa1a9df3b11", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "5dc8a57043634ef88b6a71d614a0e786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8ae5a42f72d9481d9e484419eaf858df", + "placeholder": "​", + "style": "IPY_MODEL_0ff2fe8894674c18a3cb96ccb71fdf21", + "tabbable": null, + "tooltip": null, + "value": " 73/89 [00:00<00:00, 364.84it/s]" + } + }, + "5e13bb5c391c4e04a8ac6c0836bb1d8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08cf7d4ce5764be7a8d1a0d02365cd19", + "IPY_MODEL_8c3bc90181324aae887c0903fe049539", + "IPY_MODEL_73e7969992bc47719d5806d90e79fde6" + ], + "layout": "IPY_MODEL_1e1926b7480247a28fd62e30ee03d627", + "tabbable": null, + "tooltip": null + } + }, + "5e1de8a0d9a44b9a9e4289d02fd4b22c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e81a949fcf042fb998f8b7574d18beb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5e85fe84118c4f54a26cf2500c6af9a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5ea60f460a0e482182651d158dcb90f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d4c01029140741b78012d16261101438", + "placeholder": "​", + "style": "IPY_MODEL_338e3a49e59d48fbbe5f390aa05d123d", + "tabbable": null, + "tooltip": null, + "value": " 73/89 [00:00<00:00, 358.69it/s]" + } + }, + "5ec6217bd4bd4cd99aed4ef8f31f1cea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ef16409e8e043c7858b926c93f14394": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5f12d6bf83394268a8915c4cee34a86d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5f3946b11d7d4208add0431c3b69b31c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a9256530ab154816ab380145906b2153", + "IPY_MODEL_1190eeb17c3f46cbbf57fa9f36f7eca4", + "IPY_MODEL_c3c065a140994fc6ba7159dd86bc86a1" + ], + "layout": "IPY_MODEL_1af75f6281d645f2a31d3370ba5191f0", + "tabbable": null, + "tooltip": null + } + }, + "5f40d946a8204222abcaded839a22705": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dbfee872796e4aaaae3ad4b8394fc5c8", + "IPY_MODEL_5a1ab7f2b2ea45bfb9e035d3099cec85", + "IPY_MODEL_07847480e58a43e9ae3aa39669ceb5a2" + ], + "layout": "IPY_MODEL_fe3eb75225554eeba1353933ba8056c3", + "tabbable": null, + "tooltip": null + } + }, + "5f431b448ddf4717bf79b3af34395635": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5f9e7af82521495394001a5420e06252": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_248ae7c615c14b5692b719abb04d9f44", + "placeholder": "​", + "style": "IPY_MODEL_38083250e39b41a58a7b8e85ca3992f9", + "tabbable": null, + "tooltip": null, + "value": " 663/699 [00:01<00:00, 337.58it/s]" + } + }, + "5fdee5efd1e149aca7df20d34599cfb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "60238fd9fe024b299ca30723f24441f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a093f90a30e409cbe3152a63c84fc3b", + "IPY_MODEL_ce629a218e934721a444d3b9775ad415", + "IPY_MODEL_757021aeb7cc4645856216561db002f6" + ], + "layout": "IPY_MODEL_85b94dcab7e342e1bae99ed7893d2f09", + "tabbable": null, + "tooltip": null + } + }, + "606fb842ff3c4ffc8dddc6b281d2c021": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "60764445686346e4bdeb4c27828099ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "60dae5c3458c4f2490dc11353474cb58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "60de004e799749fab0fbfc4787f44ca2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ddcf80b54c448659d40eb246408ce2a", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c41a6a91c55047bdbf640b77fc219514", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "61179f11be4d4ad3980c87be54abc0e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "61c25ba14662472d92c40579c69b680a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61d65093718847e4be786be5d6afbeb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_88a1f1ef70e04a98b2ead0f5e45a18e8", + "placeholder": "​", + "style": "IPY_MODEL_0722cdd68ced4db8ac1516a4c8e0852b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "61eb86b98b4b4462b7b5a119f742b342": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e4b754781f6a4496828d6ab199a52e38", + "placeholder": "​", + "style": "IPY_MODEL_9c9f3b931b564870a41e892f72f302f3", + "tabbable": null, + "tooltip": null, + "value": " 72/89 [00:00<00:00, 356.57it/s]" + } + }, + "632bda88d5834271a6286cec2918ae51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c40be986db794cd58b1b129f5abc33fb", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fd3c7bb2465e454f8593489d99cc3047", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "632e3f3f886642ce9963971e663ea7d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9bdf6403cdd644e981afee06da78ef12", + "placeholder": "​", + "style": "IPY_MODEL_1c115f9d563f46c1ad7126da2121989e", + "tabbable": null, + "tooltip": null, + "value": " 664/699 [00:01<00:00, 358.97it/s]" + } + }, + "632ee97aff484e7e98a12b6192ff4a2d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63597cc6e8b7497bb97c1eb85e27dd4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "63c18b60c8b340ed8ea6b0e878cf2c69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_17301b11d79b48ff90855f239fcd32cd", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ad7c5164053345a3b53a2c2623993ebf", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "63d2a279689449a8a22c76721f8634cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b440836d41b84b47b178e910da6f4bf8", + "placeholder": "​", + "style": "IPY_MODEL_eeade946e22646f8bba9134ada76a58b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "63d481c2220943d4b7153dbdbbd01710": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "63f988873c6b4f44890eaf9a6878be72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63fff5f4ee614f37a6c514bd9092531a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7b2ac3cba0ea4d568f5e253b0a5b955e", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a847f8f9f9d2446cab5a97349d94fa7c", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "640aa044b6fc459899be2394f34c19c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8c0e1f905b24acdbfa568cdf6ee23d6", + "placeholder": "​", + "style": "IPY_MODEL_dc9cc67c03584932bb357cd6a440babc", + "tabbable": null, + "tooltip": null, + "value": " 371/399 [00:01<00:00, 365.50it/s]" + } + }, + "6415484c7f904f95a97273ca8d4e6249": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e2d8483a206d47aaa5e6bad0f8d44e54", + "placeholder": "​", + "style": "IPY_MODEL_7e537cd48d2c4608af66f8b4fa8d0e62", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "642aeba1abc24ad1875c6af58fc36115": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64328995eddd4d0b9edbe66b85afcb25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6489a182240c431494fe27e8130d66e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6489ac4263e54beb93bcb3b7d91f786d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "648e40aae32243c98e5cb2c6ce8899a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_044dfc445e544deaaf2bc132418a4ac8", + "placeholder": "​", + "style": "IPY_MODEL_be92533c011b48bea564987edff34fb3", + "tabbable": null, + "tooltip": null, + "value": " 73/79 [00:00<00:00, 358.82it/s]" + } + }, + "64c00cf3334d4406bbe84b27a6213689": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64e89c05702c45f3ac0558317f9f55d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6545213986fc431b9109dc7b527a4892": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_93d68c4c299f4422acdc5a59e02b2a0d", + "IPY_MODEL_e65de43cf3d845f5bd10fc9300d1c6ff", + "IPY_MODEL_e1507bee1c2e451ba1c83c5ec8ad1d67" + ], + "layout": "IPY_MODEL_c3f3bc3d118948e6807827c79cb1e194", + "tabbable": null, + "tooltip": null + } + }, + "654c7c69cb6141c987f854aed167344d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "65a04c10d10640c79e62e4753df0f393": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "65c751148d5942eeb004930ef5dcd52c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65e919da54cf4e05bbbc660cf3ebe80e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6615bf33ecc44a3da71c0b8e04ed8e6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cc840cc144ca42c48191a10a6b063c19", + "placeholder": "​", + "style": "IPY_MODEL_2f46ec3dd30a44c396902bcac10a18b5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "66649f05b065413fa78b45be339edb0b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "66a0d901d13d43acbb00cc373f5a1712": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "66d4058fafd64f4f950379b55767810f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f10a4f9987574935b5881e29722076ed", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_cf2dd5279b0f42dcbb04a738db897ae7", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "66e9d77edd784b41a9b35a676021b82d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_256819f1cb0c41b29b446229cfbb74a4", + "placeholder": "​", + "style": "IPY_MODEL_a14b675871374ff89a5051199843f1fd", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "66f50f81d94242a0a7c92f3c1acd7ce4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6731ba8c21bd448d98e16d3c3961ce34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6735bb8ce55b4d74a04e686baa7c3894": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67c50f30b4184b90bcb9d8d8da59ab00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "67d5c96dc9f5461b87330916c305b4b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "67dddc48ed9944748afc25e1d75ff05b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_18179e83577c4292a4b0c6264d39ebe0", + "IPY_MODEL_dc51427dd8fb4662adce820a83d7e7cf", + "IPY_MODEL_fe9a989ad2c64316bf1d9bd4fb2acf86" + ], + "layout": "IPY_MODEL_58a2d0ed21224b8b8f9e43a4e6a8296a", + "tabbable": null, + "tooltip": null + } + }, + "681f63faca654225afd68d7584bd114b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "68433c7916cc4732a85ef3ed3a3c6e56": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea9d152434c44c8e8f6bd7aced190103", + "placeholder": "​", + "style": "IPY_MODEL_433a22b03c454b08ae34cd8d5ead62fe", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" + } + }, + "684e2d618bd640bcb736ac88afab5769": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43b744746ec840cabe8da606987564e2", + "IPY_MODEL_456fd90eaeb140628da39c6a96f6a7f5", + "IPY_MODEL_6a2498e402084a28b935886762e0533c" + ], + "layout": "IPY_MODEL_f0163d82a0da4d8796c79376cb59ba60", + "tabbable": null, + "tooltip": null + } + }, + "6866a64e6a494644ae47e04fbe9567af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "68744436f7954d1d90fa5e02877e5c44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b59083f0ec09407dac286854bfb5f42a", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_cd23969b19544ac798b5505542a1b869", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "6915182708974687bc9a94f20011c6fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_96831a1dc2604a4aa68fd22e2ae3678b", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_f05c396f9638427b8ff97ae0cc1d304c", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "6965bd8b51a7496c83698123a8dc7478": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_61c25ba14662472d92c40579c69b680a", + "placeholder": "​", + "style": "IPY_MODEL_fbc2e2800f69459e9adc3a61700c71b5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  81%" + } + }, + "696da8126c1841168596b216aaf22aca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6977c8e870d6452fb31d45a02e09d113": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_53667d101b214cc3b3e40eb7a83c99a6", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c5845f14cd234dd88eb917236dc1ea7e", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "69af71543bad4eca9e1fc061c2029a09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "69cd31c536d9404d92d39b4d91549d19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b8fd8c018d42415ca5d867c6d5527f7b", + "placeholder": "​", + "style": "IPY_MODEL_dd21b7e9f2204483a81155c8c942a14c", + "tabbable": null, + "tooltip": null, + "value": " 73/89 [00:00<00:00, 357.64it/s]" + } + }, + "69cf359906074f75b6be86e700d6a417": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5723301a17ea4558bbfca3fc8238d906", + "IPY_MODEL_3aa0235ce0ab439fa30d148062415ea2", + "IPY_MODEL_15bacaaa83cc4d4d8178c97f3132e31d" + ], + "layout": "IPY_MODEL_0eff6eb6b0464bb99d15ed98f3c6528a", + "tabbable": null, + "tooltip": null + } + }, + "6a241b90ea934dfbb7681056ccf7de62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c6e0e8835ce34e21a3a4ddf1e0bd3c92", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9c49f5baec4442f89e280a9601e77095", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "6a2498e402084a28b935886762e0533c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_361f5bf265d04118866d71ed7620197e", + "placeholder": "​", + "style": "IPY_MODEL_b0f0e7ff3137469cb9bf38983eb4bc17", + "tabbable": null, + "tooltip": null, + "value": " 74/79 [00:00<00:00, 365.62it/s]" + } + }, + "6a2ef554ab7548399ae616331f89d96c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_66f50f81d94242a0a7c92f3c1acd7ce4", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_11b70c1674db47d8bae8cb991942250b", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "6a58bb9506034a7a9a236632ec663b53": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6965bd8b51a7496c83698123a8dc7478", + "IPY_MODEL_ee0f9c2fc55e47bc982180eee3863d3b", + "IPY_MODEL_08edb965c1a0472287c034112093d682" + ], + "layout": "IPY_MODEL_fb046d79c2604487b3f754060000488a", + "tabbable": null, + "tooltip": null + } + }, + "6a6c374cac544ee18a1f2313bbd4e9c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_75cf65f8b1ae4829bbceb7a5335622dc", + "IPY_MODEL_f123cf87de6b4d6986dfcb05a9aed4c0", + "IPY_MODEL_5b100a208c634c92acf8aa66b5c26f24" + ], + "layout": "IPY_MODEL_acc2541152ad42ad904a608103986423", + "tabbable": null, + "tooltip": null + } + }, + "6a9ed65510764abb955653db0e7ee27b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6b081fd7b0d04dbd9a04c9d4ab595589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6b46da5e916f4a58bc0f661400a2b780": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a08167146de343a98ad9b927545e880c", + "IPY_MODEL_ec127cbcbcd34525a3314895422c4a52", + "IPY_MODEL_884d7c1a96864130809764bbd0083ee3" + ], + "layout": "IPY_MODEL_834d1ac7aa9140828523cd26219a2788", + "tabbable": null, + "tooltip": null + } + }, + "6ba40fe467a245cf8236007fcb4ac620": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bb48ac44e154515865180e401f675f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6bdd84f7701b4c47ae60dcfc0bf5b276": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6be0780908634d7c9b6949f92f8a68b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6c0e153016a94e5a8300a31fad2acea5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6c1761f7fe5b4b9bb5db2466388b6f77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6c1d48561201444f93ca459429f43c09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f26f7cd6572344afb1df3d7dfb92f478", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_74ea3b1b795b4c86afabc8faabfeff66", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "6c637650a170405ebdf9b07b83ac83bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6c67410295884800a620f374d0d87830": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9045bf1e1a564f2c98790e37e57fdd70", + "placeholder": "​", + "style": "IPY_MODEL_a557bb53bc8642749f8560bb1c0985f5", + "tabbable": null, + "tooltip": null, + "value": " 898/899 [00:02<00:00, 323.11it/s]" + } + }, + "6c6a06ed639a422c8d8853ff59c4b1b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c9c1f760faa4bbf966682d22838e8b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6cafb5e03115448cbe616cef3548c178": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b842634c17bc430eb57f5c102cd9d838", + "IPY_MODEL_3340bd63010b4136a2f321d8fa0c528b", + "IPY_MODEL_3aecb2a4a5404d4c838f0c826c3e76ba" + ], + "layout": "IPY_MODEL_7c67bcdcdc9d46a2add5ed6fb6d1d760", + "tabbable": null, + "tooltip": null + } + }, + "6cb14dea20cf43ec9a6d6c8785c6cece": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6cbcef1a9aa448d3a5437ee29d76c770": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6cef078f27b34534aad4200d93d0f910": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6d340030ab4a4a5c99c2a10b79695418": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d3b327094f54cb48f6be0adc8283f2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6d3ccec4c42b402b996aa16bc7b9e2d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6d93a53d604049e08e5720f826739d68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6e31475de7ac433caaf1847bea3ee857": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fe78982fb27943eda4f9448dd2cafeac", + "placeholder": "​", + "style": "IPY_MODEL_1d8a9819f75143a792325a6a1e24c888", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  82%" + } + }, + "6e9bb6066bdf49c88efe29f269344687": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f52e4c4680d3402fb7e0db7394ebed75", + "IPY_MODEL_710c485400d14a848d0a2633265a55d3", + "IPY_MODEL_fd645dbd466f4d53857b74abc5891616" + ], + "layout": "IPY_MODEL_6c9c1f760faa4bbf966682d22838e8b6", + "tabbable": null, + "tooltip": null + } + }, + "6f832ffb2e7b482385c6de4ed139a7ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6f97f3f8078648f499ec2cf3e8d5c29e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fa895fc623a4058b809bffb7eb68519": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6fcdc0a474df4b66a1f7bd8ad0689c21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a7f1bb5697c346f7a6968f3ce65a49bb", + "placeholder": "​", + "style": "IPY_MODEL_0fe3cac99b2b4e26a5ae84ed7da87675", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "7021866ffaf74b48b951a0d457173c2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "70354077febd42db84a54d2bf0fc088f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_57ad35adfd6d41b49b52590309c70bbe", + "placeholder": "​", + "style": "IPY_MODEL_187ea56dade04dcf9af1d225eee8ac22", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "70619300dd114a6cae94b4d91ea55e11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "708974b8aecd47ef963493532093de01": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70f12c89e3af482c8bc0ec35da4cf5ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_19fdb976dfaf42e8ac15f8a64ab307fb", + "IPY_MODEL_8450f3c696e84e9bbbe7e90598139078", + "IPY_MODEL_c1cfd029710349e8bb2a6720ae411985" + ], + "layout": "IPY_MODEL_890eaf610af7408c8137b6a626d6012f", + "tabbable": null, + "tooltip": null + } + }, + "70fe49d3a40942d298e2504e40da90bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "710c485400d14a848d0a2633265a55d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d0378c9c2cc049c98bd4ff706f607836", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_75ea079f1da349299ee02309936d0530", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "710c80d0beee4809beba178b2fe4d62c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7190e2d5f06b494191fac51ea03d3013": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ca1248100bea43b1b7758f88369fff6f", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6cbcef1a9aa448d3a5437ee29d76c770", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "71ca441c651843b5ab369965e9fff8aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "71d61ef4180b4c498e69fdaf5deccb96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b12610ec0dd453a80680804659a950f", + "placeholder": "​", + "style": "IPY_MODEL_2ffc7c0b499747e4859a41fc0a38a575", + "tabbable": null, + "tooltip": null, + "value": " 885/899 [00:02<00:00, 337.23it/s]" + } + }, + "72040055ac464cc5ae07bbd7b8f42d85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_60764445686346e4bdeb4c27828099ae", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_283a5ae3c76046ee9011294a32e8d487", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "7249d35604ea4dd5ad74f2f58dc166b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "72977439fc354dbe81b6f7e1c051b209": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f708fdbc67674d22b9e64017ccd7571b", + "placeholder": "​", + "style": "IPY_MODEL_51f50733a19b4ae6bbbd4420a8a08340", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "72e11d753a6d4b7c8d70e84694cae823": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "732c72fbd0ac4b9cb68bb1f77d88d4ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "73587d88a7244b6bbb8e239ac3e479e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "73b020aab87b477f9258d472e64bc365": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9706dc5644ff4d2aba97ca170e545439", + "placeholder": "​", + "style": "IPY_MODEL_96837fd03fbf417bb0fc348dde7d1451", + "tabbable": null, + "tooltip": null, + "value": " 72/79 [00:00<00:00, 357.13it/s]" + } + }, + "73e7969992bc47719d5806d90e79fde6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_306a8f365de746fb96d9898459d2d185", + "placeholder": "​", + "style": "IPY_MODEL_b4b4001d21704f6d9722b7baad72dd26", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "73f0959e57604fdcb6042ddd4d37ac7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "73f0c77a4a99477583c0f2e43d41cf7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7421837a72f145c19e42660ab6d9b86a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "742c8964f8e345d882b4df12f377dd46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "745240905efa4d70951fed68152308a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0eb06dd7112d444185d8378055502557", + "IPY_MODEL_e755273fe7414af393da0e637c45cb6c", + "IPY_MODEL_da46a2589b244ea59a9ec83fa6a984a2" + ], + "layout": "IPY_MODEL_ac565eb12f424e02aaee1713f6830bd6", + "tabbable": null, + "tooltip": null + } + }, + "74526b09aae44f80b5578703630e8478": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74dd164326ee4953a184018186b6d9ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "74ea3b1b795b4c86afabc8faabfeff66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "750888b11d054b8abf80aba23ff3b7d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0126894018224984b563e8bcb410d05d", + "placeholder": "​", + "style": "IPY_MODEL_075e2975edcc4b538157b98ef22e4ad1", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 358.95it/s]" + } + }, + "752ad6e08aeb4421af878c91a4a38e5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "757021aeb7cc4645856216561db002f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a4ac22479ee04dc5bd7b96347fe9b5f1", + "placeholder": "​", + "style": "IPY_MODEL_b2becf330305494798229d046a60ffad", + "tabbable": null, + "tooltip": null, + "value": " 773/799 [00:02<00:00, 347.87it/s]" + } + }, + "75cf65f8b1ae4829bbceb7a5335622dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e6da76fcbbce45558f7d698926f56490", + "placeholder": "​", + "style": "IPY_MODEL_b5138b22c1ea49bab49fd56ccbca76e1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  91%" + } + }, + "75e0a5581429468dbb12e4f0523baf1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "75ea079f1da349299ee02309936d0530": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "76570316d23f43809be5856b491f1b0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_67d5c96dc9f5461b87330916c305b4b0", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_bb04a2592724400c93e6c968f22b30b2", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "766f2422c6c14704bbea3fe759a29a31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "76afe945b755482abc45b5e568995a6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "76d7332ffd45486faf2b251a563ff724": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_449499c388ca4b0f8d1d58604791529b", + "placeholder": "​", + "style": "IPY_MODEL_cf8d72605023472e93d5fafcb932a082", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 358.81it/s]" + } + }, + "76ef200b1a9b445eab8e50b258b02c92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b57c7ff42f9b49c59a427dcd06f42710", + "IPY_MODEL_7c9002d84e45477ea8410b43ca31a599", + "IPY_MODEL_c6ec5a672f2d4b289c1d6319fb96229c" + ], + "layout": "IPY_MODEL_6731ba8c21bd448d98e16d3c3961ce34", + "tabbable": null, + "tooltip": null + } + }, + "7712728c73144961a6cd32df93caba86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9cd1c8f5093d4cf88234a53abb8aa455", + "IPY_MODEL_a75e3652be124a3886c39a30a2610599", + "IPY_MODEL_8b8d9060127e4c3e8087e7c0079d42d7" + ], + "layout": "IPY_MODEL_6c1761f7fe5b4b9bb5db2466388b6f77", + "tabbable": null, + "tooltip": null + } + }, + "776ad76aba9548ff87f451346ffe5e6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da2bf1956cc545ca8cc0d568b915d4b4", + "placeholder": "​", + "style": "IPY_MODEL_d12c7f9fe8f949c5a413058f75fe9159", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  93%" + } + }, + "777b18b6acfa4d4fb711d81c6cb170f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6fcdc0a474df4b66a1f7bd8ad0689c21", + "IPY_MODEL_80322a1fd9f645e3aadaba8e90df699a", + "IPY_MODEL_0b1fe2bfddaf432e8689aa62f0b7a7fe" + ], + "layout": "IPY_MODEL_96b58127d2384a8eb80a48c4250a3a29", + "tabbable": null, + "tooltip": null + } + }, + "7784ced197a241ce8f72d0b75833f4d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77caf9bc83a4425eb8a2307926eeb99c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "77db329df29b48f1b21c6585dd05d327": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f49954c8368243b8978265281ec86c4d", + "IPY_MODEL_0f52b0bb14a2422f8255a59614352d54", + "IPY_MODEL_31c1eb4f79f4459b8125293e0af13fa8" + ], + "layout": "IPY_MODEL_12a6aba1c13649ce83260edd991ec1cc", + "tabbable": null, + "tooltip": null + } + }, + "77e08403607348f9938f0d851c8d537e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "782e9f59991440fb8f2bb58d0540321b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "78a732d26aa746149241725cfeeb95a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "78c944b5ea5c4cdeb515d72c4eee6022": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "78e58664ca7f48c388cab93235a0af8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_84ac33aab3f241d1b6754c7ee4107e3f", + "IPY_MODEL_03620e83b2a54d48974c46c04af50a11", + "IPY_MODEL_1098bcfa42894381a07c5883849c651c" + ], + "layout": "IPY_MODEL_205298a761d64130beb1f7385fe7a829", + "tabbable": null, + "tooltip": null + } + }, + "7947d8d88c46427286df33834c3e2dd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "794891c9744b49379f3238ab072dac41": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "794a33346ea242d7a5d23a41ad6f1741": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b66b8c24ea04799aea8281d6bc5a43a", + "placeholder": "​", + "style": "IPY_MODEL_b3acf684348f4c47b64c350a910a0a2e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "7957afe16ff442eb94130d2c2c2b52ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "79afd59b049d4f68a33a08106aeb2c48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b787c0b07c794e05a349801dcf28d706", + "placeholder": "​", + "style": "IPY_MODEL_c707f497aec24165a474eb94658f6fc6", + "tabbable": null, + "tooltip": null, + "value": " 72/79 [00:00<00:00, 355.67it/s]" + } + }, + "7a29cd41f64543d18867f9502d4a962d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7ac5a584492f495e974cf19baf7a1aeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3ef923e128e74249a7d86472b4cd4f04", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_77e08403607348f9938f0d851c8d537e", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "7b2ac3cba0ea4d568f5e253b0a5b955e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b747ac67ff84204a5c2350d8d444226": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7b84cd45efd545269a100538c34053a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5a8b523400a34072b4ae0e9563294207", + "placeholder": "​", + "style": "IPY_MODEL_226b394a4e034a7085a9f6305aa0e2dc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "7bb460b12a98451bb3dbb3b6d28548ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bc2fed1bee6438e920225161b18814e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f16b839c197540b68f4a0909fc868037", + "IPY_MODEL_9556773e77fe4c63a47ff11b9883c366", + "IPY_MODEL_76d7332ffd45486faf2b251a563ff724" + ], + "layout": "IPY_MODEL_72e11d753a6d4b7c8d70e84694cae823", + "tabbable": null, + "tooltip": null + } + }, + "7c00d2df8ba842e7bd57cc122101387e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c4ab050194a4c5388ddac084f35b483": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c67bcdcdc9d46a2add5ed6fb6d1d760": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7c9002d84e45477ea8410b43ca31a599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_35ff4862dad0431192a71f939e407761", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3433e75bb0a540d883d4c418b00b7eb4", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "7c90fc17341947eeabc79ee2cc52c82c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c97f6da49da42e2841c10de0d670f26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7d46a86b30ac472e819e62c37d28735e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b064303dfefd4611a09a96fd21a6992d", + "placeholder": "​", + "style": "IPY_MODEL_1eef03ceabf1453ca62cc83a0cc21bd5", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 359.53it/s]" + } + }, + "7d7bce6493db49089fffafc473535096": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d917ed562794cc8ab9c188afa2a67cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7d969ae053bd4f6f941d7b78b6429da8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7dc391b4eaf84a27b73ef0ec43783a73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7dc6b4f355e1474799ad5666985523ca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e42c9deb4a04e2b8e5a2fac4026125d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0f5169afe8414d4a8f7c9c1aac77f5dd", + "placeholder": "​", + "style": "IPY_MODEL_9896b94d5451419b9d5900bbd2417237", + "tabbable": null, + "tooltip": null, + "value": " 295/299 [00:00<00:00, 353.71it/s]" + } + }, + "7e4e24585c9349c498bbd58bbdcc7254": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e537cd48d2c4608af66f8b4fa8d0e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7e60587e2bc741fcb53a6dc45634470c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7e6680f705bb41a892ee641163892bb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7e68d485ea5947429b58a31ce3fc975b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c9353fd9741940e889fdf60256660075", + "placeholder": "​", + "style": "IPY_MODEL_fb53cda1dcbb4485a5f473d418e06873", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  61%" + } + }, + "7e98fef5de29464fbe91fc48112fafe6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7eb7be66cbf4447d89f755bfb089b7fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7ecea0052a7a423db97e345dbf84e1b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7edcd082516745a38fdae77e062f1046": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ee8719625d4475aa482c5280db4eeab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7ee8a152f1f64b188e96971d435a98b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7f06dba9e4614c7fa0a1281402b452ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "7f3f013e4dc14d80a97c057101e02673": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0e483bb542e74106a15fecceb78d8e19", + "placeholder": "​", + "style": "IPY_MODEL_32703beeb6c245ebac7648b6f48b6b3a", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 364.24it/s]" + } + }, + "7f52da9b70204a2c964d3b7c9bb5f22c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_424ad561ee3b419db0c62ec97a88d8f7", + "placeholder": "​", + "style": "IPY_MODEL_b581ba9b94144c68ad527b841857aea1", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 361.34it/s]" + } + }, + "7f6f33376b1c49e788ac42fda6bdaed0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fa4aebf91ec47cc946851ec20bb3700": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_108807822cd546bf8582c7b3ffaa5591", + "placeholder": "​", + "style": "IPY_MODEL_ce4f691af9a5482a85053f82ccc34097", + "tabbable": null, + "tooltip": null, + "value": " 779/799 [00:02<00:00, 366.48it/s]" + } + }, + "7fb372d2c2ec46db80e769762abf4355": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ff2061a53d64858a4966097763166cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "801232451ebe4578b71c34528b8d964c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9408b864baaf4818a43ef0598306fdcd", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c44ee9e2b04a4fd4916ccfd57ce4c005", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "80322a1fd9f645e3aadaba8e90df699a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d200bdfc11a547a9b3f6b6bb42e203b1", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_d0a6d8f78e6942078f7c54f5c1032dea", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "8034dffc34894238b3dec4bc38dd602c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5c32c6d8cf9042eda7fc17cdb3ef62a3", + "placeholder": "​", + "style": "IPY_MODEL_e6fcb0ec556241c59d66ea22eff8e79d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "80353b3841a949cbbc38cbe60c077b34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "8037175b913c4f648cafdf3e2b750b0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "80ddd1f13b0240718cd9b6c4385d8651": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "80e99db76e4b45d395684a813a3e4d22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8154d81442eb4d539c6f9ae3f50d134c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81b10617b323434fa5dd09739c4c4d61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81df698edc2c4823b2461273e8a11cf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ac25dc86d6944604a7e82a5dde8e249e", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fd77ef4f213f4512b115fefe337a1d5f", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "81f3e1633f0f4edc90a2916d81b9bb01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_49f8c028aac745818f39efa25ae920b2", + "placeholder": "​", + "style": "IPY_MODEL_1f5389db68f140c5973775f895865a38", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "820ddcf258474b2789909b69fedfde3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "829902796e8447b6acf6ab15b5c29da8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "82a647356d4e49f1a8e1b5406a0a5083": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2a3a3aa6cd8c4030b0db46dbff2b0422", + "placeholder": "​", + "style": "IPY_MODEL_f3b1fddd95784c8e8d50ab319f0ba4e4", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "82e2592a59b447fd83029863de4344a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "830304cced404723afbaeb3a9c1ca6ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c469f539c05241afaa7884fa3a7b7f60", + "placeholder": "​", + "style": "IPY_MODEL_e24ac04487814b3794160710ae12f57e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  63%" + } + }, + "834d1ac7aa9140828523cd26219a2788": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "837ebb58052b4b5ca947beed81390d5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "83c133914ba64a9d8b30afbf629912b9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83c763d3fb93490d984f60bd34f86485": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a2856414241546efa76c6089226d15cf", + "placeholder": "​", + "style": "IPY_MODEL_5ef16409e8e043c7858b926c93f14394", + "tabbable": null, + "tooltip": null, + "value": " 37/39 [00:00<00:00, 360.21it/s]" + } + }, + "83c7ad2db9f441ec97e8e2ea74cbba91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8428758943004c549e3fc8419c1af086": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8450f3c696e84e9bbbe7e90598139078": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b7caebf7e06740b7a92a0441bd573cee", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_01364955bb824efb8419965b3dfd964d", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "846975ec6484423a83c9a2e462d7d933": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_23d38259eaad459380bc3c0f4040cec2", + "placeholder": "​", + "style": "IPY_MODEL_bb118a11d49d42ccb562978a4c384d2e", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 355.43it/s]" + } + }, + "846a4ca0e4b94aa2b72291e83e43d66a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1dc5f7a42c654151b547c0c19fb8e969", + "placeholder": "​", + "style": "IPY_MODEL_10d96c31ac9040508c5e8a8efdf66596", + "tabbable": null, + "tooltip": null, + "value": " 590/599 [00:01<00:00, 364.00it/s]" + } + }, + "847dea10a3b24e3fb69fb7bc20600e97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_22b46da5eaa648dd88272a46a47b45ae", + "placeholder": "​", + "style": "IPY_MODEL_cddcb3dbed6f4acabdf059adde3e8f58", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 356.87it/s]" + } + }, + "84ac33aab3f241d1b6754c7ee4107e3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2c87e239c66c41b5ada589a29b583e6b", + "placeholder": "​", + "style": "IPY_MODEL_feb30733b37147bbab8f0a130c92bd05", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "8555452d88a24c1b83130071b4002e3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8559cc625eef4b61b67169eb8b23cdbf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85a29b2dd1634be7ad97027681f62fb0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "85b2264e560f4dfaa64ee77e144a3d20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85b94dcab7e342e1bae99ed7893d2f09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "85e2e887e88b4cfebb0f86edb7894d9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e3bed6d60cf248a7b2113d6c27fb7e0f", + "IPY_MODEL_241c4bc13fed4998b5523c3305c8a032", + "IPY_MODEL_640aa044b6fc459899be2394f34c19c0" + ], + "layout": "IPY_MODEL_bfc68748100d4a7ea463cc6f96ab8087", + "tabbable": null, + "tooltip": null + } + }, + "85fb74ae8c21489198b8c41dd88ae229": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "86179bf42ffd4e2fbcdb69876bf2430b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8618600335164da2b72cb3db70edf98c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7b84cd45efd545269a100538c34053a1", + "IPY_MODEL_d0341cebf53b49658928e1655458a47a", + "IPY_MODEL_cd4ce0cefe9a40889d773a60ceb7f1fc" + ], + "layout": "IPY_MODEL_45ad0a69cdac48eebb2fe1b7fb7e0b71", + "tabbable": null, + "tooltip": null + } + }, + "861fda405f12450ba53a25bfa6a8c240": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "86b75f8cad5a46d7b97da5b62b2b89bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "870ec753188f458a8fea1d2cf7cfc7f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "875113f8ea91403f82deffd8f48d689b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "876169a19ac84d64b4eaf6b05a42c538": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87c85f7b73e34cb2bdc10b8417ceba0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "884d7c1a96864130809764bbd0083ee3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3c29b17a7070414e8ddec58e9700afad", + "placeholder": "​", + "style": "IPY_MODEL_4397aa33d8d94a79950ff8577dde46bf", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "88a1f1ef70e04a98b2ead0f5e45a18e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "88e8abe3eca34410a1941bbc595713c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "890278b32a154b97894ee3a225e1c05f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "890eaf610af7408c8137b6a626d6012f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "8913ae8f453543f1b3fbf11078e24087": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "894a2956493e4c9d8223a99014b5ae4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "897daa6ded384f73b2907776c86a1823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3a39e2f5dbab451e95d8290ef656261f", + "IPY_MODEL_37d7a6888567468bad32bb5eeeb65d68", + "IPY_MODEL_846a4ca0e4b94aa2b72291e83e43d66a" + ], + "layout": "IPY_MODEL_e99de2c5cff54076b8f33791a6e0b19c", + "tabbable": null, + "tooltip": null + } + }, + "89c1205e28c94a9fbbc1e67a716a2aa2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_40a68014923346b596b67ac0a4a193f4", + "IPY_MODEL_60de004e799749fab0fbfc4787f44ca2", + "IPY_MODEL_c803853185e04f32b8898930aed802a0" + ], + "layout": "IPY_MODEL_936ae29026c648c4829f91a3a5da492e", + "tabbable": null, + "tooltip": null + } + }, + "89c15203ace248d1a02a02594b023db4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5fdee5efd1e149aca7df20d34599cfb4", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6c637650a170405ebdf9b07b83ac83bb", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "89ea9978425b4528b483a06a93762e8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "8a18ffdbb37642bba04ea599e5538b68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f6b6db4ea31f43b58e492efff1cec142", + "IPY_MODEL_2ea4afc14a0046d198c3a249246a0246", + "IPY_MODEL_47c365b75b674b73aa3e5ec64a4dcaaa" + ], + "layout": "IPY_MODEL_1d7d48573d2544f898b30176610f737f", + "tabbable": null, + "tooltip": null + } + }, + "8a50b8decf89476dacacb5953b63da39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c435008f3f544ad2b2494ea4170ff841", + "placeholder": "​", + "style": "IPY_MODEL_b85b758d39c247b9b76d9f25c11b1f66", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  95%" + } + }, + "8a8a5222321946e38de69b513db84a8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8ab9fcd143bf46919318a3bb77aa3e1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8abc7f6b14c64c9ab6f07badd64512a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8adda907b62942fda7c7558e4baf9a94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1a8ca8069f06429e901b97416032595b", + "placeholder": "​", + "style": "IPY_MODEL_f93db39f5b0446a78c10220f2692d6ee", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  73%" + } + }, + "8ae5a42f72d9481d9e484419eaf858df": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b28cd8da30042dd967bf6d6251cd42e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b8d9060127e4c3e8087e7c0079d42d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_01276c00429544beacdb0a66b06f7676", + "placeholder": "​", + "style": "IPY_MODEL_0d9da7bf768a43f7ad3e279838a2bfce", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 360.88it/s]" + } + }, + "8b95af3fe6ec49b6a2f3d7edfd4172a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8bbe0e3bc2bc4d59bd35c50e1ad706f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8bce25e51a4f433faf80447c79476251": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_74526b09aae44f80b5578703630e8478", + "placeholder": "​", + "style": "IPY_MODEL_242e890a22f547c88a91c5ce4029d7a2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  73%" + } + }, + "8c0be0ea0e614e60be0712b34b142bd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8c149e832c2344a6a13d48e6ca6fba0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c34e8f0b5774faca5891cd7a6239b88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b007ff62602a4a2d876b1efe3afd3673", + "IPY_MODEL_81df698edc2c4823b2461273e8a11cf1", + "IPY_MODEL_bfe66051460d4067b93fc18294eb6d9d" + ], + "layout": "IPY_MODEL_7e60587e2bc741fcb53a6dc45634470c", + "tabbable": null, + "tooltip": null + } + }, + "8c3bc90181324aae887c0903fe049539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_484eb3d61373421481e5e7cc01b38b03", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_efd8dadbee4b4526a15eaea1489d3dca", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "8c5a8111755e4b539ef3fd3c91590b87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1f5b3ccaf27a481d8288195af1ec372f", + "IPY_MODEL_d0f8a3ab51954f1391a21336ef2ed4e3", + "IPY_MODEL_97628bce7bd9417a9ec12c82bdbea666" + ], + "layout": "IPY_MODEL_b645e5a2abfe49fe96ce6bb537d91029", + "tabbable": null, + "tooltip": null + } + }, + "8c71d8800d2440a78faae5237b85fda1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8c837adf34524549b4fd3ec0c3a4d530": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8cb772963b0d4f9b97d1b497b81e5787": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "8d04f608e3b7419199e4900abbb061bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_da1789b52e594f8bad8427cd64a63db9", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3e977a3b67614cfca6d57b2f08f7f3c2", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "8d3a2ef735174a10bee2b092d744275e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_92d9178b9a524148bc2fd57aff6dbbb9", + "placeholder": "​", + "style": "IPY_MODEL_2f2549fe184843d3a55c2bdf93bdc1b6", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  51%" + } + }, + "8d75ea1674e44d96af14247550d590cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8dd11c0ad50b40f4b046b2dc9192f1a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b3333a3f2d242eeab9043467a135115", + "IPY_MODEL_66d4058fafd64f4f950379b55767810f", + "IPY_MODEL_632e3f3f886642ce9963971e663ea7d8" + ], + "layout": "IPY_MODEL_272c6e13d6bf4f6d91e775b05ba90942", + "tabbable": null, + "tooltip": null + } + }, + "8e26c83d6073406a852eac2034d65be6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8e644957f81047b8add0fc659615700e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5cb086b732d34ff49205154cd69967d6", + "placeholder": "​", + "style": "IPY_MODEL_ad5b8dd38022462396e962705dd1e98d", + "tabbable": null, + "tooltip": null, + "value": " 885/899 [00:02<00:00, 363.23it/s]" + } + }, + "8e8f1de56f6647fbb3b5e7b86bf0a295": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8ef6227139994ec2b5879afe2a1294e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31ef47419b114e8e9cf1e4b2bb499aed", + "IPY_MODEL_d0a9f7554f944deebad0e0f494e0b340", + "IPY_MODEL_1f92f0e2d4ca49c58361bab50d093a43" + ], + "layout": "IPY_MODEL_4ce4d1cb1d5040458b65d731b611043a", + "tabbable": null, + "tooltip": null + } + }, + "9045bf1e1a564f2c98790e37e57fdd70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "905333b503af4652a03ec8ce2d49e7d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9068eeed80a84a5e993cde7355727880": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_77caf9bc83a4425eb8a2307926eeb99c", + "placeholder": "​", + "style": "IPY_MODEL_932453791cb642afb3696fe3f0e4b006", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 363.28it/s]" + } + }, + "90afbda5a11b422bbb56317ebe3d3079": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90bd6562f6b74386ac396b89f73f4429": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_04989c6b1d6d487786b5cc6185bbe9f3", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5b98aa6d7b56442db773d661d1569276", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "90be65850b384b7ea507a284a2978b86": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90bf76864db94a7b94fc22af8067ae8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e38c530f121746cb8a0bff30f7eff6e4", + "IPY_MODEL_0bc9005f8c1c4516afe4fa8b208fb1eb", + "IPY_MODEL_d6327d5992a946208d63034400da112d" + ], + "layout": "IPY_MODEL_52a1c2c1ea774909bcde9522ae401efb", + "tabbable": null, + "tooltip": null + } + }, + "90d8fb3e006047c7ad1f67747bc12d8e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90dbd87ef8644cb6ad32b3cc8e1955b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "90e083fd95754dbca7d6f77d89a8aac9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "91ce479998ce4fc3915fa56338763eae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91ff649d1d1840c18123da3d8b384fb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b773b548738b4088aa5fa5cb905b3583", + "placeholder": "​", + "style": "IPY_MODEL_66a0d901d13d43acbb00cc373f5a1712", + "tabbable": null, + "tooltip": null, + "value": " 592/599 [00:01<00:00, 364.18it/s]" + } + }, + "923a8f8e39e944b28f48d80793a06540": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "92d9178b9a524148bc2fd57aff6dbbb9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92dde195120c458e9d2c1aa2049fdaad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93182494b09f422e987faef2c4484f13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "932453791cb642afb3696fe3f0e4b006": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "936ae29026c648c4829f91a3a5da492e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "93d4bffa867445508dfeb08eb7cddac1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "93d68c4c299f4422acdc5a59e02b2a0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dab13f6588d94e1ea06facae48a345a6", + "placeholder": "​", + "style": "IPY_MODEL_b24a0b8a75424936bebf06a5cd6a54be", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "9404db936ef347d19c7938726480dab1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9408b864baaf4818a43ef0598306fdcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94a88227eb484887a751d951a09a7dca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "952c36ed6d154fd9bc2778f7d7a157a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1349031413004abd8f5755f9de81d47c", + "placeholder": "​", + "style": "IPY_MODEL_2db019ca42504212a3233c8e22ba73fc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  74%" + } + }, + "9538d61e6b184a778e6385a5b7c98257": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_794891c9744b49379f3238ab072dac41", + "placeholder": "​", + "style": "IPY_MODEL_12fe1abb25ea47dd9478f195b718974d", + "tabbable": null, + "tooltip": null, + "value": " 587/599 [00:01<00:00, 359.48it/s]" + } + }, + "9556773e77fe4c63a47ff11b9883c366": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_467f22de5d254df5b5f472b9189b246f", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4f210a78887a49fdb4e21d136094f12b", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "96710220aae5465183fb43b5fe5b265e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3ae9adb1174549d4ba0765594c21ef94", + "placeholder": "​", + "style": "IPY_MODEL_53f6cf534d854995b66a138d82f38f05", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 358.45it/s]" + } + }, + "96831a1dc2604a4aa68fd22e2ae3678b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "96837fd03fbf417bb0fc348dde7d1451": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "96b58127d2384a8eb80a48c4250a3a29": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9706dc5644ff4d2aba97ca170e545439": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97628bce7bd9417a9ec12c82bdbea666": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_08a4c1252645469aab123b139f486913", + "placeholder": "​", + "style": "IPY_MODEL_20c44e454ad94ca4b1ace2b8df13277f", + "tabbable": null, + "tooltip": null, + "value": " 73/79 [00:00<00:00, 363.07it/s]" + } + }, + "977a91b067e24994a38c9c3890cab2cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d7b5bc789ea846109c2966954f666e5c", + "placeholder": "​", + "style": "IPY_MODEL_73587d88a7244b6bbb8e239ac3e479e4", + "tabbable": null, + "tooltip": null, + "value": " 482/499 [00:01<00:00, 364.77it/s]" + } + }, + "9788a286e84a4450acdeaf4a5ff306b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ba78799094b347d78d70dbcd8fee7d85", + "placeholder": "​", + "style": "IPY_MODEL_64328995eddd4d0b9edbe66b85afcb25", + "tabbable": null, + "tooltip": null, + "value": " 894/899 [00:02<00:00, 367.36it/s]" + } + }, + "978a701e7e5b42f78ad268e2ea7e3e36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "97b2f9188b224719a6a73a98964a6c31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "97b8cfee6364472aa65403ca8a153f9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9896b94d5451419b9d5900bbd2417237": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "98eb1189f08a4fd0a1ca39dd50787b21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "98f250094b874a2781e0ebe476b27b85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0bcedd3d0a1647868942cd10b21bdc7a", + "placeholder": "​", + "style": "IPY_MODEL_367fc8903c0647f88f4a2d046b19d517", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "994772e07dd54886860bd3ff52f44310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9994d11815364fe0a205a24457276f26": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a093f90a30e409cbe3152a63c84fc3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c01615d310244dc793bf18a43f795ea1", + "placeholder": "​", + "style": "IPY_MODEL_db9eb05a179a4dc5bf699ba7982c2815", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "9a5b64d269de4e92b26f073ad1b9fbca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a7df1ecff3049c494786d0df894f99c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_13f0f814d19d4c7eb8c2a28a50175477", + "IPY_MODEL_33ae1b4cc09c4b64a69ea6923a1e5cdb", + "IPY_MODEL_a3ebc9da861e4af3bce977449342ab1d" + ], + "layout": "IPY_MODEL_a63c9f8d6d7045919becc483c1dae9b8", + "tabbable": null, + "tooltip": null + } + }, + "9a96669e38c449f698334512a42575d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_09d89a1d3bb64595a47d85dfecf2fe5e", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_551aca7081014f0181381105695a83d4", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "9aa3085b168c4a199a60a78c0d67dda4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9ad7aafb378f449f8cf7293f196a5510": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b12610ec0dd453a80680804659a950f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b1e34eb82bb4740b46ba721b4da8101": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9b6c83606a7c4d85a8c9b22505d783e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_00c2ce8137c8400d8a248a035dec5b14", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_deae5739c6514cabad9f0e09b6584099", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "9b6cf4af509b4bebbc25c8e5cd713190": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ba4c18dcdfc4ed092d98d9596488a6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9bc6ebd59e4f4005a21c9446fdccd958": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f4a024683a44416e984e25d202634705", + "IPY_MODEL_801232451ebe4578b71c34528b8d964c", + "IPY_MODEL_c34f858766a54c92be832fc10138950f" + ], + "layout": "IPY_MODEL_cc7500408b274601a1c97553d24c9900", + "tabbable": null, + "tooltip": null + } + }, + "9bdf6403cdd644e981afee06da78ef12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c081ca24bd74659a65bb864ad786a9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cac5a08da220495296d54d267dc6e766", + "IPY_MODEL_4465fe99e1114f66a001c2770fc06b22", + "IPY_MODEL_e217203ba78544ad9e74b8ef8a85b907" + ], + "layout": "IPY_MODEL_183774794cb14f0e83961426f95f60be", + "tabbable": null, + "tooltip": null + } + }, + "9c17bfe97cc9428d86e3d378eee8b5d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_aa687bd844e94b2d9e9eeb0b143582d1", + "placeholder": "​", + "style": "IPY_MODEL_9e1577f43049420cb456edb60bcef748", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "9c49f5baec4442f89e280a9601e77095": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9c4a8b5471fb4b2baedb1b273d9434d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_033245f09b9b44d89d4679e28ace6ef2", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ef552844b99341d79625224f4bd6e572", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "9c6f49d105f14d058f4d932bcc35b4f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9c73221770084648ab4a5ec0804196a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9c8f38be56c64ae4b038567f96db6500": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_870ec753188f458a8fea1d2cf7cfc7f4", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9f988a48438441588eed8c5dbc246898", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "9c9f3b931b564870a41e892f72f302f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9cc5dae3a64c4eadbb102b500f243165": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9cd1c8f5093d4cf88234a53abb8aa455": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1bed2502aa8c4773b2b33950356f8124", + "placeholder": "​", + "style": "IPY_MODEL_5e85fe84118c4f54a26cf2500c6af9a1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" + } + }, + "9cdf78cc7bd642e0b9d7982209392e22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9d1b19421f184307b1b8d776ef202cf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_90d8fb3e006047c7ad1f67747bc12d8e", + "placeholder": "​", + "style": "IPY_MODEL_2f443fe263424ffba5ee02553a353f13", + "tabbable": null, + "tooltip": null, + "value": " 37/59 [00:00<00:00, 364.00it/s]" + } + }, + "9d4c58a0443e4f488e244a5ef5648f3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e2a7e797571a442aa6856ae6fae6e8c6", + "placeholder": "​", + "style": "IPY_MODEL_29ed50dabf784806aad2fe583689beaf", + "tabbable": null, + "tooltip": null, + "value": " 73/89 [00:00<00:00, 361.77it/s]" + } + }, + "9d6ddcb3aa0c486983263fe5b2c7cc37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9da369ada4dc421f8645b288fa83aa94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e5404053ec2a45bc9ccaf5b92e178632", + "placeholder": "​", + "style": "IPY_MODEL_1210f02976414c3789c0b00cbe9ff17d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "9ddcf80b54c448659d40eb246408ce2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e1577f43049420cb456edb60bcef748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9e23e688de2c4c849d2c4bb43bec6f1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "9ea39809e1ef4d01adf80f76422ba7d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9eee605f30bc412aa48d9ff2fe8683ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e5abefda2b3f4d6098a926782d4fa807", + "IPY_MODEL_4981ad09da8f480e931bddd371b58d83", + "IPY_MODEL_8e644957f81047b8add0fc659615700e" + ], + "layout": "IPY_MODEL_5c79d618639c487aadb061349b282f0b", + "tabbable": null, + "tooltip": null + } + }, + "9efbcffed0d640ec95650f6b44597dac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f386df69e474796bb2042258c34baca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7fb372d2c2ec46db80e769762abf4355", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_157298b29fda4f85b5d13b1be48369b9", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "9f38f2848c3f4144a8f520ed3fe3313b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f775967506145889b3f58b2f8077818": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_318ca864920f49929982f4de537a718e", + "placeholder": "​", + "style": "IPY_MODEL_65e919da54cf4e05bbbc660cf3ebe80e", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 357.69it/s]" + } + }, + "9f988a48438441588eed8c5dbc246898": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9fc95f811a0643df88cf59a88f77e44e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f6369d1079f0474aa29bf88fc2759164", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_258500a849bf40ce9144c54163b0f70b", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "9ff75787e6594279980931eccff786d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0201e82ba4c49d08d45d4dc2a347490": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b28318c6531440e9af69ab17fbbd6bfe", + "placeholder": "​", + "style": "IPY_MODEL_23fdf25c2f62496cb2a46a757859536a", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "a0223917d2f4457e9e236222d44b7f3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d4a21d30e2e742bdbc11e4b2d113052d", + "IPY_MODEL_3a2adba6f0604289a9047d5785051169", + "IPY_MODEL_e487871e3b3a4357b3f3d3f5fc58c837" + ], + "layout": "IPY_MODEL_7a29cd41f64543d18867f9502d4a962d", + "tabbable": null, + "tooltip": null + } + }, + "a0473d4a6bbe4cc3be07eaceb2d6a35a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3622146964264166862fb39d34a8603c", + "IPY_MODEL_2b56a0ae92af48a285260a8d75e33180", + "IPY_MODEL_ae95193431e547b1b936a5a2f839464f" + ], + "layout": "IPY_MODEL_a70308a855784318b8f3a1c887098fb8", + "tabbable": null, + "tooltip": null + } + }, + "a0522f22ebdb4197b1b7dbaa37799733": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a06fa235eb974b11919167dc583e4409": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a08167146de343a98ad9b927545e880c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_053c536d46334f02bcc1be9ebad98279", + "placeholder": "​", + "style": "IPY_MODEL_6be0780908634d7c9b6949f92f8a68b2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "a08a766751ea409fae236604550a3568": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a08e0f412404497a86f103832e131a4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a14b675871374ff89a5051199843f1fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a18aac23a7124bcfaeeabff25faa246d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ee14622cd15749439820c42a23e60fbd", + "placeholder": "​", + "style": "IPY_MODEL_ebd16efb451e4bf8845891e94faa9b56", + "tabbable": null, + "tooltip": null, + "value": " 775/799 [00:02<00:00, 361.34it/s]" + } + }, + "a1930905d7944c0abc37bab11d78cb62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b6cf4af509b4bebbc25c8e5cd713190", + "placeholder": "​", + "style": "IPY_MODEL_a7306245921c4ea0bc79a6c073fe078c", + "tabbable": null, + "tooltip": null, + "value": " 369/399 [00:01<00:00, 361.08it/s]" + } + }, + "a2366512a78941d9b2e293d1b6fb9c99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a241f36ed23240d698bc228bebf55681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a255af21947f4e9da8d97d58890a1e1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a2856414241546efa76c6089226d15cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a29586ff07d8448f93ce88eb1d9b3405": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1dfd6ca45c2648d4a76b5550135d6d12", + "IPY_MODEL_4a463b8084ad4227bdc5c39992a54d14", + "IPY_MODEL_496f2d2db8cd4d6c80a59944837c14e3" + ], + "layout": "IPY_MODEL_2927b89096ec44288bc314528c24f65f", + "tabbable": null, + "tooltip": null + } + }, + "a2a1c7b5e4424ec293b9081596e5fe06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2a91473024c4d33913e49a2f8553979": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a2e89e916dd04db9bfd98eee00a49147": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a3359f583de74b66847fd6e657baa90c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a336db13ecb1496f889be30676adc46c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0aa5d390f8884c5483607403b475ec17", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_905333b503af4652a03ec8ce2d49e7d0", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "a33a001b159349fab9741fd08f1e74dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a340a170e0214eda8adb7d7e13f46c29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a355e395f10040dfa002089118841303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a0522f22ebdb4197b1b7dbaa37799733", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e8916415b5ef40c68f39362bb2fa14c3", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "a35d6c88b5a740008757e625a41371e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a3ebc9da861e4af3bce977449342ab1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d8091fc330484f93ae0428ae85d8afbb", + "placeholder": "​", + "style": "IPY_MODEL_3050a1864c2b4706a1df4a5acad077cb", + "tabbable": null, + "tooltip": null, + "value": " 478/499 [00:01<00:00, 360.56it/s]" + } + }, + "a436284c4732400e9b8c8f443966b7fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4ac22479ee04dc5bd7b96347fe9b5f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4f115a5e1434f97955e0ff7264f8afa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a51b4cbcf05f4046a4623771929e5cf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_17053bb3933543e69322a36217dd2d99", + "IPY_MODEL_4c440dd136144f749019ea43419ed99b", + "IPY_MODEL_83c763d3fb93490d984f60bd34f86485" + ], + "layout": "IPY_MODEL_d7ffdc53aa764cab94c829dcce0a5f90", + "tabbable": null, + "tooltip": null + } + }, + "a540492a97c542419a05fd5d1d10a971": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ae7a1716b0a14b43924414469bb3c47e", + "placeholder": "​", + "style": "IPY_MODEL_b76df83bba1b4424a8e29b89fe9d031d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  98%" + } + }, + "a5407b0a1fa74f35b775c39905a804ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a54c5dd9bbc64f5b97c32c37a0211929": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a2a1c7b5e4424ec293b9081596e5fe06", + "placeholder": "​", + "style": "IPY_MODEL_9c73221770084648ab4a5ec0804196a8", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "a557bb53bc8642749f8560bb1c0985f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a590d9e986e24dd2b7e9e847555d6cae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_af2706de906e4a54aae9cc27e50fe862", + "placeholder": "​", + "style": "IPY_MODEL_c9a6a71bfcfd4a75bb716c66ecd4b731", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "a5919878920d41b9b612514c78460e91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a59245fd27c84e1fa9f32f9568ba2884": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a5bb1cdab18b4fdc996a5f2118d037a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5f7a5c23d0f4a1facc5a14763124c8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a5fbfbb96bd940b6910b8461c35a803a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a63c9f8d6d7045919becc483c1dae9b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a661b4edaa614a9cb46f7306f1d46a1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a682d84851a44defa0ccc688483ab9cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_15c9cafd7e2e43548f1d26762b9e26f4", + "IPY_MODEL_54a23534e2fa4254af596b2dd7122cd3", + "IPY_MODEL_bc61a09d90384286a1c6029f74dadf4a" + ], + "layout": "IPY_MODEL_c0b8ed31060546adbec7628e74034b36", + "tabbable": null, + "tooltip": null + } + }, + "a6c41bd3946a46eb9f60e521964bde62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_afa1c174b740462695db3650f5469963", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2abd18ce78f4431fb12a9068651c4590", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "a6d07bdeb8914e1ca87a5a78ce2dcc9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a6ec65736570464d8e2b338dba9e0d16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8037175b913c4f648cafdf3e2b750b0f", + "placeholder": "​", + "style": "IPY_MODEL_63597cc6e8b7497bb97c1eb85e27dd4e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  61%" + } + }, + "a70308a855784318b8f3a1c887098fb8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "a71616c00a964b458de213c82e775098": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a7306245921c4ea0bc79a6c073fe078c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a75e3652be124a3886c39a30a2610599": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_09896c1482f9411ead4ab9b1e53033df", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6cb14dea20cf43ec9a6d6c8785c6cece", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "a7931ba0d9754c17bcdb4e91c4d5a5db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fc553ccf6a0b427aa55c04996ced8786", + "IPY_MODEL_524fc73795d24111b5aa33045f0451dd", + "IPY_MODEL_09758263bc224d42ab0415b16f594e8d" + ], + "layout": "IPY_MODEL_80353b3841a949cbbc38cbe60c077b34", + "tabbable": null, + "tooltip": null + } + }, + "a7a2d91e2baa48c3a34cbfa0e37672f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7c73efd6e9e416c85de8edd3c3a1b3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7f1bb5697c346f7a6968f3ce65a49bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a83d2632ae0e490fac1363f9af87a06c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a847f8f9f9d2446cab5a97349d94fa7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a86ef9e81e8d447b96fe630b03dc3170": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a8e1874938074203ac81d478fd1e201d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ca6ad57cfb5941159f5f1c6b055c5183", + "placeholder": "​", + "style": "IPY_MODEL_ad1c29fe56904195b160834cba04a0c7", + "tabbable": null, + "tooltip": null, + "value": " 479/499 [00:01<00:00, 363.69it/s]" + } + }, + "a904c112f7594f0991e7b6c55bde148d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a90d8a4ab2b54abab95419fb2e366e60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4b9e8510735418b98f75fffef37a5db", + "IPY_MODEL_1b3ce017807544c1b918460d658f8161", + "IPY_MODEL_c3b352168ac64b7da2c4d78a0fc9e3ca" + ], + "layout": "IPY_MODEL_1188553b527c416585862b84380cf028", + "tabbable": null, + "tooltip": null + } + }, + "a9256530ab154816ab380145906b2153": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6f97f3f8078648f499ec2cf3e8d5c29e", + "placeholder": "​", + "style": "IPY_MODEL_1fc31890d70149829ae5cf8efb6ff8ac", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  93%" + } + }, + "a9262ac2952b4d09b5a52834601ee8e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f5c1186dec3e4d24afea411ce9e31051", + "IPY_MODEL_e1436fcb37b4445d913bf68df979444c", + "IPY_MODEL_69cd31c536d9404d92d39b4d91549d19" + ], + "layout": "IPY_MODEL_9404db936ef347d19c7938726480dab1", + "tabbable": null, + "tooltip": null + } + }, + "a9d0b4ec984d4c318c970a4757df9d13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07d17c41ab2d4770bb6098c26363e34b", + "IPY_MODEL_40416f56012a46ed9ed4caa07e74d73d", + "IPY_MODEL_977a91b067e24994a38c9c3890cab2cf" + ], + "layout": "IPY_MODEL_80ddd1f13b0240718cd9b6c4385d8651", + "tabbable": null, + "tooltip": null + } + }, + "a9ed73f78a6a49b3b2f36919f6e0cc18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a54c5dd9bbc64f5b97c32c37a0211929", + "IPY_MODEL_509d9a27430844dea588744428b1d13d", + "IPY_MODEL_a590d9e986e24dd2b7e9e847555d6cae" + ], + "layout": "IPY_MODEL_b1201d00bc18498ab9894655b8ff4101", + "tabbable": null, + "tooltip": null + } + }, + "aa449fc079084c5c855152f32565c1c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa687bd844e94b2d9e9eeb0b143582d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa68cbb92bf6492a818c9be528955058": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aa9fd23d74804b7699edb91ca672e49c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aaf48d038b0045e697d3f60c20e8e1f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_28d07f56029c49e59ccf4d2e358dd949", + "IPY_MODEL_89c15203ace248d1a02a02594b023db4", + "IPY_MODEL_ce60bfb1c1a842e7b793f3562da27f9b" + ], + "layout": "IPY_MODEL_ef0f9b18e54546fd8ada11b2118939ae", + "tabbable": null, + "tooltip": null + } + }, + "ab7ee20281f048f4b741aef6e2a4720d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ab980fad443a46288c7c9020ebcb0454": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c63f98624a854b9fa5db5fbaf96bdcf4", + "placeholder": "​", + "style": "IPY_MODEL_190e7fa99dad4ca1b3656e8ca37da0db", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "aba0cb800126442a8fb0da38129ac004": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "abad997f6dc64f9c94624291452d15c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ed0e4971bd794b4bb3060657b66b8fff", + "IPY_MODEL_9a96669e38c449f698334512a42575d4", + "IPY_MODEL_bd92dc4e293a46588004a9a1352214de" + ], + "layout": "IPY_MODEL_df6fab5a0c22465b8e1ff3ab2829117a", + "tabbable": null, + "tooltip": null + } + }, + "abc32f9329d04aea9313056d069ae33a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ac25dc86d6944604a7e82a5dde8e249e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac2e5f9254b5480cbe979aece5461b9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac5149c12508461494509e9c89b33757": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac565eb12f424e02aaee1713f6830bd6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "acbf1653664b439483f72287bb24dd6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a540492a97c542419a05fd5d1d10a971", + "IPY_MODEL_c21eb73ba424423e86846d7447dc2b49", + "IPY_MODEL_db0dcff9dd144d069a54398862e9c984" + ], + "layout": "IPY_MODEL_4bb794dfe1744d55aa533efe8522ebdb", + "tabbable": null, + "tooltip": null + } + }, + "acc2541152ad42ad904a608103986423": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "acc62cb85534464da464081371d494dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "acd256a9ac3b4b2abeb614cc7400cb65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3c5184bc80de492e9758c899b7600bc2", + "placeholder": "​", + "style": "IPY_MODEL_8a8a5222321946e38de69b513db84a8e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "ad1c29fe56904195b160834cba04a0c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ad5b8dd38022462396e962705dd1e98d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ad759a9a72194a3d82076c6601322a6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad7c5164053345a3b53a2c2623993ebf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ad9a82eb73344ff5bad6273bd3a47485": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b25062c206d143aab590d0fda7cb514d", + "placeholder": "​", + "style": "IPY_MODEL_d12c898e7e1844788d3d748ad2bd8167", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  91%" + } + }, + "adbfcdc5027c4ba798eb04931bd5e539": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ade3073776f24e57aa8d4acd8b874822": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "adf76844a8d94c318d7b11f124e05ca9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "adff666cc0da41eb82076f798f8491af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae0e27e36ad64d11b539cc8bbef4ba18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_acd256a9ac3b4b2abeb614cc7400cb65", + "IPY_MODEL_33051702a54a44748f00e635574ac265", + "IPY_MODEL_648e40aae32243c98e5cb2c6ce8899a8" + ], + "layout": "IPY_MODEL_7eb7be66cbf4447d89f755bfb089b7fc", + "tabbable": null, + "tooltip": null + } + }, + "ae4f0036524f4a2badd0c345344a8fba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae7a1716b0a14b43924414469bb3c47e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ae89dd9343ed4eb8814e10c101143c05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ae95193431e547b1b936a5a2f839464f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_11fd9acc6eec4a58b00464a6a6748efa", + "placeholder": "​", + "style": "IPY_MODEL_c09575ba0b07438bb3236b145d560c6e", + "tabbable": null, + "tooltip": null, + "value": " 480/499 [00:01<00:00, 362.39it/s]" + } + }, + "af0e038f4de74c778a7304432a8ae7af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af2706de906e4a54aae9cc27e50fe862": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af3de1ec3b064b26a4c80a88601cbd29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_81f3e1633f0f4edc90a2916d81b9bb01", + "IPY_MODEL_1e9dc8e16b7442e8b4b6cbd2ef6bfd63", + "IPY_MODEL_4a9b2f8743c545ffb56f3cd00d26b3d9" + ], + "layout": "IPY_MODEL_d8b3bbfe035547f8b5583462b73d54b8", + "tabbable": null, + "tooltip": null + } + }, + "af9caec5dc16457491cb6a0d858c965d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afa1c174b740462695db3650f5469963": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afd2ef8a040b4348bc98a17b1ff49021": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b007ff62602a4a2d876b1efe3afd3673": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8d75ea1674e44d96af14247550d590cf", + "placeholder": "​", + "style": "IPY_MODEL_f87278b7c22546cdbaae634fb57a8984", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "b064303dfefd4611a09a96fd21a6992d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0683478a18b4a92a1e2c29f78fa8ef4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0a58eae94e746e6b407403b1f19364e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8abc7f6b14c64c9ab6f07badd64512a0", + "placeholder": "​", + "style": "IPY_MODEL_0514849d6d8c4727a4751a7c66a05ca7", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "b0f0e7ff3137469cb9bf38983eb4bc17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b1201d00bc18498ab9894655b8ff4101": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "b1587905de344c799dae783551080f27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b17bc236385d4dd68417114366161ecb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6ba40fe467a245cf8236007fcb4ac620", + "placeholder": "​", + "style": "IPY_MODEL_f896916f00ea483388f1a885471b5edc", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 352.40it/s]" + } + }, + "b18f0cf4f37545aeabbfd819430fc1c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "b1bcd5ba576748079cbe5e5af0a7c26a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "b1f1056fbadf4ef28147dbb1ffd2f01d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b24435a8972d41b0b12249bf609467a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b24a0b8a75424936bebf06a5cd6a54be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b25062c206d143aab590d0fda7cb514d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b28318c6531440e9af69ab17fbbd6bfe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2becf330305494798229d046a60ffad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b33ef3e8d72e4847b01a501a1ee5ae32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3a6f71884f8468687c7b586e2cc4d5c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b3acf684348f4c47b64c350a910a0a2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b440836d41b84b47b178e910da6f4bf8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4b4001d21704f6d9722b7baad72dd26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b4d8f3506da145de8a68e64bb20c1302": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_568c091a7401479aba1cb5f80507730c", + "placeholder": "​", + "style": "IPY_MODEL_8555452d88a24c1b83130071b4002e3d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "b4e67d26b8574f92be05b3b64e87c54b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1c1386ede9054a138b858dc1545ac542", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_93d4bffa867445508dfeb08eb7cddac1", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "b4eac108d5154f239da0f9bcf1ac232c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_708974b8aecd47ef963493532093de01", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4688f773988748efb9a575ca2855de8f", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "b5138b22c1ea49bab49fd56ccbca76e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b57c7ff42f9b49c59a427dcd06f42710": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f6bca00a5f5b4ff39af06e4db0ebc705", + "placeholder": "​", + "style": "IPY_MODEL_3c46f81cd95a46348b7f8ee31dc6c6bf", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "b581ba9b94144c68ad527b841857aea1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b59083f0ec09407dac286854bfb5f42a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5bc22f2c50b46debf6fc7ba099f98b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b5c37a10a2294bfb88e0a513d9d34e30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_98f250094b874a2781e0ebe476b27b85", + "IPY_MODEL_2037dae5bfa342adac4d8a9a4a822809", + "IPY_MODEL_9538d61e6b184a778e6385a5b7c98257" + ], + "layout": "IPY_MODEL_1c33f01e4a684804bb4510536b3192cd", + "tabbable": null, + "tooltip": null + } + }, + "b5ca46c46b7e40509783a90787d49d4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bad6a6bb8e9547088a37c12128130fcb", + "placeholder": "​", + "style": "IPY_MODEL_1467cab00aa44370904975393b23f428", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "b5d92701d5044ff58eab8aed0910cf31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_41a7596b7e514adea09b0dc106ab5e41", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_70619300dd114a6cae94b4d91ea55e11", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "b5fdda2c579a4cb4b17d2640ee0438f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b619b1f451714ae39ee040335567b356": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6234c14756549c19227699e587fa72d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "b62e99b4317c433faf9fd66bba58f136": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b643570874b24c3a9be931ef4a85da3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_57116be0cb5142c59d6bf15babd666c9", + "placeholder": "​", + "style": "IPY_MODEL_e0bd5a7cfd4a4569920b77d5d1d3344f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "b645e5a2abfe49fe96ce6bb537d91029": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "b6b0d2ce759f4d43857b4b691e20afc7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b6b69847001047279339b2394de2f13c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6f325f9cff2428aa16134558ef6514a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b732443cad9f4984b424f182f682f953": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b76df83bba1b4424a8e29b89fe9d031d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b773b548738b4088aa5fa5cb905b3583": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b787c0b07c794e05a349801dcf28d706": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7caebf7e06740b7a92a0441bd573cee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7ced44e9d9145e69c0f7cd2a3ab33fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3f77a1911c514851a307fd95121fa807", + "IPY_MODEL_dc4a5a362ab946b9b8124de81578769a", + "IPY_MODEL_96710220aae5465183fb43b5fe5b265e" + ], + "layout": "IPY_MODEL_9e23e688de2c4c849d2c4bb43bec6f1c", + "tabbable": null, + "tooltip": null + } + }, + "b7e0716341f74ce181718c62e6d6c208": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b7eba7cfdcf7448c93712428f4fa57dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ca90ea44457344ebaeac61889a8d37f9", + "placeholder": "​", + "style": "IPY_MODEL_7b747ac67ff84204a5c2350d8d444226", + "tabbable": null, + "tooltip": null, + "value": " 291/299 [00:00<00:00, 360.76it/s]" + } + }, + "b7ee1f2389c4437f88556be7c5ca20e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fed10a9fc2e149869e098e315605f5c5", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_bce88a5077414d8c9081384eecad3c4f", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "b842634c17bc430eb57f5c102cd9d838": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b90680aa1b824cc6b8ce8c6512d4d27d", + "placeholder": "​", + "style": "IPY_MODEL_7dc391b4eaf84a27b73ef0ec43783a73", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "b85b758d39c247b9b76d9f25c11b1f66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b860aa2f245c4479836b6664c1fbeab0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b86782f6f8514051942ed2bab9088ed2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dd672073c20746ed99d05c572588ce6f", + "placeholder": "​", + "style": "IPY_MODEL_1f6a6f57060e425da6a3efdc19c423b2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.: 100%" + } + }, + "b87b207d94984923a25fde279d144d9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7421837a72f145c19e42660ab6d9b86a", + "placeholder": "​", + "style": "IPY_MODEL_70fe49d3a40942d298e2504e40da90bc", + "tabbable": null, + "tooltip": null, + "value": " 663/699 [00:01<00:00, 360.70it/s]" + } + }, + "b882b0e063c045c5a46aef794493b4de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b88508ebc5dc4ae8b8580c6a7c823781": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8c4862861714cb1bb160e7e94a61bc0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8decf0a9fb24d29aa2988e1f1347b5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b8e9adbd4b3847be9c9c309e2153ee49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef2ac247bb39477f95d4f242d7091d82", + "IPY_MODEL_ff0b589903de4b8180bbd0c368575aa7", + "IPY_MODEL_91ff649d1d1840c18123da3d8b384fb6" + ], + "layout": "IPY_MODEL_88e8abe3eca34410a1941bbc595713c6", + "tabbable": null, + "tooltip": null + } + }, + "b8fd8c018d42415ca5d867c6d5527f7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b90680aa1b824cc6b8ce8c6512d4d27d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b90d8c5687c54433bad6171f9de544db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2e6558c07cf94401815a790e9d03dcaf", + "placeholder": "​", + "style": "IPY_MODEL_820ddcf258474b2789909b69fedfde3b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  61%" + } + }, + "b94a03dbfdc7464881d3d95a8deea5e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_14c4c1d89dbe4de68035c60d5834acff", + "IPY_MODEL_c20529aa220d473dae1d370e432453d6", + "IPY_MODEL_46f4561da5f44b15a2f2ccd81e22474b" + ], + "layout": "IPY_MODEL_591c8fa5dd8740c4880a1fc9d020d148", + "tabbable": null, + "tooltip": null + } + }, + "b980250f39ad4e99a016bc8609dbbc0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ba05376918f94f348dcc480f6bce817a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba338c46b14f47668ae298f2cf3648ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c6043c8957ef4a2aaee1dae93c485efb", + "placeholder": "​", + "style": "IPY_MODEL_7ee8719625d4475aa482c5280db4eeab", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  93%" + } + }, + "ba40add6533248abbc9da32332d9216c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ba73e26ed5a943ac938e140c55843c02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fdb6e5e0a4774be38d1f2e2d05037d91", + "IPY_MODEL_38c5fea0d65e4c48aa473f2b762dd8f9", + "IPY_MODEL_56d7f018ddae496abe2b614de1d71831" + ], + "layout": "IPY_MODEL_20e4029fe553444393f77ddd54abcb1d", + "tabbable": null, + "tooltip": null + } + }, + "ba78799094b347d78d70dbcd8fee7d85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "baaa56c7ee104ec59d9d586ec56a72d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_379aee897c594d88abf2047172f5e823", + "IPY_MODEL_471fd00c254048959ba917062300abe4", + "IPY_MODEL_7f3f013e4dc14d80a97c057101e02673" + ], + "layout": "IPY_MODEL_fe0e8914ddaf467ba7196560bee6b788", + "tabbable": null, + "tooltip": null + } + }, + "bac2b131e0fe4428adf8000233c841cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bad6a6bb8e9547088a37c12128130fcb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb01937712fe42938626bc597b28e65c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f31a7548c4184d51a9643115a87e6490", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_480053998b7148deafbc6d956a9bb88a", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "bb04a2592724400c93e6c968f22b30b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bb118a11d49d42ccb562978a4c384d2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bb22831bc9fa4e1ba508da66a65e6248": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bbe3b34d52d84712934297054f606fff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bc61a09d90384286a1c6029f74dadf4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ac2e5f9254b5480cbe979aece5461b9e", + "placeholder": "​", + "style": "IPY_MODEL_6fa895fc623a4058b809bffb7eb68519", + "tabbable": null, + "tooltip": null, + "value": " 297/299 [00:00<00:00, 364.83it/s]" + } + }, + "bc851c576c0b4acca0cebbf5bd59eab2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bce88a5077414d8c9081384eecad3c4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bd18b76931b442279477932561eac8a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bd92dc4e293a46588004a9a1352214de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_94a88227eb484887a751d951a09a7dca", + "placeholder": "​", + "style": "IPY_MODEL_57ef49ed4bb342de9c269a7b1ee5b8e5", + "tabbable": null, + "tooltip": null, + "value": " 366/399 [00:01<00:00, 357.33it/s]" + } + }, + "bdb137f7a4a846c2b65249870ef077a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "bde3343143414690b98e52981d1e8a00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5bbb8ff7901d448eb0f10c47b06f2aa7", + "IPY_MODEL_1af8a41f5c224b1e84dc8f3622533e49", + "IPY_MODEL_73b020aab87b477f9258d472e64bc365" + ], + "layout": "IPY_MODEL_3fd50bcca0f145c4b6c8bb0ce641de02", + "tabbable": null, + "tooltip": null + } + }, + "bdedb6a47a414802bd6698cd66f68ffe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdedd0f78dc04a9092d61cd8e78bfb1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "be76a31489ec454aa52489f09467f1b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d296ccd6bf49443981d59d7e68532601", + "placeholder": "​", + "style": "IPY_MODEL_54531304ad2846d09aba8946da77c4a8", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "be92533c011b48bea564987edff34fb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "be965ce8c8a94db38758b5661cee6f70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be98edb504fd4e7197e1758e0f873097": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf3b64c6daf34adb94322fe66be5485c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bf4463cbac7d42b0a19933ba30bdf6e2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf456be96f914092b288ed4e48c561cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_064f561913a64aa18e47a14c7d705634", + "placeholder": "​", + "style": "IPY_MODEL_0ab84b3feb0e4fb9b398271421a62892", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 352.33it/s]" + } + }, + "bf492ab8ac014baca398e925490bb137": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf4bbe0b25dc4e10b62fe8bc681d0832": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bf77029b1b3f4ffab6ec030eaefd0fc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "bf942b0276b340fe97e503e5c27eb4cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "bfa9cee298b54ec6a62631fffac02d3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bfa9cf76b606481e8c8e2c2e59cde948": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bfc68748100d4a7ea463cc6f96ab8087": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "bfc944d484a94e58bd83f79ca47ea60b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ba338c46b14f47668ae298f2cf3648ca", + "IPY_MODEL_0fd9e4cf02f640b28c1218a6c408a1eb", + "IPY_MODEL_d6424cac3fd944c4a898ed54b60eb73a" + ], + "layout": "IPY_MODEL_6d3b327094f54cb48f6be0adc8283f2e", + "tabbable": null, + "tooltip": null + } + }, + "bfe66051460d4067b93fc18294eb6d9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fbfe74b86bcb4805bf8b2bece1f9c2c3", + "placeholder": "​", + "style": "IPY_MODEL_2de0edc89e0048bda7a1a1f4ef9914e0", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "bff4ea0a24ee422ca96c1da962266275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c01615d310244dc793bf18a43f795ea1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c04222edb66a41d89829c004a0a610ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c079814cdff147f29bc359e80c0d939a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2e77c5df0a71486c84a989a79338aeaa", + "placeholder": "​", + "style": "IPY_MODEL_20addb377519462bb870e2a0d73d2545", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 354.96it/s]" + } + }, + "c09575ba0b07438bb3236b145d560c6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c0b8ed31060546adbec7628e74034b36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c159c6407cff49d4b01c7854215df991": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c175f1bc85e342d08c1dd6191c573ad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_47e2f57dad3c43518d3178fbc20e8bf1", + "placeholder": "​", + "style": "IPY_MODEL_681f63faca654225afd68d7584bd114b", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "c1cfd029710349e8bb2a6720ae411985": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_34a37b01cd294532a190c763be2a9da8", + "placeholder": "​", + "style": "IPY_MODEL_47ea17bfc0014d8796cce6ce9acde73b", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "c1d5610dee5a455094329f5deb02f19d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6c6a06ed639a422c8d8853ff59c4b1b7", + "placeholder": "​", + "style": "IPY_MODEL_f6503a830d434dd882251cd6c1f7ac35", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "c20529aa220d473dae1d370e432453d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_39c042dcb8344985a71093a151c39b1c", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_98eb1189f08a4fd0a1ca39dd50787b21", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "c21eb73ba424423e86846d7447dc2b49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_48924959c23d4d958c4403bd38a9021a", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ab7ee20281f048f4b741aef6e2a4720d", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "c332cb2d0fd54601a8b7a7da97c30057": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c33c52c3471c4014aac152806596ceeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3457131356c451c96a4118222ec5184": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_026f1affcc3f4093bef8fd601c5e9a78", + "IPY_MODEL_ffcac9706b364ca2894cfc605bd022a9", + "IPY_MODEL_f97c1575a84540a0abfcc35889af58fc" + ], + "layout": "IPY_MODEL_b18f0cf4f37545aeabbfd819430fc1c1", + "tabbable": null, + "tooltip": null + } + }, + "c34f858766a54c92be832fc10138950f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b5c7bbcce984435b1cf4c7029aec5c8", + "placeholder": "​", + "style": "IPY_MODEL_b882b0e063c045c5a46aef794493b4de", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "c3b352168ac64b7da2c4d78a0fc9e3ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5be3715daf394859a1394ae797100c33", + "placeholder": "​", + "style": "IPY_MODEL_c94cdfbd65db4c9a98898a5de81a7a72", + "tabbable": null, + "tooltip": null, + "value": " 778/799 [00:02<00:00, 365.71it/s]" + } + }, + "c3c065a140994fc6ba7159dd86bc86a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cf1211799c9f4ac1819a38141b6a6b4c", + "placeholder": "​", + "style": "IPY_MODEL_b980250f39ad4e99a016bc8609dbbc0e", + "tabbable": null, + "tooltip": null, + "value": " 185/199 [00:00<00:00, 331.82it/s]" + } + }, + "c3c7fd263831473a8499892f20bc17d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6615bf33ecc44a3da71c0b8e04ed8e6a", + "IPY_MODEL_5609fd0412844df48ad4d91d90137947", + "IPY_MODEL_23544f3341004d698f38b4deb7bc262f" + ], + "layout": "IPY_MODEL_6c0e153016a94e5a8300a31fad2acea5", + "tabbable": null, + "tooltip": null + } + }, + "c3d0c68500644bae8d230838bc33bc9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c3d1a25262e345c784d032f453a9354d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3f3bc3d118948e6807827c79cb1e194": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c40be986db794cd58b1b129f5abc33fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c41a6a91c55047bdbf640b77fc219514": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c435008f3f544ad2b2494ea4170ff841": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c44ee9e2b04a4fd4916ccfd57ce4c005": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c468ce2f3f1d4246986e60c4c72b86ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_70354077febd42db84a54d2bf0fc088f", + "IPY_MODEL_23d407b0c7f74a0c85f8d771e72b3e4b", + "IPY_MODEL_7e42c9deb4a04e2b8e5a2fac4026125d" + ], + "layout": "IPY_MODEL_752ad6e08aeb4421af878c91a4a38e5d", + "tabbable": null, + "tooltip": null + } + }, + "c469f539c05241afaa7884fa3a7b7f60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5005137026143fba21d826016c63a74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ad9a82eb73344ff5bad6273bd3a47485", + "IPY_MODEL_7ac5a584492f495e974cf19baf7a1aeb", + "IPY_MODEL_79afd59b049d4f68a33a08106aeb2c48" + ], + "layout": "IPY_MODEL_52b006d485404abb9fc87e2998bea48f", + "tabbable": null, + "tooltip": null + } + }, + "c5845f14cd234dd88eb917236dc1ea7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c6043c8957ef4a2aaee1dae93c485efb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6186a9115e840bc813315a474bcb455": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c61c49647d074eafbd5c1537449a6300": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c63f98624a854b9fa5db5fbaf96bdcf4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c674d4ec6c604723aad0af9ae612c8a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c68e2ef7a47c419391782502effd9fbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_438825657f4449708138c78415a3e239", + "IPY_MODEL_22392eb6be534bfda8c55756fe6f84ba", + "IPY_MODEL_b7eba7cfdcf7448c93712428f4fa57dc" + ], + "layout": "IPY_MODEL_2e92a5fc089c47d6923d68205e464c19", + "tabbable": null, + "tooltip": null + } + }, + "c6a5910106054e43a5c14f3e688b1297": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b619b1f451714ae39ee040335567b356", + "placeholder": "​", + "style": "IPY_MODEL_8e8f1de56f6647fbb3b5e7b86bf0a295", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 359.45it/s]" + } + }, + "c6a5eb1881f941b8a7abf0ab2e5b31a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c6ca16b56fb84b379b715bfe58d42734": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6e0e8835ce34e21a3a4ddf1e0bd3c92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6ec5a672f2d4b289c1d6319fb96229c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7d7bce6493db49089fffafc473535096", + "placeholder": "​", + "style": "IPY_MODEL_75e0a5581429468dbb12e4f0523baf1e", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "c707f497aec24165a474eb94658f6fc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c738d79f3d734fe6ba01ac5d9e67d82e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "c77982866f444d27a8a2ea4f78e7e52d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_40b2e835983b41fb9019401c0cbfe733", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_76afe945b755482abc45b5e568995a6c", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "c77e8912fea94fe48c143e507b5882a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7b23113d4dd49cbac62b15e6b6b4c4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c803853185e04f32b8898930aed802a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_598b6ac16039453495eae42adabdfc72", + "placeholder": "​", + "style": "IPY_MODEL_adbfcdc5027c4ba798eb04931bd5e539", + "tabbable": null, + "tooltip": null, + "value": " 37/39 [00:00<00:00, 360.46it/s]" + } + }, + "c809df67f0f34d61932887bce3873785": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be98edb504fd4e7197e1758e0f873097", + "placeholder": "​", + "style": "IPY_MODEL_bf4bbe0b25dc4e10b62fe8bc681d0832", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "c827f36c27a748fb81618a1d472d47ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c830aa04c7bc42c6acc672400ef68a90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ea39809e1ef4d01adf80f76422ba7d0", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2ecfa31322e4498d9bdec04ab535b826", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "c883da9f1be14cc7b0994683eb3b6426": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c8c0e1f905b24acdbfa568cdf6ee23d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8c46930c8114b418e073703a77d938f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e6594f8025eb406a943bb1e8af05ac00", + "IPY_MODEL_6915182708974687bc9a94f20011c6fc", + "IPY_MODEL_0ec6c1a9fa2a4df48758b1978a5a2fd4" + ], + "layout": "IPY_MODEL_f5972963a4fa4aaba90a273cf6d6c1e6", + "tabbable": null, + "tooltip": null + } + }, + "c8f3a5a0ecb24b4cbeff56656bb55f5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c910b59dbd4e48f19a1c0961edfebad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c9353fd9741940e889fdf60256660075": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c93a404c543d45a3b916e20eb761958a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c94cdfbd65db4c9a98898a5de81a7a72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c9a6a71bfcfd4a75bb716c66ecd4b731": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ca0d3acfcff7449bb13429b36b0075f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ca1248100bea43b1b7758f88369fff6f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca5ece859f934bc9a25c0452368699cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ca6ad57cfb5941159f5f1c6b055c5183": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ca90ea44457344ebaeac61889a8d37f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cac5a08da220495296d54d267dc6e766": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bf4463cbac7d42b0a19933ba30bdf6e2", + "placeholder": "​", + "style": "IPY_MODEL_0638947f16b941a39beb81ecb130627f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  52%" + } + }, + "cac9c307cd2049a5924027fdbeec1a59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_234835fc04c8441ea0afa11669ca3eee", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e1d99bf069ad436fa518ce03ee782d19", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "cbcd4929cb02433ea2c8ddc1cac80849": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cc625e16f1c64d55a0d24ea0984f4d81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_829902796e8447b6acf6ab15b5c29da8", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1ebe8286cec04816be72266652031bea", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "cc7500408b274601a1c97553d24c9900": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "cc840cc144ca42c48191a10a6b063c19": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd11f22e25c846faa451cdad41307736": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_584bc0ae47744194895f073406ef9ae1", + "placeholder": "​", + "style": "IPY_MODEL_3b0331d33a3646329714a68beaf02f9c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "cd23969b19544ac798b5505542a1b869": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cd4ce0cefe9a40889d773a60ceb7f1fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a4f115a5e1434f97955e0ff7264f8afa", + "placeholder": "​", + "style": "IPY_MODEL_3d7e9659a6924121a9f24c8517430a0b", + "tabbable": null, + "tooltip": null, + "value": " 37/39 [00:00<00:00, 360.22it/s]" + } + }, + "cdb80c4ecc0a4a26aaa7e7b207a8a0fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a6d07bdeb8914e1ca87a5a78ce2dcc9f", + "placeholder": "​", + "style": "IPY_MODEL_fb9674d226bb40b08c8298d5ce890e00", + "tabbable": null, + "tooltip": null, + "value": " 664/699 [00:01<00:00, 363.41it/s]" + } + }, + "cddcb3dbed6f4acabdf059adde3e8f58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce4f691af9a5482a85053f82ccc34097": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ce60bfb1c1a842e7b793f3562da27f9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5aad76ecfafd4c83b448e4354f7c6f42", + "placeholder": "​", + "style": "IPY_MODEL_1e55dde614fe458d843e223be3c29836", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 351.87it/s]" + } + }, + "ce629a218e934721a444d3b9775ad415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f60813e1af0e455a91a87f1be8d113ce", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fc3a225ed50b4428852f0b94fa4a5066", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "cebf00b01b754b50978d3e6b980d98b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_830304cced404723afbaeb3a9c1ca6ba", + "IPY_MODEL_63c18b60c8b340ed8ea6b0e878cf2c69", + "IPY_MODEL_9d1b19421f184307b1b8d776ef202cf6" + ], + "layout": "IPY_MODEL_3f0db553b10748598540cde60822e4f1", + "tabbable": null, + "tooltip": null + } + }, + "cedce37f6c804bc587aacc4247b7172e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf1211799c9f4ac1819a38141b6a6b4c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf1a7d94e72841658cd8b9b9a641400e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_952c36ed6d154fd9bc2778f7d7a157a1", + "IPY_MODEL_194cd83a23854561931c7f0c17fe6dba", + "IPY_MODEL_750888b11d054b8abf80aba23ff3b7d3" + ], + "layout": "IPY_MODEL_a08a766751ea409fae236604550a3568", + "tabbable": null, + "tooltip": null + } + }, + "cf2dd5279b0f42dcbb04a738db897ae7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cf3b4a67086448cebe38bc0df9b57135": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_288fb6b917c54da3a47b962f1c563580", + "IPY_MODEL_a336db13ecb1496f889be30676adc46c", + "IPY_MODEL_9068eeed80a84a5e993cde7355727880" + ], + "layout": "IPY_MODEL_255b617c965b4b66a67b74ce249e7643", + "tabbable": null, + "tooltip": null + } + }, + "cf8d72605023472e93d5fafcb932a082": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cfa71870608b4ee39b049c352412631e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d0341cebf53b49658928e1655458a47a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3004d918d6194963b440047a854d88db", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_42beb3b6bf184a8b9efc062bb0900394", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "d0378c9c2cc049c98bd4ff706f607836": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0a6d8f78e6942078f7c54f5c1032dea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d0a9f7554f944deebad0e0f494e0b340": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_05ae8b0f921d49dcacef411f7595984c", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fdbe2276e07f44be967abd7c5011727f", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "d0c171049d8248c5bfcdb5ae6eff2133": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4c80b515bdb44d03958857081b7ff066", + "placeholder": "​", + "style": "IPY_MODEL_aa9fd23d74804b7699edb91ca672e49c", + "tabbable": null, + "tooltip": null, + "value": " 368/399 [00:01<00:00, 364.54it/s]" + } + }, + "d0cd5a3f9a354b62b37c9c000e6c3454": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fb15edefaacd4f979ac5da5786c68525", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_15562d5515c54685a0418ac312a70993", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "d0d6bde4d189485294b8de5496d5badb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0f8a3ab51954f1391a21336ef2ed4e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_08b2544827604ac88f95a23a1587e481", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7947d8d88c46427286df33834c3e2dd7", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "d12c7f9fe8f949c5a413058f75fe9159": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d12c898e7e1844788d3d748ad2bd8167": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d134da8a49084494b6f03e8ffe269e5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d1b7b0961a1f485e9e7b06cdcd9e38fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d200bdfc11a547a9b3f6b6bb42e203b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d26745479b864b0d84dff122455f8a28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d296ccd6bf49443981d59d7e68532601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d306a770b70d48ffb43ea52e248b885f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d3358f971f0d48f88a5d44c91d3fb7a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3400de3aa544ec5b1f4cc5c2e3cb0dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "d3eac37fd5874895be2f4ccea40f6cad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d43583f614804c7b9a15b16fc5d39c0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d4a21d30e2e742bdbc11e4b2d113052d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b1ce2ace64948fe9ebf69eae5e0230f", + "placeholder": "​", + "style": "IPY_MODEL_d6e57e57cacc45ce8202c1459dd6f4db", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "d4c01029140741b78012d16261101438": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d4c51be1057342028ab5eaa9b27d2113": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0320460434d44245b2d484162e67183c", + "placeholder": "​", + "style": "IPY_MODEL_a661b4edaa614a9cb46f7306f1d46a1c", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 352.89it/s]" + } + }, + "d52f7fe0ac544f58b726245383cea7fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d55dd11d79a54468980f37f40d4d37c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d5e34eb5c8f248b995600255374e1cb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cd11f22e25c846faa451cdad41307736", + "IPY_MODEL_9b6c83606a7c4d85a8c9b22505d783e1", + "IPY_MODEL_febe18d581124ae08879d49b0597307b" + ], + "layout": "IPY_MODEL_71ca441c651843b5ab369965e9fff8aa", + "tabbable": null, + "tooltip": null + } + }, + "d5ec943cb5124a8aaa8424a839224d71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1f0ecc10f2924d7ca0e7f1b104b9ed8f", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ba40add6533248abbc9da32332d9216c", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "d5fb1762b5754525b2dfdefa48b7826a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d600dbd8924f4d409c5e5a110d276ee5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_09b6451b6d2a470a99ecf69281636987", + "placeholder": "​", + "style": "IPY_MODEL_710c80d0beee4809beba178b2fe4d62c", + "tabbable": null, + "tooltip": null, + "value": " 595/599 [00:01<00:00, 370.35it/s]" + } + }, + "d6327d5992a946208d63034400da112d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9d6ddcb3aa0c486983263fe5b2c7cc37", + "placeholder": "​", + "style": "IPY_MODEL_696da8126c1841168596b216aaf22aca", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 350.11it/s]" + } + }, + "d6424cac3fd944c4a898ed54b60eb73a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4a927ddb4ad34b4d8d266a9e01e26162", + "placeholder": "​", + "style": "IPY_MODEL_06971c04a2ae4553bf2088ce320a6a02", + "tabbable": null, + "tooltip": null, + "value": " 372/399 [00:01<00:00, 370.44it/s]" + } + }, + "d64dda5714dc445489d9627e65283507": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d65ca456eec34b87992aa27dc021c7b0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4e704ee25e654584b271ff9b52b07d3f", + "IPY_MODEL_3cc5eaf75896480f8dff11ae8a727ed9", + "IPY_MODEL_e4255e2fd3c9487092e58ccb4f053e2f" + ], + "layout": "IPY_MODEL_6a9ed65510764abb955653db0e7ee27b", + "tabbable": null, + "tooltip": null + } + }, + "d6830f03091b4122bf8a35adb6ef3b8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_28feb5aac0de4bb490a80c66d22b8daf", + "placeholder": "​", + "style": "IPY_MODEL_355304b3dc444dd3a780d3a03dd83d43", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "d6d68e4b062d48e596a0c483fd5fda07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d6e57e57cacc45ce8202c1459dd6f4db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d784ada454e9411dab47048443652156": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d7896b8022424b25b876bfaa8d644595": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a436284c4732400e9b8c8f443966b7fb", + "placeholder": "​", + "style": "IPY_MODEL_f699477158e14088862a109d5dc070e0", + "tabbable": null, + "tooltip": null, + "value": " 369/399 [00:01<00:00, 349.31it/s]" + } + }, + "d7b5bc789ea846109c2966954f666e5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7d7efe850c24bb0905c4466d5a21ea3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea9ab88e425b4b0584b8eed507e04407", + "placeholder": "​", + "style": "IPY_MODEL_2b7e2f2529d3499f9b631e8623105d46", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "d7f0556fc6ad4758b8a7cda07ba539f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8034dffc34894238b3dec4bc38dd602c", + "IPY_MODEL_24beb2defa5a4780ba4dc286afbac5e3", + "IPY_MODEL_1749fb2f460f4b1d926e6a554d8645d3" + ], + "layout": "IPY_MODEL_f47254cfc0e647f7adfd45769bf361b4", + "tabbable": null, + "tooltip": null + } + }, + "d7ffdc53aa764cab94c829dcce0a5f90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "d8091fc330484f93ae0428ae85d8afbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8734993d9e94afd95784de851ea82da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8b3bbfe035547f8b5583462b73d54b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "d8b9fcda56134502b34c74e949c6d3e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3185d1df4262486583b2cce2550716ef", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a59245fd27c84e1fa9f32f9568ba2884", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "d8fcc39f231c4f45a0dae262217c173c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_45b0e4c66bc1441bb94932e73f7efb79", + "placeholder": "​", + "style": "IPY_MODEL_e0a49e409fe64e798ab2d139cfb1e515", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  97%" + } + }, + "d90671b9538c4f328aa0c02f47852a76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bf492ab8ac014baca398e925490bb137", + "placeholder": "​", + "style": "IPY_MODEL_dd99074dc14c4ea4a5ed8508d18818fc", + "tabbable": null, + "tooltip": null, + "value": " 183/199 [00:00<00:00, 361.93it/s]" + } + }, + "d9af00f60d5446acb1d9c1cc0cfe770a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "d9ebbe51225a409096250907c4c2dbf5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8b28cd8da30042dd967bf6d6251cd42e", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_fedfea87bb13469d99ed1b507605937c", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "d9f6193af70e4e5ca8a48e246903e57e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2384ab9a24d54e6ba660d724d28817ad", + "placeholder": "​", + "style": "IPY_MODEL_f25a9d81b91e4bb298179a53216a074b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  62%" + } + }, + "da02205a6765423997b76576f7338f55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da119b753ebc4fab9670940cd90206dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_82a647356d4e49f1a8e1b5406a0a5083", + "IPY_MODEL_f97da0eb1ce3419a9767ea5aa0cbed1d", + "IPY_MODEL_04f8f3ecb7ab4726a414c4953afd14f3" + ], + "layout": "IPY_MODEL_ec334d842cc2459085c5386e63df7c7e", + "tabbable": null, + "tooltip": null + } + }, + "da1789b52e594f8bad8427cd64a63db9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da2bf1956cc545ca8cc0d568b915d4b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da46a2589b244ea59a9ec83fa6a984a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f1060dbf5cb34ba9bda97649bacb34b6", + "placeholder": "​", + "style": "IPY_MODEL_e23ec0460d91438b89749a365520c79d", + "tabbable": null, + "tooltip": null, + "value": " 482/499 [00:01<00:00, 368.24it/s]" + } + }, + "dab13f6588d94e1ea06facae48a345a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db0dcff9dd144d069a54398862e9c984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2b45c72793a7403ea28982b692d23f36", + "placeholder": "​", + "style": "IPY_MODEL_2259bbe9ce08411a90c41377cc330c48", + "tabbable": null, + "tooltip": null, + "value": " 294/299 [00:00<00:00, 337.64it/s]" + } + }, + "db506087065141bd9360f9d96b38e047": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "db9eb05a179a4dc5bf699ba7982c2815": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "db9fdab7cda940ab827d78240efeb06c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dbfee872796e4aaaae3ad4b8394fc5c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9cc5dae3a64c4eadbb102b500f243165", + "placeholder": "​", + "style": "IPY_MODEL_654c7c69cb6141c987f854aed167344d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  75%" + } + }, + "dc0a4d403d8b41058913fcde3e7c441f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8a50b8decf89476dacacb5953b63da39", + "IPY_MODEL_070410c8505741cb9d891b61db4b1d67", + "IPY_MODEL_cdb80c4ecc0a4a26aaa7e7b207a8a0fb" + ], + "layout": "IPY_MODEL_2db07d5df0234a4cb27f2e7124271ada", + "tabbable": null, + "tooltip": null + } + }, + "dc4a5a362ab946b9b8124de81578769a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1f3903e21d95428c97d968f475397059", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_534afcd9dbed4095bfed7c1a8d2188ab", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "dc51427dd8fb4662adce820a83d7e7cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_102f1848b58d41f892867c43637f8b4e", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_f782ba5ac68343be9098e24cd21c1755", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "dc9cc67c03584932bb357cd6a440babc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dcdeb72a91644e7b9323f3e1c7c9bb5a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "dcfd30625b0d4bcc846d80ed17da009f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8adda907b62942fda7c7558e4baf9a94", + "IPY_MODEL_5189b615168f4e809030de24721404dd", + "IPY_MODEL_d4c51be1057342028ab5eaa9b27d2113" + ], + "layout": "IPY_MODEL_89ea9978425b4528b483a06a93762e8b", + "tabbable": null, + "tooltip": null + } + }, + "dd21b7e9f2204483a81155c8c942a14c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dd672073c20746ed99d05c572588ce6f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd99074dc14c4ea4a5ed8508d18818fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ddba2ca557dc40dca530338f5dd7d648": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ddbe68e1a1064b2d8c3a9d8a267a67c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38b3ebd4a29a485f8c3c97a953467b35", + "IPY_MODEL_401bfe59ea1b43f081fb0fb8a0d2b5ff", + "IPY_MODEL_f01624c031444575992cdfccf1adc495" + ], + "layout": "IPY_MODEL_7f06dba9e4614c7fa0a1281402b452ce", + "tabbable": null, + "tooltip": null + } + }, + "ddc6cfa799264926b85f97ad463641ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddf2ca4ebb8741399cdcd4dc0c972dc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_91ce479998ce4fc3915fa56338763eae", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7e98fef5de29464fbe91fc48112fafe6", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "de9959fb09ac4cccad6320ad384fb596": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "deae5739c6514cabad9f0e09b6584099": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "df0b97971d1b4da784d13950b890ade1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "df3524274cd44265a1ddbb836776e1bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_41e3306dc3e1434383b09f4837ad3d87", + "IPY_MODEL_58a917f7215c4506b3c7e138ce9ebe16", + "IPY_MODEL_411e610baad644b98be37857503e8deb" + ], + "layout": "IPY_MODEL_782e9f59991440fb8f2bb58d0540321b", + "tabbable": null, + "tooltip": null + } + }, + "df6fab5a0c22465b8e1ff3ab2829117a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "e01c4b3ba4ea4da5849828f855afbb7a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f474844b5d6a47279cf29bccb489eae4", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b5bc22f2c50b46debf6fc7ba099f98b0", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "e0a49e409fe64e798ab2d139cfb1e515": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e0bb0891085947018543e0b25fe6a5dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e0bd5a7cfd4a4569920b77d5d1d3344f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e1436fcb37b4445d913bf68df979444c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a33a001b159349fab9741fd08f1e74dc", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_242d249d623e4070998cfac6f5a7134b", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "e1507bee1c2e451ba1c83c5ec8ad1d67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_530a0ee2ccf1401086c4cc131935356c", + "placeholder": "​", + "style": "IPY_MODEL_c674d4ec6c604723aad0af9ae612c8a8", + "tabbable": null, + "tooltip": null, + "value": " 73/79 [00:00<00:00, 364.87it/s]" + } + }, + "e1c8bd82777d41fd980fd06a4bf78855": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e1d99bf069ad436fa518ce03ee782d19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e217203ba78544ad9e74b8ef8a85b907": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c77e8912fea94fe48c143e507b5882a2", + "placeholder": "​", + "style": "IPY_MODEL_bd18b76931b442279477932561eac8a9", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 354.12it/s]" + } + }, + "e231ca64eb4a4161bd34c8ec0ce9cf95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e23ec0460d91438b89749a365520c79d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e24818dc9a7146d99f8348d040d3bb48": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e24ac04487814b3794160710ae12f57e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e26b0fff5a9b4bfcbc7bbb87709b7332": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e2a7e797571a442aa6856ae6fae6e8c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2d8483a206d47aaa5e6bad0f8d44e54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e32d08044d8d43dc84641a3567ae8c00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0099e0eed0af4be88b3d64f9e7069ca0", + "IPY_MODEL_4f50e952c8ee4dfb8727e51c61e0c095", + "IPY_MODEL_19892871612e45f6ac1c74d736c4cd2a" + ], + "layout": "IPY_MODEL_93182494b09f422e987faef2c4484f13", + "tabbable": null, + "tooltip": null + } + }, + "e383b2024372464abe591908ce466a8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e384fa48257444e2aea55d925d67e2a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0c6502ee8c2c42b7ba21f18ca572eac0", + "placeholder": "​", + "style": "IPY_MODEL_a340a170e0214eda8adb7d7e13f46c29", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  81%" + } + }, + "e38c530f121746cb8a0bff30f7eff6e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_90be65850b384b7ea507a284a2978b86", + "placeholder": "​", + "style": "IPY_MODEL_bff4ea0a24ee422ca96c1da962266275", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  61%" + } + }, + "e3bed6d60cf248a7b2113d6c27fb7e0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7f6f33376b1c49e788ac42fda6bdaed0", + "placeholder": "​", + "style": "IPY_MODEL_4674e0570d2240518bca3a5d9727bcee", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  93%" + } + }, + "e3c9be1c6d584b52aded832d6defd824": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a279b0dabba46cbb4a5c98f0ab0dbda", + "placeholder": "​", + "style": "IPY_MODEL_837ebb58052b4b5ca947beed81390d5a", + "tabbable": null, + "tooltip": null, + "value": " 997/999 [00:02<00:00, 364.16it/s]" + } + }, + "e3d3e60602cd4b009782826748f9bdf7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0870533661634ff0aba3af61c7d1f45b", + "placeholder": "​", + "style": "IPY_MODEL_0072758cb5a441a189c874088e2e4f9f", + "tabbable": null, + "tooltip": null, + "value": " 294/299 [00:00<00:00, 362.88it/s]" + } + }, + "e40fe9987f85442296584419162dd149": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_de9959fb09ac4cccad6320ad384fb596", + "placeholder": "​", + "style": "IPY_MODEL_26adc41a09eb4024b14e199b23ee1268", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  95%" + } + }, + "e4255e2fd3c9487092e58ccb4f053e2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d8734993d9e94afd95784de851ea82da", + "placeholder": "​", + "style": "IPY_MODEL_bdedd0f78dc04a9092d61cd8e78bfb1b", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "e4496b6b73d04e97ae3c28b8a03e85a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ff75787e6594279980931eccff786d5", + "placeholder": "​", + "style": "IPY_MODEL_57207c637ae4438c8db164c201510156", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  73%" + } + }, + "e475f0eabf8d4677a3962363685f4b4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e487871e3b3a4357b3f3d3f5fc58c837": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ae4f0036524f4a2badd0c345344a8fba", + "placeholder": "​", + "style": "IPY_MODEL_502b1a5c327e4b7988044c6fa14c9856", + "tabbable": null, + "tooltip": null, + "value": " 297/299 [00:00<00:00, 337.41it/s]" + } + }, + "e4b754781f6a4496828d6ab199a52e38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4b9e8510735418b98f75fffef37a5db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4307e9357abb49408c2ed54e1ba18eed", + "placeholder": "​", + "style": "IPY_MODEL_86b75f8cad5a46d7b97da5b62b2b89bb", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "e4f00fc898ac4023b7ff5b6a84d59c44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5404053ec2a45bc9ccaf5b92e178632": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e5abefda2b3f4d6098a926782d4fa807": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_73f0959e57604fdcb6042ddd4d37ac7b", + "placeholder": "​", + "style": "IPY_MODEL_a5bb1cdab18b4fdc996a5f2118d037a2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "e5d527029e744ec6b36b963d68e2c649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b33ef3e8d72e4847b01a501a1ee5ae32", + "placeholder": "​", + "style": "IPY_MODEL_c910b59dbd4e48f19a1c0961edfebad0", + "tabbable": null, + "tooltip": null, + "value": " 297/299 [00:00<00:00, 367.29it/s]" + } + }, + "e6594f8025eb406a943bb1e8af05ac00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_82e2592a59b447fd83029863de4344a4", + "placeholder": "​", + "style": "IPY_MODEL_67c50f30b4184b90bcb9d8d8da59ab00", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "e65de43cf3d845f5bd10fc9300d1c6ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b6b69847001047279339b2394de2f13c", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_57305e3d08fa4b88b8002663ec22ce03", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "e6b5834bbff443c1868868bd4f2da9c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e6c34a76e2174f35880a463faf8e5f36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e384fa48257444e2aea55d925d67e2a4", + "IPY_MODEL_42a2de20706e40bb8b771300802429da", + "IPY_MODEL_61eb86b98b4b4462b7b5a119f742b342" + ], + "layout": "IPY_MODEL_07b2a8bef0984a42a8b9bd4f68671314", + "tabbable": null, + "tooltip": null + } + }, + "e6c48de32f8348ff8b82a4c271e979c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6da76fcbbce45558f7d698926f56490": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6fcb0ec556241c59d66ea22eff8e79d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e7478027f5ad4cd1bbc0960ace565444": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e755273fe7414af393da0e637c45cb6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5bc1d89e46b14893a48308eda7ca8327", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_420ca366d3f84b8da696529b09e0fb7f", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "e86dd5462de24a36b290ae8edf850afd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e86ec14407794006a23d0ee3c05432dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e87e5e1f902f41dcb9337631b9dd253a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e8916415b5ef40c68f39362bb2fa14c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e8ad29bc62e24720a81201de0fedd77c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e913215a765d411080f03f4b8e81a3c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ed2d821545ac409885568652e88b8e0a", + "placeholder": "​", + "style": "IPY_MODEL_bfa9cee298b54ec6a62631fffac02d3c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "e93cc4a88cad4dbd8383789e40ea66f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_148576e0fb2141a0808464ed94b127fd", + "IPY_MODEL_d0cd5a3f9a354b62b37c9c000e6c3454", + "IPY_MODEL_e3c9be1c6d584b52aded832d6defd824" + ], + "layout": "IPY_MODEL_fa616fa92f694f8baf973e3e0216ade2", + "tabbable": null, + "tooltip": null + } + }, + "e9574faea46b46caac536226111891e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e99de2c5cff54076b8f33791a6e0b19c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "e9b55a0769c74814a9026ecbe81be643": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e9ed2d3b26914df18a247d134a39d762": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2582ee3ecb8f40a4a915e20cf76d3034", + "IPY_MODEL_edcaefe370114f90be5a428a348cd4d6", + "IPY_MODEL_12fe941e2aff47c6af6415035cbe59f7" + ], + "layout": "IPY_MODEL_978a701e7e5b42f78ad268e2ea7e3e36", + "tabbable": null, + "tooltip": null + } + }, + "ea47ff2930e148d3b73975bbc39c56ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "ea5e890d80d74f688eb8f80994f47716": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea671a54605c4fd09b00a497010b515d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ea9ab88e425b4b0584b8eed507e04407": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea9d152434c44c8e8f6bd7aced190103": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eaa4d7ec8a9e49c7bc4bff6253aa5620": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eac9dad51c714b8fa278d66f6aadc660": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0936de0747cb4882ab7e6f256d7aa4eb", + "placeholder": "​", + "style": "IPY_MODEL_e1c8bd82777d41fd980fd06a4bf78855", + "tabbable": null, + "tooltip": null, + "value": " 782/799 [00:02<00:00, 372.79it/s]" + } + }, + "ead10f9e718748628b5767cb4fa7f2f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8f3a5a0ecb24b4cbeff56656bb55f5c", + "placeholder": "​", + "style": "IPY_MODEL_bb22831bc9fa4e1ba508da66a65e6248", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 355.45it/s]" + } + }, + "ead2cdd756d94dc1a61fe64e12eb1ef7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f1aece31cca34d15a9a93b9170d4b625", + "IPY_MODEL_27888a19cb4949a5955db0810887d01c", + "IPY_MODEL_a1930905d7944c0abc37bab11d78cb62" + ], + "layout": "IPY_MODEL_370b92e85a114488afa68e2ed2e2eb67", + "tabbable": null, + "tooltip": null + } + }, + "ead4f63dba604c7d921e0673959a38b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebd16efb451e4bf8845891e94faa9b56": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ebfc2591c3ff485e803aee787d8ed593": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec0e4b7f69cd46db845078b2c870c8fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ec127cbcbcd34525a3314895422c4a52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b860aa2f245c4479836b6664c1fbeab0", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ca0d3acfcff7449bb13429b36b0075f9", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "ec334d842cc2459085c5386e63df7c7e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "ec34fa7c1738470ca8918e8677230b63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec43535fa727495ea79cd60300bf312a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_61d65093718847e4be786be5d6afbeb8", + "IPY_MODEL_b4e67d26b8574f92be05b3b64e87c54b", + "IPY_MODEL_b17bc236385d4dd68417114366161ecb" + ], + "layout": "IPY_MODEL_923a8f8e39e944b28f48d80793a06540", + "tabbable": null, + "tooltip": null + } + }, + "ed0994b856054eddb92f8604e0cec538": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b643570874b24c3a9be931ef4a85da3f", + "IPY_MODEL_5c735f833cca42faa4e621addb0cbe62", + "IPY_MODEL_41799e8ed28f4b68a731b96a18ac2380" + ], + "layout": "IPY_MODEL_d3400de3aa544ec5b1f4cc5c2e3cb0dd", + "tabbable": null, + "tooltip": null + } + }, + "ed0e4971bd794b4bb3060657b66b8fff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d134da8a49084494b6f03e8ffe269e5a", + "placeholder": "​", + "style": "IPY_MODEL_db9fdab7cda940ab827d78240efeb06c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "ed2d821545ac409885568652e88b8e0a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "edbc56fcfef44c16a94f76c9082fe44f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "edc8d6ee12a24ff0953ab319cebabee2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_81b10617b323434fa5dd09739c4c4d61", + "placeholder": "​", + "style": "IPY_MODEL_25239cb5cb2c40b3b9f88c91fa11bfcb", + "tabbable": null, + "tooltip": null, + "value": " 773/799 [00:02<00:00, 363.25it/s]" + } + }, + "edcaefe370114f90be5a428a348cd4d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9efbcffed0d640ec95650f6b44597dac", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_994772e07dd54886860bd3ff52f44310", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "ede85cad6ca14078b9c0f3f17c56b72b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee0f9c2fc55e47bc982180eee3863d3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a5b64d269de4e92b26f073ad1b9fbca", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_0d1f00eccad145d18d77ffacd34fdcfc", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "ee14622cd15749439820c42a23e60fbd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee4ec24bdf0946429e1c92a8855fbf3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ee9292d2cf6246b482f4477a43083366": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ee94d2d7c18b4cb8810f14c855e1b2b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eeade946e22646f8bba9134ada76a58b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "eed9040d31db4bd1bec29339e53e3306": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "ef0f9b18e54546fd8ada11b2118939ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "ef2ac247bb39477f95d4f242d7091d82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_132a0fb522764f228fc5e2353294c6e4", + "placeholder": "​", + "style": "IPY_MODEL_61179f11be4d4ad3980c87be54abc0e5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  99%" + } + }, + "ef552844b99341d79625224f4bd6e572": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ef77acf3363d4105934d4c294dd6e405": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efa9f0a8274b4fcf9b5370fda250fa30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "efd51c0a5a68438fa2197e5bafdbee2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "efd8dadbee4b4526a15eaea1489d3dca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f01624c031444575992cdfccf1adc495": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_347e13716cac4865a6ff64467313aa11", + "placeholder": "​", + "style": "IPY_MODEL_7c97f6da49da42e2841c10de0d670f26", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" + } + }, + "f0163d82a0da4d8796c79376cb59ba60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "f0208ba48bac41138021991cc6fab964": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2f521620627248e7a4763ba2fde8b384", + "placeholder": "​", + "style": "IPY_MODEL_b6b0d2ce759f4d43857b4b691e20afc7", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "f038310c56d84ff98cd045fc75d74752": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5068dbbfa0de4c3ba0e259cd8333dc2b", + "placeholder": "​", + "style": "IPY_MODEL_2dd9ff6d11ad475da767edbca22fde12", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  82%" + } + }, + "f05c396f9638427b8ff97ae0cc1d304c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f0c8be8468434012b19d9f4969a16cad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f0dfe5c6ff1147f98d8a9dd72055bf62": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f1060dbf5cb34ba9bda97649bacb34b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f10a4f9987574935b5881e29722076ed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f123cf87de6b4d6986dfcb05a9aed4c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_be965ce8c8a94db38758b5661cee6f70", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_19a544bf339e4591b7dac54f64ee27a0", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "f131e376ab0b4b99bba21834c0badf63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f5ad72f7153d4b99b6c1424b8c7080eb", + "IPY_MODEL_8d04f608e3b7419199e4900abbb061bb", + "IPY_MODEL_9f775967506145889b3f58b2f8077818" + ], + "layout": "IPY_MODEL_dcdeb72a91644e7b9323f3e1c7c9bb5a", + "tabbable": null, + "tooltip": null + } + }, + "f14d714c6c0d4fdb934a0c8b6add79f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_58c83d49675b46db82266c261c036f86", + "placeholder": "​", + "style": "IPY_MODEL_6d3ccec4c42b402b996aa16bc7b9e2d5", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  99%" + } + }, + "f16b839c197540b68f4a0909fc868037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5ec6217bd4bd4cd99aed4ef8f31f1cea", + "placeholder": "​", + "style": "IPY_MODEL_1e42e38b82d640d0b9bcaa8704520e26", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  73%" + } + }, + "f1aece31cca34d15a9a93b9170d4b625": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_26f6decc30544462b6b1487cbab83353", + "placeholder": "​", + "style": "IPY_MODEL_ddba2ca557dc40dca530338f5dd7d648", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "f1ce1746bd4c49c6b3f183d3c7add171": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f14d714c6c0d4fdb934a0c8b6add79f8", + "IPY_MODEL_250b9961e7384b11b02d9fcfca4002ec", + "IPY_MODEL_9788a286e84a4450acdeaf4a5ff306b6" + ], + "layout": "IPY_MODEL_24951e7781bd4944bff41af1367209fc", + "tabbable": null, + "tooltip": null + } + }, + "f1e87e57b914424cbcfa344bfadcb60e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3826cf494a024e14aba545a3a1f8a4ff", + "placeholder": "​", + "style": "IPY_MODEL_8c0be0ea0e614e60be0712b34b142bd8", + "tabbable": null, + "tooltip": null, + "value": " 185/199 [00:00<00:00, 365.13it/s]" + } + }, + "f22d03c204a342288dd7efe8a22d48ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_40bcea7843324063a66654235af0b041", + "placeholder": "​", + "style": "IPY_MODEL_067ef8d9b43f475c8bafd8641e82b903", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "f236ca780b3a4051a5992f7b138766f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f24982c181324287b4cb2411ea291384": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b4d8f3506da145de8a68e64bb20c1302", + "IPY_MODEL_bb01937712fe42938626bc597b28e65c", + "IPY_MODEL_7f52da9b70204a2c964d3b7c9bb5f22c" + ], + "layout": "IPY_MODEL_bf77029b1b3f4ffab6ec030eaefd0fc5", + "tabbable": null, + "tooltip": null + } + }, + "f25a9d81b91e4bb298179a53216a074b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f26f7cd6572344afb1df3d7dfb92f478": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2885b35b3db481fb368939ef8d508ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f31493e347064f87a4c9af4d899c8338": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f31a7548c4184d51a9643115a87e6490": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f360e6312e5a4403863bb5ab1ba58459": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f382db9ffd234b6f92338797a6a935da": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f3b1fddd95784c8e8d50ab319f0ba4e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f47254cfc0e647f7adfd45769bf361b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "f474844b5d6a47279cf29bccb489eae4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f49954c8368243b8978265281ec86c4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_449b77da8cb04157b3a1da8bd069de3f", + "placeholder": "​", + "style": "IPY_MODEL_90dbd87ef8644cb6ad32b3cc8e1955b2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  82%" + } + }, + "f4a024683a44416e984e25d202634705": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2943c575311a4d638cfcf9ae49e165af", + "placeholder": "​", + "style": "IPY_MODEL_acc62cb85534464da464081371d494dc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "f52a08b1ab0e4a889394c121bc328c23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f52e4c4680d3402fb7e0db7394ebed75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c33c52c3471c4014aac152806596ceeb", + "placeholder": "​", + "style": "IPY_MODEL_1817cfe1c4d045f38e2e022bf07a9b33", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" + } + }, + "f568520fcad84f348539d16c081d6b59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7edcd082516745a38fdae77e062f1046", + "placeholder": "​", + "style": "IPY_MODEL_3be06b1781ea4ae891c8f28bc5252120", + "tabbable": null, + "tooltip": null, + "value": " 965/999 [00:02<00:00, 367.32it/s]" + } + }, + "f5972963a4fa4aaba90a273cf6d6c1e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "f5ad72f7153d4b99b6c1424b8c7080eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b5d39cb4bf24420a3590ed904673d3d", + "placeholder": "​", + "style": "IPY_MODEL_4b299d4ab0424a17821e153a9bf463ee", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  73%" + } + }, + "f5c1186dec3e4d24afea411ce9e31051": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_890278b32a154b97894ee3a225e1c05f", + "placeholder": "​", + "style": "IPY_MODEL_8e26c83d6073406a852eac2034d65be6", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  82%" + } + }, + "f5d34dcb783c458fb360983cb881e41d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b86782f6f8514051942ed2bab9088ed2", + "IPY_MODEL_9c8f38be56c64ae4b038567f96db6500", + "IPY_MODEL_6c67410295884800a620f374d0d87830" + ], + "layout": "IPY_MODEL_9b1e34eb82bb4740b46ba721b4da8101", + "tabbable": null, + "tooltip": null + } + }, + "f60661654b89466394e752e2c5aafd51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f60813e1af0e455a91a87f1be8d113ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6369d1079f0474aa29bf88fc2759164": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f6503a830d434dd882251cd6c1f7ac35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f699477158e14088862a109d5dc070e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f6b6db4ea31f43b58e492efff1cec142": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_80e99db76e4b45d395684a813a3e4d22", + "placeholder": "​", + "style": "IPY_MODEL_d3eac37fd5874895be2f4ccea40f6cad", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "f6bca00a5f5b4ff39af06e4db0ebc705": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f708fdbc67674d22b9e64017ccd7571b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7179f3dd1ca4bfa88f3e5f07e45a1dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f724380a346142a29ed9d12e57b047af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f7829ae2c54e434f9a22005fc3dae290": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fe16ea82eb63455bb85d4a926f4b8275", + "placeholder": "​", + "style": "IPY_MODEL_b62e99b4317c433faf9fd66bba58f136", + "tabbable": null, + "tooltip": null, + "value": " 35/69 [00:00<00:00, 348.98it/s]" + } + }, + "f782ba5ac68343be9098e24cd21c1755": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f85bf7cfc17d422ebacea7480fee420f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_adff666cc0da41eb82076f798f8491af", + "placeholder": "​", + "style": "IPY_MODEL_48fdae60bb784400a806e96dd5cb1294", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 354.16it/s]" + } + }, + "f87278b7c22546cdbaae634fb57a8984": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f88dc163254c4eb5a3a1a351ce5c07bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f896916f00ea483388f1a885471b5edc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f8c19883440b464ea6907f88ecc20cb6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8c2d3e5712d4833b35ff936ee65278f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f8dcb2847ef1484ca610ae70720a8b85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5ca46c46b7e40509783a90787d49d4b", + "IPY_MODEL_40e83a61461e46c3b706ba28f53ae68d", + "IPY_MODEL_eac9dad51c714b8fa278d66f6aadc660" + ], + "layout": "IPY_MODEL_8cb772963b0d4f9b97d1b497b81e5787", + "tabbable": null, + "tooltip": null + } + }, + "f8e5e573da5347f0bc4ab60584d96b11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f91b5415a4444a2b9838403c8d4a82bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4f2d86db11d94eb3892d396d95488b2c", + "IPY_MODEL_68744436f7954d1d90fa5e02877e5c44", + "IPY_MODEL_f568520fcad84f348539d16c081d6b59" + ], + "layout": "IPY_MODEL_3f36bab9c92040eb997e99f0ca05adaf", + "tabbable": null, + "tooltip": null + } + }, + "f93db39f5b0446a78c10220f2692d6ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f97c1575a84540a0abfcc35889af58fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_03cdefc6bcc3441c96d965034eb1c6f5", + "placeholder": "​", + "style": "IPY_MODEL_c6a5eb1881f941b8a7abf0ab2e5b31a4", + "tabbable": null, + "tooltip": null, + "value": " 591/599 [00:01<00:00, 363.08it/s]" + } + }, + "f97da0eb1ce3419a9767ea5aa0cbed1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b88508ebc5dc4ae8b8580c6a7c823781", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_bac2b131e0fe4428adf8000233c841cd", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "fa616fa92f694f8baf973e3e0216ade2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fac12ab2299f4eb49e2f2ad4ab157ae7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb046d79c2604487b3f754060000488a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fb15edefaacd4f979ac5da5786c68525": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb3a17559779408db0db5cf5aaf39908": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_742c8964f8e345d882b4df12f377dd46", + "placeholder": "​", + "style": "IPY_MODEL_38cc4a5c189b4f09bd10c8d6a0371964", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "fb53cda1dcbb4485a5f473d418e06873": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fb8ce4e9e22a475eb46cd0bd06bef548": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fb9674d226bb40b08c8298d5ce890e00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fbc2e2800f69459e9adc3a61700c71b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fbd8b39aab8b4aa197a53ab2f71c37b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fbfe74b86bcb4805bf8b2bece1f9c2c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc0ecbcdd8804a4ca291c51e12bce4c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9da369ada4dc421f8645b288fa83aa94", + "IPY_MODEL_16d282bd9e0642ebb9e2731ca6c78aa1", + "IPY_MODEL_d0c171049d8248c5bfcdb5ae6eff2133" + ], + "layout": "IPY_MODEL_6cef078f27b34534aad4200d93d0f910", + "tabbable": null, + "tooltip": null + } + }, + "fc3a225ed50b4428852f0b94fa4a5066": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fc553ccf6a0b427aa55c04996ced8786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_86179bf42ffd4e2fbcdb69876bf2430b", + "placeholder": "​", + "style": "IPY_MODEL_a35d6c88b5a740008757e625a41371e2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "fd0a818a3abe4d83b5db0d8cebfb7225": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fd3c7bb2465e454f8593489d99cc3047": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fd58898564e14f91a2de5ef353915ee7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_72977439fc354dbe81b6f7e1c051b209", + "IPY_MODEL_29f90c5cc8e747a0ab22a7d7e6f1817b", + "IPY_MODEL_c079814cdff147f29bc359e80c0d939a" + ], + "layout": "IPY_MODEL_067db5ac65ff4bd989a502badf2ccead", + "tabbable": null, + "tooltip": null + } + }, + "fd645dbd466f4d53857b74abc5891616": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c6186a9115e840bc813315a474bcb455", + "placeholder": "​", + "style": "IPY_MODEL_894a2956493e4c9d8223a99014b5ae4a", + "tabbable": null, + "tooltip": null, + "value": " 481/499 [00:01<00:00, 361.66it/s]" + } + }, + "fd77ef4f213f4512b115fefe337a1d5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fd7f07c8304e4edc81106a886df8d71c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd933da07e674cddb3bcfa7d6eed1d67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdb22cf92086422f87a8e173bf688af4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fdb6e5e0a4774be38d1f2e2d05037d91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ad7aafb378f449f8cf7293f196a5510", + "placeholder": "​", + "style": "IPY_MODEL_cbcd4929cb02433ea2c8ddc1cac80849", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "fdbe2276e07f44be967abd7c5011727f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fdd0aa39b9ae426093657e1aa7180e8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fde3ed00fb8744af93a13077c0fb90ca": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe0e8914ddaf467ba7196560bee6b788": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fe0f230185f2470c963a01e6393ced04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fe16ea82eb63455bb85d4a926f4b8275": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe3eb75225554eeba1353933ba8056c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "fe78982fb27943eda4f9448dd2cafeac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe833ec08ef84467be5a41bc49e84336": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fe9a989ad2c64316bf1d9bd4fb2acf86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6d340030ab4a4a5c99c2a10b79695418", + "placeholder": "​", + "style": "IPY_MODEL_afd2ef8a040b4348bc98a17b1ff49021", + "tabbable": null, + "tooltip": null, + "value": " 971/999 [00:02<00:00, 319.31it/s]" + } + }, + "feb30733b37147bbab8f0a130c92bd05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "febe18d581124ae08879d49b0597307b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a5f7a5c23d0f4a1facc5a14763124c8b", + "placeholder": "​", + "style": "IPY_MODEL_d64dda5714dc445489d9627e65283507", + "tabbable": null, + "tooltip": null, + "value": " 36/69 [00:00<00:00, 352.06it/s]" + } + }, + "fed10a9fc2e149869e098e315605f5c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fede4f2d39114cada434c7f2a7fed07d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_290c3be5b2ff4f278a639007eb07ecb4", + "IPY_MODEL_01fe3f8bfc9441f3a6db7a92d65dcdab", + "IPY_MODEL_c6a5910106054e43a5c14f3e688b1297" + ], + "layout": "IPY_MODEL_38006af591a445688fbb47c5d6e5922e", + "tabbable": null, + "tooltip": null + } + }, + "fedfea87bb13469d99ed1b507605937c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fef876ee507e47a9839acc282b271da3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff0b589903de4b8180bbd0c368575aa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_97b2f9188b224719a6a73a98964a6c31", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_aba0cb800126442a8fb0da38129ac004", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "ff2cbdf66e284671a9581f68bbb8a921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_43a7fa9e28d74fe6984d4bc3504f6d0f", + "placeholder": "​", + "style": "IPY_MODEL_e26b0fff5a9b4bfcbc7bbb87709b7332", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "ffcac9706b364ca2894cfc605bd022a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3ee76f44e6c4434cb060a79c2b7db9bf", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_d43583f614804c7b9a15b16fc5d39c0c", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + } + }, + "version_major": 2, + "version_minor": 0 + } } }, "nbformat": 4, From 79c05a7505521d78d82b8679f67e0f98eb407ad3 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Fri, 28 Aug 2026 12:09:52 +0100 Subject: [PATCH 106/112] Improved benchmarking to pass pre-commit tests --- ...ring_misc_functions_in_rust_v_python.ipynb | 29353 ++++++++-------- 1 file changed, 14685 insertions(+), 14668 deletions(-) diff --git a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb index daf4a4c10..0726505bc 100644 --- a/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_misc_functions_in_rust_v_python.ipynb @@ -52,6 +52,23 @@ "\n" ] }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-28T11:03:12.185412Z", + "iopub.status.busy": "2026-08-28T11:03:12.185336Z", + "iopub.status.idle": "2026-08-28T11:03:12.187287Z", + "shell.execute_reply": "2026-08-28T11:03:12.186915Z" + } + }, + "outputs": [], + "source": [ + "step1 = 100\n", + "step2 = 1000" + ] + }, { "cell_type": "markdown", "metadata": { @@ -64,13 +81,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:46:50.190055Z", - "iopub.status.busy": "2026-08-28T10:46:50.189985Z", - "iopub.status.idle": "2026-08-28T10:46:52.298252Z", - "shell.execute_reply": "2026-08-28T10:46:52.297778Z" + "iopub.execute_input": "2026-08-28T11:03:12.188198Z", + "iopub.status.busy": "2026-08-28T11:03:12.188121Z", + "iopub.status.idle": "2026-08-28T11:03:14.191118Z", + "shell.execute_reply": "2026-08-28T11:03:14.190651Z" } }, "outputs": [], @@ -112,19 +129,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:46:52.299448Z", - "iopub.status.busy": "2026-08-28T10:46:52.299327Z", - "iopub.status.idle": "2026-08-28T10:46:52.778899Z", - "shell.execute_reply": "2026-08-28T10:46:52.778471Z" + "iopub.execute_input": "2026-08-28T11:03:14.192524Z", + "iopub.status.busy": "2026-08-28T11:03:14.192404Z", + "iopub.status.idle": "2026-08-28T11:03:14.584220Z", + "shell.execute_reply": "2026-08-28T11:03:14.583734Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -163,13 +180,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:46:52.795635Z", - "iopub.status.busy": "2026-08-28T10:46:52.795515Z", - "iopub.status.idle": "2026-08-28T10:46:53.358334Z", - "shell.execute_reply": "2026-08-28T10:46:53.357796Z" + "iopub.execute_input": "2026-08-28T11:03:14.601138Z", + "iopub.status.busy": "2026-08-28T11:03:14.600992Z", + "iopub.status.idle": "2026-08-28T11:03:15.020948Z", + "shell.execute_reply": "2026-08-28T11:03:15.020373Z" } }, "outputs": [], @@ -227,13 +244,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:46:53.359443Z", - "iopub.status.busy": "2026-08-28T10:46:53.359283Z", - "iopub.status.idle": "2026-08-28T10:46:53.361675Z", - "shell.execute_reply": "2026-08-28T10:46:53.361280Z" + "iopub.execute_input": "2026-08-28T11:03:15.022422Z", + "iopub.status.busy": "2026-08-28T11:03:15.022265Z", + "iopub.status.idle": "2026-08-28T11:03:15.024613Z", + "shell.execute_reply": "2026-08-28T11:03:15.024261Z" } }, "outputs": [], @@ -276,13 +293,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:46:53.362393Z", - "iopub.status.busy": "2026-08-28T10:46:53.362315Z", - "iopub.status.idle": "2026-08-28T10:47:06.355888Z", - "shell.execute_reply": "2026-08-28T10:47:06.355277Z" + "iopub.execute_input": "2026-08-28T11:03:15.025565Z", + "iopub.status.busy": "2026-08-28T11:03:15.025484Z", + "iopub.status.idle": "2026-08-28T11:03:27.921643Z", + "shell.execute_reply": "2026-08-28T11:03:27.921022Z" } }, "outputs": [], @@ -345,7 +362,7 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if num_patches < 100:\n", + " if num_patches < step1:\n", " num_patches += 10\n", " num_classes += 10\n", " else:\n", @@ -355,19 +372,19 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:06.357131Z", - "iopub.status.busy": "2026-08-28T10:47:06.357041Z", - "iopub.status.idle": "2026-08-28T10:47:06.401017Z", - "shell.execute_reply": "2026-08-28T10:47:06.400627Z" + "iopub.execute_input": "2026-08-28T11:03:27.923455Z", + "iopub.status.busy": "2026-08-28T11:03:27.923350Z", + "iopub.status.idle": "2026-08-28T11:03:27.967261Z", + "shell.execute_reply": "2026-08-28T11:03:27.966878Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -406,13 +423,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:06.401908Z", - "iopub.status.busy": "2026-08-28T10:47:06.401755Z", - "iopub.status.idle": "2026-08-28T10:47:06.404747Z", - "shell.execute_reply": "2026-08-28T10:47:06.404436Z" + "iopub.execute_input": "2026-08-28T11:03:27.968364Z", + "iopub.status.busy": "2026-08-28T11:03:27.968276Z", + "iopub.status.idle": "2026-08-28T11:03:27.971315Z", + "shell.execute_reply": "2026-08-28T11:03:27.970935Z" } }, "outputs": [], @@ -485,13 +502,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:06.405491Z", - "iopub.status.busy": "2026-08-28T10:47:06.405416Z", - "iopub.status.idle": "2026-08-28T10:47:06.407591Z", - "shell.execute_reply": "2026-08-28T10:47:06.407257Z" + "iopub.execute_input": "2026-08-28T11:03:27.972125Z", + "iopub.status.busy": "2026-08-28T11:03:27.972042Z", + "iopub.status.idle": "2026-08-28T11:03:27.974277Z", + "shell.execute_reply": "2026-08-28T11:03:27.973891Z" } }, "outputs": [], @@ -535,13 +552,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:06.408253Z", - "iopub.status.busy": "2026-08-28T10:47:06.408183Z", - "iopub.status.idle": "2026-08-28T10:47:09.858264Z", - "shell.execute_reply": "2026-08-28T10:47:09.857756Z" + "iopub.execute_input": "2026-08-28T11:03:27.975062Z", + "iopub.status.busy": "2026-08-28T11:03:27.974985Z", + "iopub.status.idle": "2026-08-28T11:03:31.338784Z", + "shell.execute_reply": "2026-08-28T11:03:31.338213Z" } }, "outputs": [], @@ -592,7 +609,7 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if num_patches < 100:\n", + " if num_patches < step1:\n", " num_patches += 10\n", " num_classes += 10\n", " else:\n", @@ -602,19 +619,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:09.859447Z", - "iopub.status.busy": "2026-08-28T10:47:09.859361Z", - "iopub.status.idle": "2026-08-28T10:47:09.903377Z", - "shell.execute_reply": "2026-08-28T10:47:09.902965Z" + "iopub.execute_input": "2026-08-28T11:03:31.340457Z", + "iopub.status.busy": "2026-08-28T11:03:31.340355Z", + "iopub.status.idle": "2026-08-28T11:03:31.384911Z", + "shell.execute_reply": "2026-08-28T11:03:31.384442Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -643,13 +660,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:09.904165Z", - "iopub.status.busy": "2026-08-28T10:47:09.904083Z", - "iopub.status.idle": "2026-08-28T10:47:09.906254Z", - "shell.execute_reply": "2026-08-28T10:47:09.905892Z" + "iopub.execute_input": "2026-08-28T11:03:31.385849Z", + "iopub.status.busy": "2026-08-28T11:03:31.385757Z", + "iopub.status.idle": "2026-08-28T11:03:31.388052Z", + "shell.execute_reply": "2026-08-28T11:03:31.387607Z" } }, "outputs": [], @@ -686,13 +703,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:09.906914Z", - "iopub.status.busy": "2026-08-28T10:47:09.906841Z", - "iopub.status.idle": "2026-08-28T10:47:09.908623Z", - "shell.execute_reply": "2026-08-28T10:47:09.908293Z" + "iopub.execute_input": "2026-08-28T11:03:31.388835Z", + "iopub.status.busy": "2026-08-28T11:03:31.388753Z", + "iopub.status.idle": "2026-08-28T11:03:31.390598Z", + "shell.execute_reply": "2026-08-28T11:03:31.390201Z" } }, "outputs": [], @@ -710,13 +727,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:09.909252Z", - "iopub.status.busy": "2026-08-28T10:47:09.909183Z", - "iopub.status.idle": "2026-08-28T10:47:09.910841Z", - "shell.execute_reply": "2026-08-28T10:47:09.910526Z" + "iopub.execute_input": "2026-08-28T11:03:31.391346Z", + "iopub.status.busy": "2026-08-28T11:03:31.391271Z", + "iopub.status.idle": "2026-08-28T11:03:31.392987Z", + "shell.execute_reply": "2026-08-28T11:03:31.392621Z" } }, "outputs": [], @@ -737,13 +754,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:09.911486Z", - "iopub.status.busy": "2026-08-28T10:47:09.911418Z", - "iopub.status.idle": "2026-08-28T10:47:10.459011Z", - "shell.execute_reply": "2026-08-28T10:47:10.458536Z" + "iopub.execute_input": "2026-08-28T11:03:31.393714Z", + "iopub.status.busy": "2026-08-28T11:03:31.393642Z", + "iopub.status.idle": "2026-08-28T11:03:31.834779Z", + "shell.execute_reply": "2026-08-28T11:03:31.834334Z" } }, "outputs": [], @@ -842,13 +859,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:10.460012Z", - "iopub.status.busy": "2026-08-28T10:47:10.459822Z", - "iopub.status.idle": "2026-08-28T10:47:10.462290Z", - "shell.execute_reply": "2026-08-28T10:47:10.461941Z" + "iopub.execute_input": "2026-08-28T11:03:31.836397Z", + "iopub.status.busy": "2026-08-28T11:03:31.836250Z", + "iopub.status.idle": "2026-08-28T11:03:31.838800Z", + "shell.execute_reply": "2026-08-28T11:03:31.838382Z" } }, "outputs": [], @@ -887,20 +904,20 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:47:10.462965Z", - "iopub.status.busy": "2026-08-28T10:47:10.462892Z", - "iopub.status.idle": "2026-08-28T10:49:46.196237Z", - "shell.execute_reply": "2026-08-28T10:49:46.195820Z" + "iopub.execute_input": "2026-08-28T11:03:31.839629Z", + "iopub.status.busy": "2026-08-28T11:03:31.839546Z", + "iopub.status.idle": "2026-08-28T11:06:08.152874Z", + "shell.execute_reply": "2026-08-28T11:06:08.152360Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "393b37c2fb0c4f5dafcc3aea04998786", + "model_id": "278a6ffa1b8c4cf386e19e0bddb382ff", "version_major": 2, "version_minor": 0 }, @@ -914,7 +931,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d65ca456eec34b87992aa27dc021c7b0", + "model_id": "9e6b5a443dea4b588cd7fb348154d4c4", "version_major": 2, "version_minor": 0 }, @@ -928,7 +945,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ddbe68e1a1064b2d8c3a9d8a267a67c8", + "model_id": "42f6bd9a8f63422d885de865327c8519", "version_major": 2, "version_minor": 0 }, @@ -942,7 +959,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ba73e26ed5a943ac938e140c55843c02", + "model_id": "b2fe64d58aa044118a38cebcbaddd29c", "version_major": 2, "version_minor": 0 }, @@ -956,7 +973,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "51c47b104e7a40a1a949ecdf24c4b360", + "model_id": "63a39158402f47afb50aceaa9c4599f7", "version_major": 2, "version_minor": 0 }, @@ -970,7 +987,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0563ab96bb5f4cd0a9f2ce2da290a240", + "model_id": "1e37aafd22f6451b886162c9c47f6df1", "version_major": 2, "version_minor": 0 }, @@ -984,7 +1001,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "777b18b6acfa4d4fb711d81c6cb170f9", + "model_id": "060c4d711a4a4a2089a8762d28cf28a1", "version_major": 2, "version_minor": 0 }, @@ -998,7 +1015,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "70f12c89e3af482c8bc0ec35da4cf5ba", + "model_id": "02c59e8839a547448182ebe6c3d275a2", "version_major": 2, "version_minor": 0 }, @@ -1012,7 +1029,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9bc6ebd59e4f4005a21c9446fdccd958", + "model_id": "adb0ccf8ab734a9fbda3727d2733decc", "version_major": 2, "version_minor": 0 }, @@ -1026,7 +1043,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6b46da5e916f4a58bc0f661400a2b780", + "model_id": "63cf240a664144609b570f6bac45f597", "version_major": 2, "version_minor": 0 }, @@ -1040,7 +1057,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1f53a34375ef477184c006926f62ac15", + "model_id": "fd032fa795b84d8db167fb8b963e5917", "version_major": 2, "version_minor": 0 }, @@ -1054,7 +1071,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5b1d8dbe3381429bb94ef4b4290349bd", + "model_id": "121d5315dfbd4cb98ca39735e43db5eb", "version_major": 2, "version_minor": 0 }, @@ -1068,7 +1085,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5e13bb5c391c4e04a8ac6c0836bb1d8f", + "model_id": "56c4b383adf44a5198e04adf9a4c072c", "version_major": 2, "version_minor": 0 }, @@ -1082,7 +1099,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2a92c6051e9849b9a9fdb69ea34e1a24", + "model_id": "19956e1d85644868acd194f5b2b35523", "version_major": 2, "version_minor": 0 }, @@ -1096,7 +1113,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "da119b753ebc4fab9670940cd90206dc", + "model_id": "cbf046394c764635801e3e2d509ffe01", "version_major": 2, "version_minor": 0 }, @@ -1110,7 +1127,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8618600335164da2b72cb3db70edf98c", + "model_id": "6c24fcf5223645afb8d7245f88f1036b", "version_major": 2, "version_minor": 0 }, @@ -1124,7 +1141,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8ef6227139994ec2b5879afe2a1294e7", + "model_id": "ee621c769b2f4e2eb6ac1527bd12c681", "version_major": 2, "version_minor": 0 }, @@ -1138,7 +1155,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "89c1205e28c94a9fbbc1e67a716a2aa2", + "model_id": "cb6e24d8a07d49b7aa6e4275131dceae", "version_major": 2, "version_minor": 0 }, @@ -1152,7 +1169,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a51b4cbcf05f4046a4623771929e5cf5", + "model_id": "30ad7c40e4624ac2b5087aafdad39c2b", "version_major": 2, "version_minor": 0 }, @@ -1166,7 +1183,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fede4f2d39114cada434c7f2a7fed07d", + "model_id": "014a73554b5c42c1bea738f40927d8a6", "version_major": 2, "version_minor": 0 }, @@ -1180,7 +1197,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dcfd30625b0d4bcc846d80ed17da009f", + "model_id": "ea8954dcf9cf4fa593726ee10684bcbe", "version_major": 2, "version_minor": 0 }, @@ -1194,7 +1211,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "22edab40b3914d349aa684b441522e7e", + "model_id": "02ec68869d9948b58ec365abbc9f4dbc", "version_major": 2, "version_minor": 0 }, @@ -1208,7 +1225,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "495733dc2b184e1c8314e2a1d1f93d9e", + "model_id": "6c3a197e403e49c098636b5be9572818", "version_major": 2, "version_minor": 0 }, @@ -1222,7 +1239,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0c83849d2aac453b9384639ee6bb8cca", + "model_id": "a0eb39e0dfef4db7856aef0eede98f0a", "version_major": 2, "version_minor": 0 }, @@ -1236,7 +1253,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7bc2fed1bee6438e920225161b18814e", + "model_id": "1b92b86db8634e28ac634759ce47d41f", "version_major": 2, "version_minor": 0 }, @@ -1250,7 +1267,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cebf00b01b754b50978d3e6b980d98b4", + "model_id": "00018d66c6ba4416a89b82dfff6b4ce7", "version_major": 2, "version_minor": 0 }, @@ -1264,7 +1281,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b7ced44e9d9145e69c0f7cd2a3ab33fd", + "model_id": "303cad02f2c8469e95efd4070437e40e", "version_major": 2, "version_minor": 0 }, @@ -1278,7 +1295,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "510d7d38baa440afafb811da674ea47f", + "model_id": "a46c0ff35f684db3b80c1b3c249b2383", "version_major": 2, "version_minor": 0 }, @@ -1292,7 +1309,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4e5cdd3c399d4f3aafc93bef4b165447", + "model_id": "6a537fd1a1c249d88bc22d4690a76b75", "version_major": 2, "version_minor": 0 }, @@ -1306,7 +1323,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1b157ac0610f4547bd00b2c6af8c929b", + "model_id": "5e6bc7eea5794a1885339cc12a01bb4d", "version_major": 2, "version_minor": 0 }, @@ -1320,7 +1337,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d5e34eb5c8f248b995600255374e1cb2", + "model_id": "a51a11dbdc1d4446b3ccbfbb9ab83536", "version_major": 2, "version_minor": 0 }, @@ -1334,7 +1351,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "55cfa4f5cb9f47e5baa83d7a7be485d2", + "model_id": "68afcc9f2dbe4030982ece5bc7294ce3", "version_major": 2, "version_minor": 0 }, @@ -1348,7 +1365,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "49abcf503bcd43af9c7aa11f4e5a4220", + "model_id": "f887f18477de4d3fa8e1945ce09cbbef", "version_major": 2, "version_minor": 0 }, @@ -1362,7 +1379,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec43535fa727495ea79cd60300bf312a", + "model_id": "75c87d59d5fd45bb8890383755e748b8", "version_major": 2, "version_minor": 0 }, @@ -1376,7 +1393,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4a306080bd6543b786e5313f8b89fd6d", + "model_id": "875c68cbdfcc4f289ae2b40519388d4d", "version_major": 2, "version_minor": 0 }, @@ -1390,7 +1407,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6a6c374cac544ee18a1f2313bbd4e9c4", + "model_id": "0622939b090f45c3970397baf7a64815", "version_major": 2, "version_minor": 0 }, @@ -1404,7 +1421,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ae0e27e36ad64d11b539cc8bbef4ba18", + "model_id": "fbb2934f82554655af4a00d42652960a", "version_major": 2, "version_minor": 0 }, @@ -1418,7 +1435,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bde3343143414690b98e52981d1e8a00", + "model_id": "a2143e05ba7f4a7b97a6eaba83b239cf", "version_major": 2, "version_minor": 0 }, @@ -1432,7 +1449,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8c5a8111755e4b539ef3fd3c91590b87", + "model_id": "cd15bcfba3794c6f8fe2dc68d5a4b0dc", "version_major": 2, "version_minor": 0 }, @@ -1446,7 +1463,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6545213986fc431b9109dc7b527a4892", + "model_id": "53cb05b20b374b00a98c1755ba735806", "version_major": 2, "version_minor": 0 }, @@ -1460,7 +1477,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0866b3ae2bb64864bc472d1e3501d49b", + "model_id": "2d4107fde9bb45f8899567b6ce72c654", "version_major": 2, "version_minor": 0 }, @@ -1474,7 +1491,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e6c34a76e2174f35880a463faf8e5f36", + "model_id": "576848cb3f21455ca2101929d6aa2d78", "version_major": 2, "version_minor": 0 }, @@ -1488,7 +1505,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "77db329df29b48f1b21c6585dd05d327", + "model_id": "0d6c5c8a761b4d42896494df7083ed51", "version_major": 2, "version_minor": 0 }, @@ -1502,7 +1519,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a9262ac2952b4d09b5a52834601ee8e0", + "model_id": "c1c427152bd44c81acc3d373e40ffbbe", "version_major": 2, "version_minor": 0 }, @@ -1516,7 +1533,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "39493560285a4d9d98d4d7c4ac978c05", + "model_id": "a2dd8cfd816643a19f694ee065601bd8", "version_major": 2, "version_minor": 0 }, @@ -1530,7 +1547,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5f40d946a8204222abcaded839a22705", + "model_id": "674a2712d76f44bb94bd695d018caa0c", "version_major": 2, "version_minor": 0 }, @@ -1544,7 +1561,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e32d08044d8d43dc84641a3567ae8c00", + "model_id": "58175a1777af4c3086919ae6c696130e", "version_major": 2, "version_minor": 0 }, @@ -1558,7 +1575,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7712728c73144961a6cd32df93caba86", + "model_id": "aa4533f4b72d4b1684637a977bc435c5", "version_major": 2, "version_minor": 0 }, @@ -1572,7 +1589,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2f7a26e9f83e4eac93525a1577b6d1cd", + "model_id": "851ab66845154dd691d6ec663432077f", "version_major": 2, "version_minor": 0 }, @@ -1586,7 +1603,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cf3b4a67086448cebe38bc0df9b57135", + "model_id": "b65f8956fffc4557be6416270b68e2ef", "version_major": 2, "version_minor": 0 }, @@ -1600,7 +1617,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5f3946b11d7d4208add0431c3b69b31c", + "model_id": "ebdf08a16ab64e0db85ae8b85538ef20", "version_major": 2, "version_minor": 0 }, @@ -1614,7 +1631,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6cafb5e03115448cbe616cef3548c178", + "model_id": "6801dff3175545f69d35d3219e3d7fcd", "version_major": 2, "version_minor": 0 }, @@ -1628,7 +1645,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "49588eb8c2ab4615b4ca1692512c2a4f", + "model_id": "c362d1e3e37e4187a2d162b1392ce90d", "version_major": 2, "version_minor": 0 }, @@ -1642,7 +1659,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "00fa80e77f7741519634dfcf9bad01de", + "model_id": "4f519f6a766540369cfe7213bb71f585", "version_major": 2, "version_minor": 0 }, @@ -1656,7 +1673,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1a0dc3042dc7417b8ca7c20f1483b07a", + "model_id": "5a9efa63bd7744b4a8933e5127d207ec", "version_major": 2, "version_minor": 0 }, @@ -1670,7 +1687,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0223917d2f4457e9e236222d44b7f3c", + "model_id": "de1a1c817fbb4acfb3e4678bb3a01159", "version_major": 2, "version_minor": 0 }, @@ -1684,7 +1701,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a682d84851a44defa0ccc688483ab9cf", + "model_id": "4fce76ee3b3e4d64bde923d782c9263e", "version_major": 2, "version_minor": 0 }, @@ -1698,7 +1715,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c468ce2f3f1d4246986e60c4c72b86ae", + "model_id": "4ff9e589864a422189a7f4852d707302", "version_major": 2, "version_minor": 0 }, @@ -1712,7 +1729,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "486681b56e12490180a20aaf942c89aa", + "model_id": "da10211b30a94c14b4b35b2de142b061", "version_major": 2, "version_minor": 0 }, @@ -1726,7 +1743,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "059d0fbaeccd4aeea43f24e93d191b08", + "model_id": "c4ae7aef6b4344d2a097751d7aa41aae", "version_major": 2, "version_minor": 0 }, @@ -1740,7 +1757,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bfc944d484a94e58bd83f79ca47ea60b", + "model_id": "33907522e43748b5a2b6b28dfb6748e1", "version_major": 2, "version_minor": 0 }, @@ -1754,7 +1771,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3f72018e6e5a46fbbebb5f8d402f7757", + "model_id": "6384b8016185409587f1011522ed5683", "version_major": 2, "version_minor": 0 }, @@ -1768,7 +1785,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "85e2e887e88b4cfebb0f86edb7894d9b", + "model_id": "fbcbb33574a24095b51d554f0ed7be27", "version_major": 2, "version_minor": 0 }, @@ -1782,7 +1799,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2de0d0d0c2f44cf69f01ede67f25b002", + "model_id": "9542360425234377a470cf10f3b02b36", "version_major": 2, "version_minor": 0 }, @@ -1796,7 +1813,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fc0ecbcdd8804a4ca291c51e12bce4c6", + "model_id": "b2fd804650fe41eaa214942cc13f595c", "version_major": 2, "version_minor": 0 }, @@ -1810,7 +1827,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "745240905efa4d70951fed68152308a7", + "model_id": "b879ae9000e04638b07a607f0d89ccd0", "version_major": 2, "version_minor": 0 }, @@ -1824,7 +1841,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6e9bb6066bdf49c88efe29f269344687", + "model_id": "15345c59a009437c88d924df885b75bf", "version_major": 2, "version_minor": 0 }, @@ -1838,7 +1855,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0d5b733a0be84859b36df24d1a76e762", + "model_id": "e6c16a3b5ae94f509c3d116e22bee998", "version_major": 2, "version_minor": 0 }, @@ -1852,7 +1869,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a9d0b4ec984d4c318c970a4757df9d13", + "model_id": "dfdb2b109c3a413ea87fcc4b2de5260e", "version_major": 2, "version_minor": 0 }, @@ -1866,7 +1883,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c3c7fd263831473a8499892f20bc17d4", + "model_id": "2c04fe33220c4c43b72455c79f25c61a", "version_major": 2, "version_minor": 0 }, @@ -1880,7 +1897,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "062dda88b8404d12a8d6f135b976191f", + "model_id": "d8baba81a7db4e5bb40b757c58935229", "version_major": 2, "version_minor": 0 }, @@ -1894,7 +1911,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c3457131356c451c96a4118222ec5184", + "model_id": "fe821a7c58dd40079ae4d7692425a9c3", "version_major": 2, "version_minor": 0 }, @@ -1908,7 +1925,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "897daa6ded384f73b2907776c86a1823", + "model_id": "4e2da43f92c34074851aa86f5cb9f44c", "version_major": 2, "version_minor": 0 }, @@ -1922,7 +1939,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c8c46930c8114b418e073703a77d938f", + "model_id": "717487e4c2c14329a81d3d95f13dfd64", "version_major": 2, "version_minor": 0 }, @@ -1936,7 +1953,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b5c37a10a2294bfb88e0a513d9d34e30", + "model_id": "988ad3fd739e4c34ab91bdacc6268a99", "version_major": 2, "version_minor": 0 }, @@ -1950,7 +1967,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a29586ff07d8448f93ce88eb1d9b3405", + "model_id": "daf3a28c1ca94ab88a54ec5d9403bd88", "version_major": 2, "version_minor": 0 }, @@ -1964,7 +1981,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "69cf359906074f75b6be86e700d6a417", + "model_id": "6db9de00a119405a8a5e66846bdf8128", "version_major": 2, "version_minor": 0 }, @@ -1978,7 +1995,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "df3524274cd44265a1ddbb836776e1bd", + "model_id": "dbafc86815ca45719c9e6a7fe2696045", "version_major": 2, "version_minor": 0 }, @@ -1992,7 +2009,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8dd11c0ad50b40f4b046b2dc9192f1a4", + "model_id": "3159a15269e34291a3134c2c21bb5739", "version_major": 2, "version_minor": 0 }, @@ -2006,7 +2023,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4f8324d810b84b8e8d1368fe8de84d8e", + "model_id": "a9083826b8b54ed1877eda78417661ab", "version_major": 2, "version_minor": 0 }, @@ -2020,7 +2037,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f8dcb2847ef1484ca610ae70720a8b85", + "model_id": "40ba86d0e11a4a32b5fb7b68ce0815ad", "version_major": 2, "version_minor": 0 }, @@ -2034,7 +2051,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a90d8a4ab2b54abab95419fb2e366e60", + "model_id": "609e0079f5de4169bb61f0ddd99c843a", "version_major": 2, "version_minor": 0 }, @@ -2048,7 +2065,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "200cd5fcaec74d1bb60f371831b3926d", + "model_id": "7ab05e2a4cdd4bfd883167f38ef76a13", "version_major": 2, "version_minor": 0 }, @@ -2062,7 +2079,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "78e58664ca7f48c388cab93235a0af8f", + "model_id": "480285c93775454b81ffb69463b191f3", "version_major": 2, "version_minor": 0 }, @@ -2076,7 +2093,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "371b6730e42945b884be6787e8846e12", + "model_id": "813aede5e317485cb728287ec1b4ee6b", "version_major": 2, "version_minor": 0 }, @@ -2090,7 +2107,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1d5faaed9b6c423e825a6a573133ae96", + "model_id": "a5b7b301923542088c00c4a38bd01cf4", "version_major": 2, "version_minor": 0 }, @@ -2104,7 +2121,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9eee605f30bc412aa48d9ff2fe8683ca", + "model_id": "4ea6e90d0e034f8fbbeec3ae469195d8", "version_major": 2, "version_minor": 0 }, @@ -2118,7 +2135,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5750eea408884bc29ffd6453c8f0d628", + "model_id": "5ce50900ba6b4afe819c98739d371acd", "version_major": 2, "version_minor": 0 }, @@ -2132,7 +2149,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "af3de1ec3b064b26a4c80a88601cbd29", + "model_id": "3fbaec84487441158fbb5aae8c259403", "version_major": 2, "version_minor": 0 }, @@ -2146,7 +2163,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "495cb904c28440eaae52abb0f40840f7", + "model_id": "3d183ba506914a43a5251340be95b25a", "version_major": 2, "version_minor": 0 }, @@ -2160,7 +2177,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "67dddc48ed9944748afc25e1d75ff05b", + "model_id": "98cabba1994245fa8898c1621e7d6472", "version_major": 2, "version_minor": 0 }, @@ -2174,7 +2191,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ed0994b856054eddb92f8604e0cec538", + "model_id": "01ab757ca5da461e8b768a1fa474ffb7", "version_major": 2, "version_minor": 0 }, @@ -2188,7 +2205,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e93cc4a88cad4dbd8383789e40ea66f0", + "model_id": "c4ce70f380c14c1b9c6d133b1a2370d9", "version_major": 2, "version_minor": 0 }, @@ -2202,7 +2219,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b94a03dbfdc7464881d3d95a8deea5e1", + "model_id": "420b82723a9f4f2f8cafcb441f856a20", "version_major": 2, "version_minor": 0 }, @@ -2216,7 +2233,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d7f0556fc6ad4758b8a7cda07ba539f4", + "model_id": "f1296249c4714d8792decf672544a3fa", "version_major": 2, "version_minor": 0 }, @@ -2312,7 +2329,7 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if num_patches < 100:\n", + " if num_patches < step1:\n", " num_patches += 10\n", " num_classes += 10\n", " else:\n", @@ -2322,19 +2339,19 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.197650Z", - "iopub.status.busy": "2026-08-28T10:49:46.197562Z", - "iopub.status.idle": "2026-08-28T10:49:46.236199Z", - "shell.execute_reply": "2026-08-28T10:49:46.235926Z" + "iopub.execute_input": "2026-08-28T11:06:08.154469Z", + "iopub.status.busy": "2026-08-28T11:06:08.154378Z", + "iopub.status.idle": "2026-08-28T11:06:08.193074Z", + "shell.execute_reply": "2026-08-28T11:06:08.192742Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2363,13 +2380,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.237061Z", - "iopub.status.busy": "2026-08-28T10:49:46.236982Z", - "iopub.status.idle": "2026-08-28T10:49:46.238684Z", - "shell.execute_reply": "2026-08-28T10:49:46.238435Z" + "iopub.execute_input": "2026-08-28T11:06:08.194159Z", + "iopub.status.busy": "2026-08-28T11:06:08.194077Z", + "iopub.status.idle": "2026-08-28T11:06:08.195869Z", + "shell.execute_reply": "2026-08-28T11:06:08.195530Z" } }, "outputs": [], @@ -2391,13 +2408,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.239371Z", - "iopub.status.busy": "2026-08-28T10:49:46.239303Z", - "iopub.status.idle": "2026-08-28T10:49:46.244509Z", - "shell.execute_reply": "2026-08-28T10:49:46.244234Z" + "iopub.execute_input": "2026-08-28T11:06:08.196623Z", + "iopub.status.busy": "2026-08-28T11:06:08.196551Z", + "iopub.status.idle": "2026-08-28T11:06:08.201678Z", + "shell.execute_reply": "2026-08-28T11:06:08.201388Z" } }, "outputs": [], @@ -2520,13 +2537,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.245229Z", - "iopub.status.busy": "2026-08-28T10:49:46.245115Z", - "iopub.status.idle": "2026-08-28T10:49:46.247613Z", - "shell.execute_reply": "2026-08-28T10:49:46.247388Z" + "iopub.execute_input": "2026-08-28T11:06:08.202472Z", + "iopub.status.busy": "2026-08-28T11:06:08.202396Z", + "iopub.status.idle": "2026-08-28T11:06:08.204925Z", + "shell.execute_reply": "2026-08-28T11:06:08.204654Z" } }, "outputs": [], @@ -2589,13 +2606,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.248234Z", - "iopub.status.busy": "2026-08-28T10:49:46.248164Z", - "iopub.status.idle": "2026-08-28T10:49:46.250187Z", - "shell.execute_reply": "2026-08-28T10:49:46.249973Z" + "iopub.execute_input": "2026-08-28T11:06:08.205770Z", + "iopub.status.busy": "2026-08-28T11:06:08.205695Z", + "iopub.status.idle": "2026-08-28T11:06:08.207765Z", + "shell.execute_reply": "2026-08-28T11:06:08.207493Z" } }, "outputs": [], @@ -2639,20 +2656,20 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:49:46.250784Z", - "iopub.status.busy": "2026-08-28T10:49:46.250714Z", - "iopub.status.idle": "2026-08-28T10:50:48.228195Z", - "shell.execute_reply": "2026-08-28T10:50:48.227827Z" + "iopub.execute_input": "2026-08-28T11:06:08.208540Z", + "iopub.status.busy": "2026-08-28T11:06:08.208470Z", + "iopub.status.idle": "2026-08-28T11:07:10.764491Z", + "shell.execute_reply": "2026-08-28T11:07:10.763942Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8c34e8f0b5774faca5891cd7a6239b88", + "model_id": "ecad90018cdc46e0ad507d651eb19f1f", "version_major": 2, "version_minor": 0 }, @@ -2666,7 +2683,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8a18ffdbb37642bba04ea599e5538b68", + "model_id": "7ae345151c5a46afad1a453ade8be695", "version_major": 2, "version_minor": 0 }, @@ -2680,7 +2697,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "18f9076b3e5c4efa9772a28815505070", + "model_id": "8ce8f7bcbb054863b63a46a3cd231d0a", "version_major": 2, "version_minor": 0 }, @@ -2694,7 +2711,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "76ef200b1a9b445eab8e50b258b02c92", + "model_id": "331052cac0b042958e63dbc99fab3188", "version_major": 2, "version_minor": 0 }, @@ -2708,7 +2725,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a9ed73f78a6a49b3b2f36919f6e0cc18", + "model_id": "c76331bbc2b049788ae8560b9fd55e05", "version_major": 2, "version_minor": 0 }, @@ -2722,7 +2739,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a7931ba0d9754c17bcdb4e91c4d5a5db", + "model_id": "1524e9bdcbc74c67a7d05275006c5905", "version_major": 2, "version_minor": 0 }, @@ -2736,7 +2753,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fd58898564e14f91a2de5ef353915ee7", + "model_id": "37978aa28d9f40289314991befcdaf25", "version_major": 2, "version_minor": 0 }, @@ -2750,7 +2767,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2eee24513db1454dab4e04b9a357172e", + "model_id": "01e4f1bc2f974d9ea6fb9184094f7764", "version_major": 2, "version_minor": 0 }, @@ -2764,7 +2781,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2e14f23461204db0b7c93b459e20c2c4", + "model_id": "14143480bc66483c9a574f4f2985b558", "version_major": 2, "version_minor": 0 }, @@ -2778,7 +2795,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f131e376ab0b4b99bba21834c0badf63", + "model_id": "a4b21b8e95604668b3aa35cc3f8d3cc5", "version_major": 2, "version_minor": 0 }, @@ -2792,7 +2809,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "90bf76864db94a7b94fc22af8067ae8e", + "model_id": "3dc07c6aa8094e5b8a7d6ebbcbbbab16", "version_major": 2, "version_minor": 0 }, @@ -2806,7 +2823,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "aaf48d038b0045e697d3f60c20e8e1f0", + "model_id": "6ed6e46243f3408ea9d7bfa6037d2e7b", "version_major": 2, "version_minor": 0 }, @@ -2820,7 +2837,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9c081ca24bd74659a65bb864ad786a9f", + "model_id": "4c4dc3c884884a8fa3719a3cb160b6ea", "version_major": 2, "version_minor": 0 }, @@ -2834,7 +2851,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1f8858dbcbf54a4daea0d698396e3d0e", + "model_id": "32c2452decb440bc843401b38110ecce", "version_major": 2, "version_minor": 0 }, @@ -2848,7 +2865,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "684e2d618bd640bcb736ac88afab5769", + "model_id": "a3b75fd89b9d4c71b5b62e7e37e0d3ba", "version_major": 2, "version_minor": 0 }, @@ -2862,7 +2879,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c5005137026143fba21d826016c63a74", + "model_id": "3bc7f7abb024459caf0091216f325977", "version_major": 2, "version_minor": 0 }, @@ -2876,7 +2893,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6a58bb9506034a7a9a236632ec663b53", + "model_id": "684dc2d3caa84db0964a014a338efaa3", "version_major": 2, "version_minor": 0 }, @@ -2890,7 +2907,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0db8d88810a3451c80f64a5362480743", + "model_id": "50d72866770d4e48819b115a032d3f72", "version_major": 2, "version_minor": 0 }, @@ -2904,7 +2921,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cf1a7d94e72841658cd8b9b9a641400e", + "model_id": "d40abf57cebd453e97820cfa59293dda", "version_major": 2, "version_minor": 0 }, @@ -2918,7 +2935,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3f037bc37ae64ff685d559b9f354f945", + "model_id": "d327c6ddffaf4d00ba2af3aa0acc0971", "version_major": 2, "version_minor": 0 }, @@ -2932,7 +2949,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f24982c181324287b4cb2411ea291384", + "model_id": "b19f60f6b4a94cf0b18f3f534c44a4af", "version_major": 2, "version_minor": 0 }, @@ -2946,7 +2963,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "baaa56c7ee104ec59d9d586ec56a72d4", + "model_id": "cd226cc365dd4eccb39f625c8c03326d", "version_major": 2, "version_minor": 0 }, @@ -2960,7 +2977,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "acbf1653664b439483f72287bb24dd6a", + "model_id": "3fdbc5a11b1245979b23f1f3aa56f5c1", "version_major": 2, "version_minor": 0 }, @@ -2974,7 +2991,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c68e2ef7a47c419391782502effd9fbc", + "model_id": "b2cf2528a6f747378071157f32031170", "version_major": 2, "version_minor": 0 }, @@ -2988,7 +3005,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "abad997f6dc64f9c94624291452d15c1", + "model_id": "a466639fdbd94435a5c10cdfbd0c90cd", "version_major": 2, "version_minor": 0 }, @@ -3002,7 +3019,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ead2cdd756d94dc1a61fe64e12eb1ef7", + "model_id": "3523e2269a9f4e819e0a8aef0f26671b", "version_major": 2, "version_minor": 0 }, @@ -3016,7 +3033,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0473d4a6bbe4cc3be07eaceb2d6a35a", + "model_id": "ee3d8fa788384c6383e9b7c3749b0bc5", "version_major": 2, "version_minor": 0 }, @@ -3030,7 +3047,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9a7df1ecff3049c494786d0df894f99c", + "model_id": "e28bf1986bb044b5b1f74c8f7596c174", "version_major": 2, "version_minor": 0 }, @@ -3044,7 +3061,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b8e9adbd4b3847be9c9c309e2153ee49", + "model_id": "3e74d3ad3edb458e95f869031ef2ec71", "version_major": 2, "version_minor": 0 }, @@ -3058,7 +3075,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e9ed2d3b26914df18a247d134a39d762", + "model_id": "9b5aedfc554849d5a60bf07d7c402c66", "version_major": 2, "version_minor": 0 }, @@ -3072,7 +3089,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dc0a4d403d8b41058913fcde3e7c441f", + "model_id": "96b70992ca594ea3a9b72e3c98a47a42", "version_major": 2, "version_minor": 0 }, @@ -3086,7 +3103,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0194287cfbf349ba9a6b415bea46ab81", + "model_id": "e4df00b8a9b14f55abeb6a5e710702c6", "version_major": 2, "version_minor": 0 }, @@ -3100,7 +3117,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "60238fd9fe024b299ca30723f24441f2", + "model_id": "29e24014d7fe4d3197d1c0a9ff16eb6b", "version_major": 2, "version_minor": 0 }, @@ -3114,7 +3131,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "11a731d616f640199f64e0145367c5ee", + "model_id": "a4aa8b3328bd493d9f7eb4031638da2b", "version_major": 2, "version_minor": 0 }, @@ -3128,7 +3145,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f5d34dcb783c458fb360983cb881e41d", + "model_id": "be1e5bc6e6034cf39656188cd765c137", "version_major": 2, "version_minor": 0 }, @@ -3142,7 +3159,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f1ce1746bd4c49c6b3f183d3c7add171", + "model_id": "5e9ce21abde14e9ea85ae05639813bee", "version_major": 2, "version_minor": 0 }, @@ -3156,7 +3173,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3dba60b55ea44aa0bea85513c47993fb", + "model_id": "1c9cd3297f6e48dfb0dce6261805b40d", "version_major": 2, "version_minor": 0 }, @@ -3170,7 +3187,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f91b5415a4444a2b9838403c8d4a82bf", + "model_id": "e2f14e49a5ca45e2b73680a3de3dba8b", "version_major": 2, "version_minor": 0 }, @@ -3263,7 +3280,7 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(num_patches)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if num_patches < 100:\n", + " if num_patches < step1:\n", " num_patches += 10\n", " num_classes += 10\n", " else:\n", @@ -3273,19 +3290,19 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.229507Z", - "iopub.status.busy": "2026-08-28T10:50:48.229423Z", - "iopub.status.idle": "2026-08-28T10:50:48.267784Z", - "shell.execute_reply": "2026-08-28T10:50:48.267553Z" + "iopub.execute_input": "2026-08-28T11:07:10.766040Z", + "iopub.status.busy": "2026-08-28T11:07:10.765947Z", + "iopub.status.idle": "2026-08-28T11:07:10.804526Z", + "shell.execute_reply": "2026-08-28T11:07:10.804127Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaYNJREFUeJzt3Xd0FGXfxvHvpiekEQiEEnroofeO0kGlCCoWRMGCYsEGdlREELFhFyyoDyrSBBSk915C6J0QSmjpfXfeP+YlGmoC2WyyuT7ncM4zs/fM/WPlIRczd7EYhmEgIiIi4iRcHF2AiIiISF5SuBERERGnonAjIiIiTkXhRkRERJyKwo2IiIg4FYUbERERcSoKNyIiIuJUFG5ERETEqbg5ugBHsNlsnDhxAj8/PywWi6PLERERkRwwDIOEhATKli2Li8vVn88UyXBz4sQJQkNDHV2GiIiI3ICoqCjKly9/1c+LZLjx8/MDzC/H39/fwdWIiIhITsTHxxMaGpr1c/xqimS4ufgqyt/fX+FGRESkkLnekBINKBYRERGnonAjIiIiTkXhRkRERJxKkRxzkxM2m4309HRHl1Ekubu74+rq6ugyRESkkFK4uYL09HQOHz6MzWZzdClFVmBgICEhIVqHSEREck3h5hKGYXDy5ElcXV0JDQ295iJBkvcMwyA5OZmYmBgAypQp4+CKRESksFG4uURmZibJycmULVsWHx8fR5dTJHl7ewMQExNDqVKl9IpKRERyRY8lLmG1WgHw8PBwcCVF28VgmZGR4eBKRESksFG4uQqN9XAsff8iInKjFG7kqiZOnMiMGTMcXYaIiEiuaMyNk/juu+9YvXo1YE6lDg0NpU+fPtSqVStH13/66aeUKlWKu+66K+vc/PnzadKkCX379rVLzSIiIvagJzdOYvny5axcuZIWLVpQr149IiMjCQ8PZ+bMmTm6fsGCBaxdu9bOVYqIiNifntw4kTJlyjBkyBAAHn/8cRITE3nrrbfw8fFh+fLlvPvuu9na//zzz0RHRxMcHExERARHjhzJuv6dd97Jards2TIWLVqE1Wqlf//+NGrUKNt9IiMj+fXXXzl//jz16tXjgQceyJrxBObrrUqVKhEUFHTN+4iISOG343gc26IucH/LSg6rQU9unFjdunWJioqiSpUqjB07lsjIyKzPbDYbo0aNws3NjapVq1K8eHHKlClDixYtaNGiRVY4+emnn3jzzTcpUaIE586do0WLFmzZsiXrPn/99ReNGjXi5MmTVKpUiUmTJtGmTZtsqzvPnz+fp5566pr3ERGRwi0908bEhXvp/flq3pizk21RsQ6rRU9ursMwDFIyrA7p29vd9YZnDVmtVhYvXkzdunUJCwujXbt2TJkyhYkTJwLwzz//cOrUKe6//36Cg4MJDQ2lWrVqWU9uLgoKCmLx4sVZa80cOHCAH374gUaNGmEYBk899RRPPfUUEyZMAGDo0KFUrlyZr7/+mieffDJH9xERkcJt54k4nvttO3tOJQDQs14ZQot7X+cq+1G4uY6UDCu1X1/gkL53vdUVH4+c/yfau3cvQ4YMITMzk3Xr1hEXF8e8efMAM3SMGDGCcePG4e7uzpQpU+jVqxfBwcHXvGfHjh2zLaJXo0YNjh8/DkB0dDQHDhzgnnvuyfo8MDCQnj17snz58mzh5lr3ERGRwinDauOLZQf5ZPF+Mm0GxX3cebt3XXrVK+vQuhRunIi/vz8tWrTA3d2d+++/n1atWmW9XrrzzjsZPnw4f/75Jx06dGD27NlMnz79uvf879gZAFdX16yFDi9ukVCyZMlsbUqWLHnZK6dr3UdERAqfvacSeO73bURGxwPQtU5p3ukdTrCfp4MrU7i5Lm93V3a91dVhfefGfwcUX8rLy4v77ruPKVOmEB0dTVBQEN27d8/6/EZef4WGhgJw9OhRKlasmHX+6NGjVKhQIdf3ExGRgi/TauOrFYf4eNF+0q02ArzdeeuOOtxev2yBWYBV4eY6LBZLrl4NFWRDhw6lUaNG7N27l0GDBmV7TRQUFMT58+dzdb/g4GDatWvHxx9/TJs2bXBxcWH37t3Mnz+fadOm5XX5IiLiYAdiEnju9wi2//9g4VtrlmJs33BK+Xs5trBLOMdPbcmRevXq0bBhQzZt2sTgwYOzfXbHHXdw3333kZ6ejq+vb7ap4Nfy+eef06VLFxo1akS1atVYtGgRAwcOpE+fPvb4LYiIiANYbQaTVx1iwsJ9pGfa8PNy483b6tC3UbkC87TmvxRunMRDDz1EQkLCdds1bNgQLy8vqlevnu1837592bRpE9u3bycpKQlvb2+ee+65y8bT3HvvvSQlJWUd16lTh/3797NkyRIuXLjAa6+9Rv369bNdk5P7iIhIwXToTCLP/76dLcdiAWhfPZj3+oVTJsBxs6Gux2IYhuHoIvJbfHw8AQEBxMXF4e/vn+2z1NRUDh8+TOXKlfHyKliP2W5WfHw8FStW5LPPPmPgwIGOLueanPm/g4hIYWCzGXy35gjj/95DWqYNX083XutViwFNQh32tOZaP7//S09uiogXXniBf/75hypVqjBgwABHlyMiIgXY0XNJvPB7BBuOmGMx21Qrybg761EusOA+rfkvhZsiolGjRjRr1ozu3bvj5qb/7CIicjmbzeCn9UcZO38PKRlWfDxceaVnLQY2q1Agx9ZcjX7KFRH/XWhPRETkUlHnk3lxegRrD50DoEWVIN6/sz6hQT4Oriz3FG5ERESKMMMw+N+GKMbM20VSuhVvd1dGdq/J/S0q4uJSeJ7W/JfCjYiISBF1IjaFl/6IYOX+swA0rVSc9++sT6WSxRxc2c1RuBERESliDMPg903HeXvuLhLSMvF0c+HFbjV5sFUlXAvp05r/UrgREREpQk7FpTJqRgRL954BoGGFQCb0r0/VYF8HV5Z3FG5ERESKAMMwmLk1mjfn7CQ+NRMPNxee61ydIW2rOMXTmv9SuBEREXFyMQmpvDwjkkW7TwNQv3wAE/rXJ6y0n4Mrsw+FGyexadMmjhw5AoC7uzvly5enXr16uLu751kf0dHRbN68mdtvvz3P7ikiIvZjGAZztp/gjTk7iU3OwN3VwjOdqvNouyq4ubo4ujy7UbhxEpMmTWLevHm0b9+ezMxMtm7dipubG3PmzKFOnTp50sfatWsZMmQIsbGxeXI/ERGxn7OJabw2K5K/Ik8BUKesPx8MqE/NkKtvW+AsFG6cSJ06dZg+fToA6enptGrViqeffppFixYBcODAAQ4fPkznzp2zrjl9+jSrV6+mb9++Wefi4+PZsmULYK5s7O/vz5kzZ1i3bh0ZGRlZfdSsWZO6devm129PRERyaP6Ok7w6K5LzSem4uVgYfksYwzpWxd2Jn9b8l8KNk/Lw8KBLly588803Wefmzp3Lt99+S2RkZNa5rVu3MmDAADIzMwFYunQp/fr1o0aNGvj6+nLw4EE++eQTKleuzOrVq8nIyGDatGkA9OnTR+FGRKQAOZ+UzuuzI5kbcRKAmiF+TOhfn7rlAhxcWf5SuLkew4CMZMf07e4DN7GXx6FDhyhZsmSurhk7diwPP/ww77//PgBxcXGsX7+eOnXq8NxzzzFkyJCsJzciIlJwLNh5ildm7uBsYjquLhaGdajK8FvC8HArGk9r/kvh5noykuHdso7p++UT4JHzVSLPnDnD9OnTyczMZP369cyYMYOpU6fmqktPT0+OHj1KSkoK3t7eBAQE0KVLl9xWLiIi+SQ2OZ3Rf+5i5tZoAMJK+fLBgPrUKx/o2MIcSOHGicTExDBt2jTS0tJYs2YN3bt3p0+fPrm6x/jx43nooYcIDg6mdevW9OrVi6FDh+Ll5WWnqkVE5EYt2XOakX/sICYhDRcLPNq+Kk/fGoaXu6ujS3MohZvrcfcxn6A4qu9c+O+A4tOnT9OkSRNGjhzJxIkTAXBxccFms2W7JjU1NdtxrVq1WLt2LSdPnmTJkiWMGTOGBQsWMHfu3Jv4jYiISF6KS8ngnbm7+H3zcQCqBBdjQv/6NKpQ3MGVFQwKN9djseTq1VBBUbp0aT744AMGDhzI0KFDqVWrFuXKlSM6Opq0tDQ8PT0BWL58ebbrTp48SZkyZShTpgz33nsvNpuNp59+GgBfX1/S0tLy/fciIiL/Wr7vDCP/iOBkXCoWCwxpU5nnutQo8k9r/kvhxokNGDCACRMmMGrUKGbNmkXnzp3x8vLi7rvvpk+fPmzatInffvst2zX33XcfoaGhtG7dGqvVyocffki/fv0ACA8Px2q18tprr1G/fn1NBRcRyUcJqRm8O383/9sQBUClEj5M6F+fJpWCHFxZwePwcLN+/XrWrFmDm5sbbdq0oWHDhtdsP2fOHDZs2JDtXOnSpRk+fLg9yyzwmjZtSsWKFS87/9FHH/Hhhx9mPZFZv349n332GcuWLaNx48bMmTOHDz74IKv9ggUL+OWXX1i5ciUuLi689tpr3H333QCUK1eOv/76i+nTp/Prr7/Su3dvhRsRkXyw+sBZXpweQXRsCgAPtqrES91q4u2hpzVXYjEMw3BExzabLWs13ZYtW5KcnMxPP/3EsGHDGD9+/FWve+yxx1i1alXWD1yAUqVK8cgjj+S47/j4eAICAoiLi8PfP/tKjampqRw+fJjKlStrEK0D6b+DiAgkpWUy9q/d/LTuGAChQd68f2d9WlQp4eDKHONaP7//y2FPbiwWC++99x6tW7fOOterVy9uu+02HnzwQWrXrn3Va2vWrMmrr76aH2WKiIg4xJoDZ3lpRgRR582nNfe3qMjI7jUp5unwly4FnkPDzX+DDZivVgCOHj16zXBz9OhR3n33XQICAmjTpg3169e3a60iIiL55UJSOmPm72b6/8+EKhfozfg769G6Wu4WZS3KCtSyhT///DOenp40btz4mu1cXFyIjY1lzZo1NGvWjJEjR16zfVpaGvHx8dl+iYiIFCSGYTB7WzSdJi5n+ubjWCzwQMuK/P1MWwWbXCowz7bWrl3LK6+8wjvvvEOpUqWu2m7EiBFUr1496/jee++lZ8+edO/enfbt21/xmrFjxzJ69Og8r1lERCQvRJ1P5tVZkSzfdwaA6qV9Gdu3Ho0rat2aG1Egntxs2bKFHj168Pjjj/P8889fs+1/gw1Ajx49KFeu3GXrtfzXqFGjiIuLy/oVFRWVJ3WLiIjcjEyrjW9XHqLLhytYvu8MHq4uPNe5OnOHt1WwuQkOf3KzdetWOnXqxKBBg7JW0s0tm81GSkrKVT/39PTMWrQupxw0iUz+n75/EXF2kdFxjJqxgx3RcQA0qxzE2L7hVA32dXBlhZ9Dw822bdvo1KkTDzzwAB999NEV28yaNYuoqCiGDx9OZmYmW7duzRp4fPHzkydPcuutt+ZJTa6u5poB6enpeHt758k9JfeSk82d2N3d3R1ciYhI3kpJt/LRon18u+owVpuBv5cbL/eoxYAmobi4WBxdnlNwWLhJSkqic+fOuLm54evrm21qd58+fbIGFc+dO5d169YxfPhwLBYLzz77LD4+PtSpU4djx44xd+5cXnrpJTp16pQndbm5ueHj48OZM2dwd3fHxaVAvLkrMgzDIDk5mZiYGAIDA7PCpoiIM1i5/wwvz9yRNb27Z70yvHFbbUr5aT2vvOSwcOPi4pK1Z9Gl/vsDrU+fPjRr1izr/KpVq1ixYgVbt26lYcOGvPfee4SFheVZXRaLhTJlynD48GGOHj2aZ/eV3AkMDCQkJMTRZYiI5InzSem8M3cXM7ZGA1AmwIu376hLp9qlHVyZc3LYCsWOlJMVDm02G+np6flcmYD5KkpPbETEGRiGwcyt0bw9dxcXkjOwWGBQy0o837UGvlqML9cK/ArFBZ2Li4uW/RcRkRt27Fwyr8zawcr9ZwGoGeLH2L7hNKygWVD2pnAjIiKShzKtNiavOsyHi/aRmmHDw82Fp28N45F2VXB31TjO/KBwIyIikkd2HI/jpT8i2HXSXAm/ZZUSvNs3nMolizm4sqJF4UZEROQmJadnMnHhPqasPozNgABvd17pWYv+jctjsWh6d35TuBEREbkJy/bG8MrMSKJjzendt9cvy2u9ahPsl7vFYyXvKNyIiIjcgLOJabw9dxezt50AzN273+ldl441r74/ouQPhRsREZFcMAyD6ZuPM2b+bmKTM3CxwODWlRnRuTrFNL0bks/D2f1QobnDStB/BRERkRw6cjaJl2fuYM3BcwDUKuPPe33DqR8a6NjCCopj62H6Q5CeAI+uhOIVHVKGwo2IiMh1ZFhtfLPyEB8v2k9apg1PNxee7Vydh9tU1vRuAJsN1n4Ki0aDYYWgqpCR7LByFG5ERESuYVtULCP/iGDPqQQA2lQryZg+dalYQtO7AfM11MzHYP8C87huP7jtY/D0c1hJCjciIiJXkJiWyQcL9/L9miMYBhT3cefVnrXp26icpndfdPE1VPxxcPWE7uOg8YPg4O9H4UZEROQSS/ac5tWZkZyISwWgT8NyvNqzFiV8Nb0buPJrqP7fQ5l6jq4MULgRERHJEpOQyug/dzEv4iQA5Yt7M6ZPOO2rBzu4sgKkAL6GupTCjYiIFHmGYfDbpijGzNtNfGomLhYY0rYKz3QKw8dDPyqzFNDXUJfSfzERESnSDp1JZNSMHaw/fB6AOmX9GdevHnXLBTi4sgKkgL+GupTCjYiIFEnpmTa+XnGQT5YcID3Thpe7C891rsHg1pVw0/TufxWC11CXUrgREZEiZ8uxC4z6Ywd7T5vTu9uGleTdPuGEBvk4uLIC5th6mD4Y4qML9GuoSynciIhIkZGQmsH7C/Yydd1RDAOCinnweq/a3NGgrKZ3/1chew11KYUbEREpEv7ZdZrXZkVyKt6c3t23UTle7VmboGIeDq6sgCmEr6EupXAjIiJOLSXdyot/RPDndnP37gpBPrzbJ5w2YSUdXFkBVEhfQ11K4UZERJxWXEoGQ37YyMYjF3B1sTC0bRWevjUMbw9XR5dWsFzpNdSAHyAk3NGV3RCFGxERcUoxCak8MHkDe04l4OflxrcPNKF5lRKOLqvgcYLXUJdSuBEREadz7Fwy901ez7HzyZT09eTHh5pRu6y/o8sqeJzkNdSlFG5ERMSp7D4ZzwNTNnAmIY3QIG9+eri5dvC+lJO9hrqUwo2IiDiNjUfO89D3G0lIzaRmiB8/PtSMUv5eji6rYHHC11CXUrgRERGnsGTPaR7/aQtpmTaaVCzO5EFNCfBxd3RZBYuTvoa6lMKNiIgUejO2HOeF6RFYbQa31CzFZwMbaUbUfzn5a6hLKdyIiEihNmXVYd6auwuAPg3LMf7Oerhrb6h/FYHXUJdSuBERkULJMAw+WLiPSUsPADC4dSVe61kbFxfnesVyU4rIa6hLKdyIiEihY7UZvDY7kl/WHwPg+S7VeaJjNe0PdVERew11KYUbEREpVNIyrTz76zbm7ziFxQLv9K7Lvc0rOrqsgqMIvoa6lMKNiIgUGklpmTw6dTOrDpzF3dXCR3c1pGe9Mo4uq+Aooq+hLqVwIyIihcL5pHQGf7eB7cfj8PFw5av7G9M2LNjRZRUMRfw11KUUbkREpMA7EZvC/ZPXc/BMEsV93PlucDMahAY6uqyC4bLXUHfCbR8VqddQl1K4ERGRAu1ATCIPTF7PibhUygR4MfXhZlQrVXR/cGej11BXpHAjIiIF1vaoWB78bgMXkjOoElyMqQ83p1ygt6PLcjybDdZ8Aovf0muoK1C4ERGRAmnV/rM8OnUTSelW6pUP4LsHm1LC19PRZTmeXkNdl8KNiIgUOPN3nOSZadtIt9poXa0EX93fBF9P/cjSa6ic0Z8UEREpUH5Zf4xXZu3AMKB73RA+ursBnm5FfJ8ovYbKFYUbEREpEAzD4PNlB3l/wV4A7mlWgXd618W1qG+noNdQuaZwIyIiDmezGYyZv5vJqw4D8ETHqjzfpYa2U9BrqBuicCMiIg6VYbXx0vQIZmyNBuDVnrUY0raKg6tysNQ4WDEB1n6m11A3QOFGREQcJjXDyhM/b2HxnhhcXSyM71ePfo3LO7osx7FZYcsPsGQMJJ81z+k1VK4p3IiIiEPEpWQw9IdNbDhyHk83Fz4b2IhOtUs7uizHObQM/n4ZYnaaxyXCoOu7ENZZr6FySeFGRETyXUxCKoOmbGT3yXj8vNyYPKgpzSoHObosxzh3EBa+Cnvnm8degdBhFDR9GFzdHVpaYaVwIyIi+erYuWTun7Keo+eSKenryY8PNaN2WX9Hl5X/UmJhxfuw/iuwZYDFFZoNhfYvgU8RDXp5ROFGRETyze6T8TwwZQNnEtIIDfLmp4ebU7FEMUeXlb+smbDle1j6LiSfM8+FdYEu70BwDYeW5iwUbkREJF9sPHKeh77fSEJqJjVD/PjxoWaU8vdydFn56+ASc1zNmd3mccka/z+uppNj63IyCjciImJ3S/acZtjPW0jNsNGkYnEmD2pKgE8RGk9ydr85rmbf3+axd3Ho+Iq5Zo3G1eQ5h4cbq9XKvn37cHNzo3Llyri55aykqKgoTp8+TfXq1fH3L4LvakVEComZW4/z/O8RWG0Gt9QsxWcDG+HtUUS2U0i5AMvHw4avwZYJLm7Q7BFo/6IZcMQuXBzZ+ZgxYyhXrhz9+vWjS5cuVKpUiblz517zmtTUVPr160eNGjW4//77CQkJ4dNPP82nikVEJDemrDrMs79ux2oz6NOwHF/d37hoBBtrJmz4Bj5pCOs+N4NN9W4wbB10G6tgY2cOe3JjtVpJSUlh165dBAWZo8LffPNN7rrrLg4ePEhISMgVrxs9ejQbNmzg4MGDlClThlmzZtGnTx+aNWtG8+bN8/O3ICIiV2EYBhP/2cenSw4AMLh1JV7rWRuXorBP1IFFsOAVOLPHPA6uBV3HQLVbHVtXEWIxDMNwdBEXnT59mpCQEObNm0ePHj2u2CYkJITHH3+cN954I+tceHg4rVu35ssvv8xRP/Hx8QQEBBAXF6dXWiIiecxqM3htdiS/rD8GwPNdqvNEx2rOv0/UmX2w8BXYv9A89g6CW16BRg+Cq8NHgTiFnP78LlDf9saNGwGoWrXqFT8/ceIEp0+fpnHjxtnON2vWjK1bt171vmlpaaSlpWUdx8fH50G1IiJyqbRMKyN+3c68HSexWOCd3nW5t3lFR5dlX8nnYfk48zWUYTXH1TR/DNq9AN6Bjq6uSCow4ebs2bMMHz6cAQMGUKPGlef5nz9/HoASJUpkO1+iRImsz65k7NixjB49Ou+KFRGRyySlZfLo1M2sOnAWd1cLH93VkJ71yji6LPuxZsCmKeZ6Namx5rkaPaDz21CymkNLK+oKRLiJi4ujW7duhISE8O233161nbu7OV0uNTU12/mUlBQ8PDyuet2oUaMYMWJE1nF8fDyhoaE3WbWIiFx0Pimdwd9vZHtULD4ernx1f2PahgU7uiz72f8PLHgZzu4zj0vVNterqdrRsXUJUADCTXx8PF26dMHV1ZW///4bP7+r73oaGhqKi4sL0dHR2c5HR0dToUKFq17n6emJp6dnntUsIiL/OhGbwv2T13PwTBLFfdz5bnAzGoQGOros+4jZY4aag4vNY58ScMur0PABjaspQBw6FfxisAFYuHAhAQEBl7U5cOBA1ngaHx8fWrVqxZw5c7I+T0pKYtGiRXTu3Dl/ihYRkSwHYhK584s1HDyTRJkAL35/rKVzBpukczDvefiilRlsXNyh1XB4ais0eUjBpoBx2GypjIwMOnTowIEDB5gyZUq2YBMWFkbp0ua290OGDGHdunVERkYCsHz5cjp37sxzzz1Hy5Yt+fTTTzl8+DDbtm3D19c3R31rtpSIyM2LOB7Lg99t5HxSOlWCizH14eaUC/R2dFl5KzMdNn4Ly9+D1DjzXM1e0PktKHHlyS9iPwV+tlRycjIWi4WwsDDGjh2b7bORI0fSq1cvwAw66enpWZ+1b9+epUuX8tlnn7FhwwbCw8OZOnVqjoONiIjcvNUHzvLIj5tISrdSr3wA3z3YlBK+TvT63zBg3wJzavc5c60eSodDt3ehcjvH1ibXVaDWuckvenIjInLj/tpxkqenbSPdaqN1tRJ8dX8TfD2d6LXM6V3muJpDS83jYsFwy2vQ8D5wKQKrKxdgBf7JjYiIFC6GYfDd6iO8M28XNgO61w3ho7sb4OnmJD/wk86a07o3fweGDVw9oMUwaPsceOkfwoWJwo2IiFxXUlomo2bsYM72EwDc06wC7/Sui6szbKeQmQ4bvoLl70Pa/4+rqXW7Oa4mqLJja5MbonAjIiLXdOhMIo/9tJl9pxNxc7Hwco9aDG5dqfBvp2AYsHc+LHwVzh8yz4XUMze2rNTGsbXJTVG4ERGRq/o78iTP/x5BYlompfw8+ezeRjStFOTosm7eqUhYMAoOrzCPi5WCW1+HBgM1rsYJKNyIiMhlMq02xi/Yy9crzCcazSoHMWlgQ0r5eTm4spuUeAaWvgNbfvz/cTWe0PIJaDsCPK++iKwULgo3IiKSzZmENIb/bwvrDpl79g1tW5kXu9XE3dWh677enMw0WP8lrJgAaf+/eXKdPtBpNBR38o09iyCFGxERybL56HmG/byF0/FpFPNw5f3+9ekRXog3v0xPgq0/w5pPIe6Yea5MA3NcTcVWDi1N7EfhRkREMAyD79ccYcy83WTaDKqV8uXL+xpTrVQhXSA16Rxs+Nr8lWI+gcK3NNz6BtS/B1wK8VMouS6FGxGRIu7Sad696pVhXL96FCuMC/NdOAJrJsHWnyAzxTxXvJK5D1SDe8HdybaHkCsqhH9yRUQkrzjNNO8T22DNJ7BzpjlQGMzXT62fhtp3aAZUEaNwIyJSRBX6ad6GYW6RsPpjOLTs3/NVbzVDTeV2UNhCmuQJhRsRkSKm0E/ztmbCrllmqDkVYZ6zuELdvmaoCQl3aHnieAo3IiJFSKGe5p2eDNv+f+ZT7FHznLsPNHrA3ANKU7rl/ynciIgUEYV2mnfSOdj4Daz/6t+ZTz4loPlj0HQI+BSiV2mSLxRuREScXKGd5n3hKKydBFum/jvzKbDivzOfPHwcW58UWAo3IiJOrFBO8z65HVZfnPlkNc+VqW+Op6l1B7gW4NqlQNCfEBERJ1WopnkbBhxebg4SPrjk3/NVb/n/mU/tNfNJckzhRkTECRWaad7WTNg92ww1J7eb5yyu5r5PrZ+GMvUcW58USgo3IiJOpNBM874482ntJHNVYQA3b3PmU8th5qrCIjdI4UZExEkUimneyedhwzew4StIPmee8ykBzR41Zz4VK+HY+sQpKNyIiDiBAj/N+8JRWPc5bPkRMpLNc5r5JHaicCMiUogV+Gnep3aY42kiZ/w78ymkHrR5RjOfxG70p0pEpJAqsNO8DQMOr/j/mU+L/z1fpaM5SLhKB818ErtSuBERKYQK5DRvmxV2XZz5tM08Z3GBOn2h9VPmWjUi+UDhRkSkkClw07wzUv7d8ynbzKf7oeUTmvkk+U7hRkSkkMi02nh/wV6+KijTvJPPw8bJsP5LSD5rnvMOguaPQtOhmvkkDqNwIyJSCBSoad6xx2DtxZlPSea5wArQcjg0vE8zn8ThFG5ERAq4AjPNOyMFlrwD677IPvOp9dNQu7dmPkmBoT+JIiIFVIGa5h29BWY+Bmf3msdVOvz/zKeOmvkkBY7CjYhIAVRgpnlbM2DF+7Bigvm0xrc03P4pVO+av3WI5ILCjYhIAVNgpnmf3gUzH4VTEeZxnb7Q8wPwKYAbcIr8h8KNiEgBUiCmedus5oaWS94Bazp4FzdDTd1++VuHyA1SuBERKQAKzDTvcwdh1jCIWmceh3WF2z8Bv5D8rUPkJijciIg4WIGY5m0YsGkyLHzN3NjSww+6jTWndmvAsBQyCjciIg5UIKZ5x0XD7Cfg0FLzuFJbuOMzKF4xf+sQySMKNyIiDlAgpnkbBkT8CvNfhLQ4cPOCTqOh2SPg4oDFAUXyiMKNiEg+O5uYxkvTI1i8JwZw0DTvxDMw9xnYM9c8LtcY+nwFJcPyrwYRO1G4ERHJR0v3xvDC79s5m5iOh5sLo7rX5MFW+TzNe/ef8Ocz5n5QLu7Q4SVo/axWGBanoT/JIiL5IDXDytj5u/lh7VEAapT24+N7GlAzxD//ikiJhb9egohp5nGpOtDnSyhTL/9qEMkHCjciIna260Q8T0/byv6YRAAGt67ES91q4uXumn9FHFgMs5+EhBNgcTG3TugwCtw8868GkXyicCMiYic2m8GU1YcZ//de0q02gv08mdC/Pu2rB+dfEWmJ8M/r5jRvgKCq5tOa0Gb5V4NIPlO4ERGxg9PxqTz323ZWHTgLQKdapRnXL5wSvvn4pOToWpj1OFw4bB43ewQ6vQkexfKvBhEHyHW4OXLkCL/99hsrVqzg+PHjAISGhtKuXTsGDBhAxYpaF0FEira/I08xckYEsckZeLm78Fqv2gxsViH/Bg1npMLSMbDmU8AA//LQ+zNzJ2+RIiDHCxkcOnSIO++8k7CwMH766SdKly5Njx496NGjB6VKleLHH3+kWrVq9O/fn0OHDtmzZhGRAikpLZORf0Tw2E+biU3OoG45f+YOb8u9zSvmX7A5sQ2+7gBrPgEMaHAvDFujYCNFSo6f3LRs2ZJHHnmECRMmUKlSpSu2OXLkCJMnT6Zly5acPn06r2oUESnwtkfF8syv2zh8NgmLBR5tV5URnavj4ZZPi+FZM2DlRFgxHmyZUCwYbvsEavbIn/5FChCLYRhGThqeO3eOEiVK5OimuWnrCPHx8QQEBBAXF4e/fz5OwxQRp2O1GXy5/CAf/rOPTJtBmQAvJg5oQMuq+fh3YMwemPUYnNhqHte+A3p+CMUK7t/DIjcipz+/c/zk5lphxTAMDh48SEhICL6+vgU62IiI5JXjF5IZ8et2NhwxN7zsGV6Gd/uEE+Djnj8F2Gyw7nNY/BZY08ArAHp8AOF3arNLKdJu6Hnpxo0beeKJJ7KOBw4cSFhYGCEhIaxcuTLPihMRKahmb4um+8cr2XDkPMU8XJnQvz6TBjbMv2Bz/jD80AsWvmIGm2qdYNg6qNdfwUaKvBuaCv7888/z7rvvAhAREcFff/3Fpk2bWLBgAa+88gorVqzI0yJFRAqK+NQM3pi9k5lbowFoWCGQj+5qQMUS+TS92jBg8/ew4BXISAL3YtB1DDR+UKFG5P/dULjZvHkzjRo1AuCff/6hb9++NG7cmBo1avDee+/laYEiIgXFxiPneWbaNqJjU3CxwFO3hvFkx2q4uebToOH4EzBnOBxYZB5XbA13fAZBlfOnf5FC4ob+H+nv75813fvPP/+kY8eOAMTGxuZqgG5SUhLffvstTZo0wdfXN0evtJ555hl8fX2z/WrWTCttioj9ZFhtfLBwL3d9tZbo2BRCg7z5/bGWPNOpev4EG8OAiN/h8xZmsHH1hC5jYNBcBRuRK7ihJzcDBgygZ8+e1K5dmx07dtCrVy8A/v77b3r0yPm0w7fffpszZ87w6quv0qdPH6xW63WvSU1NpXPnzkydOjXrnKtrPu7PIiJFypGzSTz96za2R8UC0LdROUbfXgc/r3waW5N0FuY+C7vnmMdlGkCfr6BUzfzpX6QQuqFwM2HCBMLCwjh69Chjx46lePHiABw8eJDXX389x/e5+Arr4krHOeXq6oqvr2+urhERyQ3DMPh983HenLOT5HQr/l5ujOkTzm31y+ZfEXvmw59PQdIZcHGDdi9C2xHgmk/BSqSQuqFw4+bmlm221EVjx4696YJyYtGiRZQqVYqAgADatm3LmDFjKFOmTL70LSLOLzY5nVEzdvBX5CkAmlcO4sO7GlA20Dt/CkiNg79HwbafzePgmuZml2Ub5k//IoVcjl8W9+/fnz179ly33a5du+jfv/9NFXUtoaGhfPHFF2zbto1ffvmFgwcP0qZNGxITE696TVpaGvHx8dl+iYhcyZoDZ+n20Ur+ijyFm4uFl7rV5JehLfIv2BxaBp+3+v9gY4FWT8EjyxVsRHIhx09uWrRoQYsWLWjYsCG33XYbjRs3pnTp0hiGwalTp9i4cSNz5sxhx44dvPbaa3Yr+JVXXsn632XLluWPP/6gXLlyTJs2jSFDhlzxmrFjxzJ69Gi71SQihV9appWJC/fx9cpDGAZUKVmMj+9uSHj5gPwpID0JFr0JG742j4tXgt5fQsWW+dO/iBPJ8fYLYG6r8NVXXzFt2jQiIyO5eKnFYiE8PJx77rmHoUOH5nqF4uPHjxMaGsrSpUvp0KFDrq4FCAsLo0+fPowfP/6Kn6elpZGWlpZ1HB8fT2hoqLZfEBEADsQk8NT/trHrpPlUd2DzCrzasxY+Hjf05j73ojbAzEfh/P9vOtzkYej8FnhqbKHIf+X59gtgbsHw8ssv8/LLLxMXF0d0dDQWi4WyZcsSEJBP/7q5RGJiItHR0ZQqVeqqbTw9PfH09MzHqkSkMDAMg5/WHeWdebtJy7QRVMyD9/qG06VOSP4UkJkGy8bC6o/BsIFfWbhjElS7NX/6F3FSN/zPkoCAgHwJNE8++SQbNmxgw4YNpKWlMWTIEEaNGkWNGjU4ceIEw4cPx9PTk4EDB9q9FhFxHmcT03hxegRL9sQA0DasJB/0r08pf6/8KeDYOnOKd8wu87je3dD9PfAunj/9izixG159KiEhgT/++IP3338/69zu3bvJxVsufv75Z3x9falRowYA3bt3x9fXN2trBzDXtUlOTgbMJzC9evXivvvuo1ixYtSvXx/DMFi7di1ly+bj9EwRKdSW7o2h20crWLInBg83F17vVZsfBjfLn2CTdBZmDYMpXc1g41MSBkyFvl8p2IjkkVyNubloz549dO7cGZvNxokTJ7ICzaBBg+jatWuOn6JkZmaSmpp62XkPDw88PDwAc7yMzWbD2zv7TAWr1XrDi/fl9J2diDiX1AwrY+fv5oe1RwGoUdqPj+9pQM2QfPh7wGY194Ra/BakxprnGt4PnUZDsdyNUxQpqnL68/uGwk337t1p2LAhY8aMwcXFJSvcbN68maFDh7Jly5YbrzwfKNyIFD27TsTz9LSt7I8xl40Y3LoSL3WriZd7PqxwHr0F5o2AE1vN45Bw6DkRQrV1jEhu2DXcBAYGcuTIEQIDA7FYLFnhJikpiaCgoGwzkwoihRuRosNmM5iy+jDj/95LutVGsJ8nE/rXp331YPt3nnIBFr8Nm6YABnj6Q8dXoOkQcM2nmVgiTsQus6UuMgwjK8BYLJas84cOHXLYrCkRkUudjk/lud+2s+rAWQA61SrNuH7hlPC18+xJw4Dt/4OFr0Gy2TfhA6DL2+CXTzOxRIqwGwo3Xbp0Yfz48XzwwQdZ4SYmJoYnn3yS7t2752mBIiI34u/IU4ycEUFscgZe7i681qs2A5tVyPYPMrs4vRPmPQfH1prHJWtAzwlQuZ19+xWRLDf0WioqKooOHTrg4uLCgQMHaNOmDVu3biUkJISVK1cW+H2e9FpKxHklpWXy9txdTNsYBUDdcv58dFdDqpWy84J4aQmwdCys/xIMK7j7QPuXoMUwcPOwb98iRYRdX0uFhoYSERHBL7/8wqZNm7DZbAwcOJD7779fu3WLiMNsj4rl6WlbOXIuGYsFHm1XlRGdq+PhdsOrXlyfYcDOGbDgFUg4aZ6rdRt0HQuBofbrV0Su6oae3BR2enIj4lysNoMvlx/kw3/2kWkzKBPgxcQBDWhZ1c5TrM/uh/nPm5tdAhSvDD0mQFgn+/YrUkTZ9cnNRTabLWuBvf/S0xsRyS8HYhJ4cXoEW47FAtCzXhne7R1OgI+7/TpNT4aVE2D1J2DLAFdPaDsCWj8D7vm0wrGIXNUNhZu9e/fy2GOPsWbNGtLT0y/7vAg+DBKRfJZhtfHV8oN8svgA6VYbvp5ujL69Dn0blbPvoOE98+GvlyDumHkc1gW6j4OgKvbrU0Ry5YbCzaBBgwgJCWH27NkEBgbmcUkiIte243gcL0zfzp5TCQDcUrMUY/rUpUyA93WuvAkXjpihZt/f5rF/eXMvqJq9wN4zsEQkV24o3Gzfvp2///5bwUZE8lVqhpWPFu3nm5WHsNoMivu48+btdbi9fln7Pa3JTDN37V75AWSmgos7tHoS2r0AHsXs06eI3JQbCjeVKlUiJiZG4UZE8s36Q+cYOWMHh88mAXBb/bK8eVtt+y7Id2AxzH8Bzh80jyu3MwcMB9ewX58ictNuKNy89dZbDB48mHHjxlG1atXL/sUUEqIVOEUkbySkZjD+771MXWdudlna35N3eofTuXZp+3UaFw0LRsGu2eaxbwh0HQN1++kVlEghcEPhpkSJEkRGRtK2bdsrfq4BxSKSF5bujeGVGTs4EZcKwD3NQhnZvRYB3naaCWXNgHVfwLL3ICMJLK7Q/FHoMAq8tGyESGFxQ+Fm2LBh9OzZk2HDhunVlIjkuQtJ6bw9dxcztkYDUCHIh/f6htOqWkn7dXpktbltwpnd5nFoc+j5gbmDt4gUKjcUbo4dO8aGDRu0AJ6I5CnDMJi34yRvzN7JuaR0XCzwUOvKjOhSHR8PO+2inRhjbnAZMc089ikBnd+C+gPBxY4rG4uI3dzQ3xZhYWEcP36c2rVr53U9IlJEnY5P5bVZkSzcdRqAsFK+jL+zHg0rFLdPhzYrbJwMS96BtDjAAo0fhFtfB58g+/QpIvnihsLNfffdx3333ce4ceOoVq3aZQOKK1WqlBe1iUgRYBgGv22K4p15u0lIzcTNxcITHasxrGNVPN1c7dNp1EaYNwJORZjHZRpAr4lQrrF9+hORfHVDe0tdbz2Jgj6gWHtLiRQMx84lM2pmBKsPnAOgXvkAxt9Zj5ohdvr/ZfJ5WPQmbPnBPPYKMJ/UNB4MLnYKUiKSZ+y6t9T+/ftvuDAREavN4Ps1R5iwYC8pGVY83Vx4vksNBreuhJurHca52GywdaoZbFLOm+fqDzTH1vgG531/IuJQNxRuqlWrltd1iEgRsf90Ai/+EcHW/9/osnnlIMb1q0elknZa7fdkhPkK6vhG87hUbXMWVMVW9ulPRBwux+EmMjISgLp162b976upW7fuzVUlIk4nPdPGl8sPMmnJvxtdvtyjFnc3DcXFxQ4L46XGwZIxsPEbMGzg4WuuV9P8UXC1447hIuJwOQ434eHmWg+GYWT976sp6GNuRCR/RRyP5cXpEfmz0aVhwI7fYcErkBRjnqvT11xh2L9s3vcnIgVOjsPNyZMnr/i/RUSuJjXDyof/7OOblYewGRBUzIM3bqttv40uY/bA/OfhyErzuEQ1cy+oqh3zvi8RKbByHG5CQkIYMmQI3377rfaOEpHrWnfoHCP/iODIuWQAbq9fljfstdFlehIsHwdrPwNbJrh5Q7vnodVwcLPjxpoiUiDlaiq4xWJxildOmgouYj8JqRm899cefl5/DIAQfy/e6V2XTvba6PL4JvhjCFw4bB7X6AHd3oPiFe3Tn4g4jF2ngouIXMnSPTG8PHMHJ7M2uqzAqB418feywwBeayasmmhucmlYwb889JwANbrnfV8iUqgo3IjITTuflM5bf+5k1rYTAFQs4cPYvuG0qmqnjS4vHIEZj0DUevO4bj9zere3nbZqEJFCJdfhxs3t+pdkZmbeUDEiUrgYhsHciJO8OeffjS4fblOZEZ1r4O1hhxV/DQO2T4P5L0B6Anj6mwOG6w0AewxQFpFCKdfhZtKkSfaoQ0QKmdPxqbwyM5JFu82NLmuU9mPcnfVoEBponw5TLsDcZ2HnTPO4Qkvo85XG1ojIZXIdbh577DF71CEihYRhGPy6MYox882NLt1d/3+jyw7V8HCzw9YJAIdXwMzHID4aXNygw0hoM0L7QYnIFWnMjYjk2LFzyYycEcGag+ZGl/VDAxnfrx41Qvzs02FmGix5B9Z8ChgQVBX6faPdu0XkmhRuROS6rDaD71YfZsLCvaRm2PByv7jRZWVc7bF1AsCZvfDHw3Bqh3ncaBB0fRc8fe3Tn4g4jVyFm5SUFHvVISIF1L7TCbw4PYJtUbEAtKgSxHt97bjRpWHAxm9h4auQmQreQXD7p1Crl336ExGnk6tw4+XlZa86RKSAubjR5adL9pNhNfDzdGOUPTe6BEiMgdlPwP6F5nHVW6H35+CnVdFFJOf0WkpELrM9KpaX/vh3o8tba5biHXttdHnR3r/NYJN8Flw9ofNb0OwRcLHTIGURcVoKNyKSJS3TysSF+bjRJUB6Mix8BTZNMY9L14W+30Dp2vbpT0ScnsKNiABw+GwSw/+3hcjoeADuaFCW13vZaaPLi05shT+Gwrn95nHLJ+HW17XZpYjcFIUbEWH2tmhenrGDpHQrxX3cGX9nfTrba6NLAJsVVn8MS8eYu3j7lYHeX0DVjvbrU0SKDIUbkSIsJd3K6D93Mm1jFADNKgfx8d0N7Du2JjYKZj4KR1ebx7Vuh9s+Bp8g+/UpIkWKwo1IEbXvdAJP/rKFfacTsVhg+C1hPHVLNdxc7TiAd8d0mDsC0uLAwxe6j4MG92pfKBHJUwo3IkWMYRj8vuk4r8+JJDXDRrCfJx/d1YDW1ey0gzdAahzMex52/GYel28Kfb+GoCr261NEiiyFG5EiJDEtk1dm7mD2thMAtA0rycQBDQj2s+MA3qNrYMajEHcMLC7Q7kVo9wK46q8fEbEP/e0iUkRERsfx5C9bOHIuGVcXC891qc5j7arab0E+awYsGwurPgTDBsUrmVO8Q5vZpz8Rkf+ncCPi5AzD4Me1RxkzbzfpVhtlA7z45J6GNKlkxwG8Zw/AjCHmVG8wx9V0HweedtpgU0TkPxRuRJxYXHIGL/6xnQU7TwPQqVZpJvSvR6CPh306NAzY/D0seBkyksEr0JwJVae3ffoTEbkChRsRJ7Xl2AWG/7KV6NgU3F0tjOpei8GtK9lvpeGkszDnKdg7zzyu3A56fwkB5ezTn4jIVSjciDgZm83g65WHmLBgL5k2g4olfPj0nobUKx9ov073L4LZwyDxNLh6mKsMt3hC+0KJiEMo3Ig4kXOJaYz4bTvL950BoFe9MoztG46fl7t9OsxIgX/egA1fmcfBNaHftxASbp/+RERyQOFGxEmsPXiOZ37dyun4NDzdXHjz9jrc3TTUfq+hTkbAjKFwZo953OxR6Dwa3O24urGISA44PNwcPXqUb775hj179jB69Gjq1Klz3Wv27NnDN998w+nTpwkPD+eJJ57A19c3H6oVKXisNoNPl+znk8X7sRlQrZQvkwY2pGaIv306tNlg7SRY8jZY06FYKej9OYR1tk9/IiK55NAX4hMmTKBjx44kJibyxx9/cObMmetes2XLFho3bsz58+dp27Yt06dPp23btqSlpeVDxSIFy+n4VO79dh0fLTKDTf/G5ZnzZGv7BZu4aJh6B/zzmhlsavSAYWsVbESkQLEYhmE4qvOjR48SGhrKiRMnCA0NZenSpXTo0OGa13Tt2hU3NzfmzTNnZJw7d47Q0FAmTpzIY489lqN+4+PjCQgIIC4uDn9/O/0QELGzZXtjeO637ZxLSsfHw5UxferSp2F5+3W4cxb8+TSkxoK7D3R9Fxo/qH2hRCTf5PTnt0Of3FSsWBGXXMymSEtLY8mSJdx5551Z50qUKMGtt97K/Pnz7VGiSIGTYbUx9q/dPPjdRs4lpVO7jD9zh7exX7BJS4BZw+D3QWawKdsQHl0JTQYr2IhIgeTwMTe5cezYMTIzM6lQoUK28xUqVGD58uVXvS4tLS3ba6v4+Hi71ShiT8cvJDP8f1vZeiwWgAdaVuTlHrXwcne1T4dRG8xBwxeOABZoOwI6jAJXO82+EhHJA4Uq3FwMKD4+PtnO+/r6kpqaetXrxo4dy+jRo+1am4i9Ldh5ihd+3058aiZ+Xm6M71eP7uFl7NOZNRNWvG/+MqwQUAH6fgUVW9mnPxGRPFSowk1AQAAAFy5cyHb+3LlzBAYGXvW6UaNGMWLEiKzj+Ph4QkND7VKjSF5Ly7Qydv4evl9zBIAGoYF8ek9DQoN8rn3hjTp/CGY8Asc3msfhA6DnBPAKsE9/IiJ5rFCFm/Lly1O8eHEiIiLo0aNH1vmIiAjq1at31es8PT3x9PTMjxJF8tThs0kM/98WIqPNV6mPtqvC811r4O5qp+Fy23+FeSMgPRE8A6DXRAi/8/rXiYgUIAV+bfQvv/wy66mLxWLh3nvvZfLkycTGxgKwfPlyNm7cyH333efAKkXy3uxt0fT6ZCWR0fEU93HnuwebMqpHLfsEm7REmPk4zHzEDDYVW8PjqxRsRKRQcuiTm2XLljFp0iRSUlIAeOONNwgODmbAgAEMGDAAgE2bNrFu3bqsa8aMGcOWLVuoVasWtWrVYv369bz88svccsstDvk9iOS1lHQrb87Zya+bogBoVjmIT+5uSEiAl306PLUDfh8M5/aDxQXaj4R2z4OLnQYpi4jYmcPXudm4ceNl52vXrk3t2rUB2Lx5M+fPn6dz538XCTMMg40bN3L69Gnq1q1L5cqVc9Wv1rmRgmrf6QSe/GUL+04nYrHA8FvCeOqWarjZ42mNYcDGb2HBK2BNA7+y0O8bqNQm7/sSEckDOf357dBw4ygKN1LQGIbBb5uieGPOTlIzbAT7efLxXQ1oVa2kfTpMuQCzn4Q9c83j6t3gjs+hWAn79Ccikgdy+vO7UA0oFnFGiWmZvDJzB7O3nQCgbVhJPryrASV97TQI/th6+ONhiIsCF3fo8jY0f0wL8omI01C4EXGgyOg4nvxlC0fOJePqYuH5LjV4tF0VXFzsEDRsNlj9ISwZY65dU7wy9P/OXHFYRMSJKNyIOIBhGPyw5gjvzt9DutVGuUBvPrmnAY0rBtmnw4TT5kyoQ8vM4/D+0HMieOm1rIg4H4UbkXwWl5zBC9O3s3DXaQA61y7N+3fWI9DHwz4dHlgEMx+DpDPmhpc93ocG9+o1lIg4LYUbkXy0+egFnvrfVqJjU/BwdeHlHjUZ1KoSFnsEDWsGLHkbVn9sHpeqY76GCq6R932JiBQgCjci+cBmM/h65SHeX7AXq82gYgkfJt3TiPDydtrS4MIRmP4wRG8yj5s8DF3HgLu3ffoTESlAFG5E7OxcYhojftvO8n1nALitflne7VMXPy877ay9cxbMeQrS4swtFO74FGrfYZ++REQKIIUbETtae/AcT0/bSkxCGp5uLoy+vQ53NQ21z2uojBRY8DJsmmIel28K/SZD8Yp535eISAGmcCNiB4Zh8Pmyg3ywcC82A8JK+TJpYCNqhPjZp8OYPTB9MMTsMo/bPAsdXwFXOz0dEhEpwBRuRPJYWqaVkX/sYObWaAAGNCnPm7fXwcfDDv93MwzY+hPMfwEyU6BYMPT5Cqrdmvd9iYgUEgo3InnoXGIaj07dzKajF3B1sfD2HXUZ2LyCfTpLjYe5z0LkdPO4Sgfo8zX4lbZPfyIihYTCjUgeORCTwEPfb+LY+WT8vNz44t7GtAmz095Q0Vtg+kNw4TBYXOGWV6H1M+Bihw02RUQKGYUbkTywav9ZHv95MwmpmVQI8mHKg02oVsoO42sMA9Z9Dv+8AbYMCAg1Bw1XaJ73fYmIFFIKNyI36Zf1x3htdiRWm0GTisX5+oEmBBWzw2rDSedg1uOwf4F5XLMX3DEJvIvnfV8iIoWYwo3IDbLaDMbO3823qw4D0KdhOd7rF46nm2ved3ZkFfwxBBJOgqunuSBf0yHaQkFE5AoUbkRuQFJaJk9P28ai3eb+UCM6V2f4LdXyfv0amxWWj4cV48GwQYkwcwuFkPC87UdExIko3Ijk0sm4FB7+fhO7Tsbj4ebCB/3rc1v9snnfUVw0zBgKR1ebxw3ugx7jwaNY3vclIuJEFG5EcmHH8TiG/LiR0/FplPT14OsHmtCogh3GvOz92xxfk3IePHyh14dQb0De9yMi4oQUbkRy6O/IUzz76zZSMqxUL+3L5EFNCQ3yydtOMtNg0ZvmjCiAMvXhzu+gRNW87UdExIkp3Ihch2EYfLXiEOP+3oNhQPvqwUwa2DDvN748d9Bcu+bkNvO4xTDo9Ca4eeZtPyIiTk7hRuQa0jNtvDYrkl83RQEwqGVFXutVGzfXPF4sL+J3mPsMpCeaU7t7fwE1uudtHyIiRYTCjchVxCVn8NhPm1l76BwuFni9V20ebF05bztJT4K/XjT3hwKo0Ar6fQsB5fK2HxGRIkThRuQKjpxN4qHvN3LobBLFPFyZNLARHWuWyttOTkWaO3mf3QdYoP1L0O4FcNX/LUVEbob+FhW5xPpD53j0p83EJmdQLtCbyQ82oWaIf951YBiwaQr8PQqsaeBXBvp+A5Xb5l0fIiJFmMKNyH9M33ycUTMiyLAa1A8N5JsHGlPKzyvvOkiJhTnDYfcc8zisizm+ppidNtgUESmCFG5EAJvN4IN/9vLZ0oMA9KxXhg/618fLPQ+3UojaANMfhrhj4OJuzoRqMUw7eYuI5DGFGynyUtKtPPf7NubvOAXA8Fuq8Wyn6ri45NFWCjYbrP4IlrwDhhWKV4I7p0C5xnlzfxERyUbhRoq0mIRUhv6wie3H43B3tfBe33r0a1w+7zpIjIEZj8ChpeZx3X7Q6yPwysMxPCIiko3CjRRZu0/G8/D3GzkRl0pxH3e+ur8JzSoH5V0H+xeZWygkxYCbt7kvVMP7tZO3iIidKdxIkbRkz2mG/7KVpHQrVYKLMWVQUyqVzKMNKRNjzJlQkdPN41K1zS0UStXMm/uLiMg1KdxIkWIYBt+vOcLbc3dhM6BV1RJ8cW9jAnzyYCsFmw22ToV/XofUWLC4QPPH4NbXwd375u8vIiI5onAjRUam1cboP3cxdd1RAO5uGsrbvevinhdbKZzZZ26fcHS1eRxSD277GMo1uvl7i4hIrijcSJEQn5rBk79sZcW+M1gsMKp7TYa2rYLlZse/ZKbByomwaiJY08HdBzq+DM0f10rDIiIOor99xelFnU/moe83sj8mEW93Vz66uwFd64Tc/I2PrII/n4Fz+83jsC7QYwIUr3jz9xYRkRumcCNObfPRCzw6dRNnE9Mp7e/J5EFNqVsu4OZumnzeHFezdap5XKwUdB8HdfpoJpSISAGgcCNOa872Ezz/+3bSM23UKevP5EFNCQm4ia0UDAN2TIcFoyDpjHmu8WBzpWHvwLwoWURE8oDCjTgdwzD4ZPEBPly0D4DOtUvz0V0NKOZ5E3/czx+Gec/BwcXmcXBNczG+ii1vvmAREclTCjfiVFIzrIz8I4JZ204A8Ei7KrzUrSauN7qVgjUD1k6CZeMgMwVcPaHdC9D6aXDzyMPKRUQkryjciNM4l5jGo1M3s+noBdxcLLzduy73NKtw4zc8vhn+fApOR5rHldqaT2tKVsuTekVExD4UbsQp7D+dwEM/bCTqfAp+Xm58eV9jWlcreWM3S42HJW/Dhm8AA7yLQ5cx0GCgBgyLiBQCCjdS6K3cf4ZhP28hITWTCkE+THmwKdVK+d7YzXbPhfkvQIL5Wot6d0PXMVDsBoOSiIjkO4UbKdR+Xn+U12fvxGozaFqpOF/d34SgYjcwFiYuGv56EfbMNY+LV4ZeH0LVjnlbsIiI2J3CjRRKVpvBu/N3M3nVYQD6NizH2H7heLq55u5GNits/BYWvw3pCeDiZg4WbveC9oMSESmkFG6k0ElKy+TpaVtZtDsGgOc6V+fJW6rlfiuFUzvgz6cherN5XL6ZuR9U6dp5XLGIiOQnhRspVE7EpvDwD5vYfTIeTzcXPhhQn171yubuJunJsPw9WDMJDCt4+kOnN6DxQ+CSB5toioiIQyncSKGx43gcD/+wkZiENEr6evDNA01oWKF47m5yYBHMHQGx5s7g1L4Duo0D/zJ5X7CIiDiEwo0UCn9HnuSZX7eRmmGjRmk/Jj/YhPLFfXJ+g8QY+HsURE43j/3LQ88JUKO7fQoWERGHUbiRAi0hNYPxf+9l6jrzSUv76sFMGtgQPy/3nN3AMMwNLhe+BqmxYHGB5o9Bx1fA8wani4uISIGmcCMF1sKdp3h99k5OxacC8GCrSrzasxZurjkcF3NmH8x9Bo6uNo9D6sHtn0DZhvYpWERECgSHh5uMjAyWLVvG6dOnCQ8Pp379+tdsv3r1anbv3p3tXFBQEH379rVnmZKPYhJSeXPOTubvOAVAxRI+jO0TTqucrjicmQYrJ8KqiWBNB3cf80lN88fA1eF/5EVExM4c+jf9uXPnuPXWW0lMTCQ8PJwnnniC+++/n0mTJl31mqlTp7JgwQJuvfXWrHPlypVTuHEChmHw68Yo3p2/m/jUTFxdLDzSrgpP3xqGl3sO1685sgr+fAbO7TePw7pAjwlQvKLd6hYRkYLFoeFm1KhRZGRksH37dooVK8bGjRtp3rw5PXv2pHv3qw/0bNy4Md9++20+Vir2dvhsEqNmRLDu0HkAwssF8F6/cOqUDcjZDZLPwz+vm+NrAIqVgu7joE4f7QclIlLEOCzc2Gw2fv31V15//XWKFSsGQNOmTWnRogX/+9//rhluzpw5wy+//EJAQABNmjShdOnS+VW25LEMq42vVxzi48X7Sc+04e3uynNdqvNgq0o5G1tjGLBjOiwYBUlnzHONB0OnN8E70J6li4hIAeWwcBMVFUV8fDy1a2dfDbZOnTps3rz5mtcePHiQWbNmER0dzdatW5kwYQLDhg27avu0tDTS0tKyjuPj42+ueMkT26NieemPCPacSgCgbVhJ3u0TTmhQDqd4nz8M856Dg4vN4+Ca0OsjqNjSPgWLiEih4LBwczFgFC+efRG2oKCga4aPQYMG8emnn+Lubk4F/uabb3j88cdp0aIFjRo1uuI1Y8eOZfTo0XlUudyspLRMPli4j+/XHMZmQHEfd17rVZs+DcvlbAsFawas/QyWvQeZKeDqae4F1fppcLuBTTNFRMSpOGyteW9vc1PChISEbOcTEhKyPruSli1bZgUbgKFDhxIUFMTChQuves2oUaOIi4vL+hUVFXWT1cuNWrY3hi4frmDKajPY9G5QlkUj2tO3UfmcBZvjm+HrDrDoDTPYVGoLj6+B9i8o2IiICODAJzcVKlTA3d2dI0eOZDt/+PBhqlWrlqt7eXt7c/78+at+7unpiaen542UKXnkXGIab8/dxaxtJwAoF+jNmD516VCjVM5ukBoPS96GDd8ABngHQdcxUP8eDRgWEZFsHPbkxsPDg65duzJt2jQMwwDg5MmTLF26lNtuuy2r3apVq5gxYwYAVqv1sqcua9euJSoqipYtNc6iIDIMgxlbjtNp4nJmbTuBiwUeblOZhc+2y3mw2T0XPmsOG74GDKh3Nzy5ERoMVLAREZHLWIyLycIBdu3aRatWrbjlllto0aIFP/zwA4GBgSxbtizr1dOQIUNYt24dkZGRZGZm0qBBA1q1akWdOnU4duwYX3/9NT179uSXX37BJYc7OsfHxxMQEEBcXBz+/v72/C0WaVHnk3l55g5W7j8LQM0QP97rV48GoYE5u0FcNPz1IuyZax4Xrwy9PoSqHe1TsIiIFGg5/fnt0HVuateuTUREBN9//z1Hjx5l+PDhDB48ONuYmrZt21KuXDkA3Nzc2Lx5M7/++itbt26lePHizJkzh44d9cOuIMm02vh+zRE+WLiPlAwrHm4uPH1rGI+0q4J7TqZ326ywcTIsfgvSE8DFzRws3O4FcL/6eCwRERFw8JMbR9GTG/vZdSKekTMiiDgeB0DzykGM7RtOleAcblJ5KhL+fBqiN5nH5ZvBbR9D6drXvk5ERJxeoXhyI84jNcPKx4v38/WKQ1htBn5ebrzSoxYDmoTi4pKDcTHpybB8HKydBLZM8PSHTm9A44cgh68bRUREQOFG8sCag2d5ecYOjpxLBqBHeAhv3laHUv5eObvBgcUwbwRcOGIe17oduo8H/zL2KVhERJyawo3csLjkDMbM38Vvm44DEOLvxVt31KFLnZCc3SDxDCx4GXb8Zh77lzM3uazZw04Vi4hIUaBwI7lmGAbzdpzkzTm7OJtobmtxf4uKvNitBn5e7te5GnM/qG0/w8JXIeUCYIHmj8Etr4Cnn32LFxERp6dwI7lyMi6F12ZFsmh3DABVg4vxXr96NK0UlLMbnD0Ac5+BIyvN49LhcPvHUK6xfQoWEZEiR+FGcsRmM/hp/VHG/72XxLRM3F0tDOtQjWEdq+Lp5nr9G2Smw+qPYMUEsKaBuw90GAUthoGr/hiKiEje0U8Vua79pxMYOWMHm49eAKBRhUDe61eP6qVz+Arp6FpzevfZveZxtU7Q8wMoXsk+BYuISJGmcCNXlZZp5fOlB/l82QEyrAbFPFx5qXtN7mteMWfTu1NizQ0uN39vHhcLhm7vQd1+2jZBRETsRuFGrmjTkfOMnLGDAzGJAHSqVYq37qhL2cAcrBBsGLBzBvw1EpLMsTk0egA6jQafHI7NERERuUEKN5JNQmoG4/7ew0/rjgFQ0teT0bfXoUd4CJacPG2JPQbznoP9C83jEmHmCsOVWtuxahERkX8p3EiWf3ad5rVZkZyKTwXgriahvNyjFgE+OZjebc2E9V/C0jGQkQyuHtD2OWjzLLh52rlyERGRfyncCDEJqbw5Zyfzd5wCoGIJH8b2CadVtZI5u8GJreaA4ZPbzeOKraHXRxBc3T4Fi4iIXIPCTRFmGAa/bozi3fm7iU/NxNXFwiPtqvD0rWF4uedgendaIix9F9Z/AYYNvAKhy9vQ4D7tByUiIg6jcFNEHT6bxKgZEaw7dB6A8HIBvNcvnDplA3J2g30LzLE1cVHmcd07odtY8C1lp4pFRERyRuGmiMmw2vh6xSE+Xryf9Ewb3u6uPNelOg+2qoSbaw6etiScgr9egl2zzOPACtDzQwjrZNe6RUREckrhpggxDIOHvt/Iyv1nAWgbVpJ3+4QTGuRz/YttNtj8HSwaDWlxYHGFlk9Ah5HgUczOlYuIiOScwk0RMmf7CVbuP4uXuwtj+4bTu0G5nE3vjtltDhiOWm8el20It30CZerZt2AREZEboHBTRCSnZ/LeX3sAeLJjNfo0LH/9izJSYeUEWPUR2DLAwxdueQ2aDQWXHAw4FhERcQCFmyLiy+WHOBmXSvni3gxpW+X6FxxeAX8+A+cPmsc1ekCP9yEgB6FIRETEgRRuioDjF5L5arkZUl7tWeva07yTz8PCV2Hbz+axXxnoPh5q3ab9oEREpFBQuCkCxv61h7RMGy2rlKBrnZArNzIMiPgNFoyC5HOABZo+DLe+Dl45nB4uIiJSACjcOLl1h84xL+IkLhZ4/bbaVx5AfP4QzB0Bh5aax6Vqm/tBhTbL32JFRETygMKNE7PaDEb/uQuAgc0rUKuM/yUNMmDNp7B8HGSmgpsXtH8RWj0FrjnYT0pERKQAUrhxUqkZVl6fHcnuk/H4e7kxonON7A2iNprTu2N2mseV20OvD6FE1fwvVkREJA8p3Dih6NgUHv9pMxHH47BY4I3b6hBUzMP8MDUeFr8FG78FDPAOMrdNqHeXBgyLiIhTULhxMqv2n2X4/7ZwITmD4j7ufHx3Q9pVDzZXGI6YBovehMTTZuP6A6HLO1CshENrFhERyUsKN07CZjP4YvlBPli4F5thboT5xX2NKF/cB45vgr9ehOjNZuOgquYrqCrtHVu0iIiIHSjcOIEzCWmM+G1b1p5RdzUJZfQddfBKvwAzR8D2/5kNPfyg/QvQ/HFw83BgxSIiIvajcFPIrdp/lmd+3cbZxDS83F146/a6DGgaCrvmwNxnIdkMPDS4F259A/xKO7ZgERERO1O4KaQyd88nYfYLnEuqQGNrM06Was3E+1pSzS8T/hgKO34zG5aqDbdPgvKNHVuwiIhIPrEYhmE4uoj8Fh8fT0BAAHFxcfj7+1//ggLm2PHj+E9uRaARl3XOcPfBUq0THN8ICSfB4gKtn4EOI8HN03HFioiI5JGc/vzWk5tCxDAMft98HMufT9HfEscBymMJ60LVM4uwxB6D3XPMhiXCoM+XUL6JYwsWERFxAIWbQiI2OZ1RM3ZwZucypnsuASBgwOcE125v7gt1chvsmQee/tBsKLh7O7ZgERERB1G4KQS2HrvAsJ+3cDYukfkekwGwNRpkBhswF98r29D8JSIiUsQp3BRghmHwy4ZjjJ6zi3SrjVf9FxKWHg3FgnHp9KajyxMRESmQFG4KqIt7Q/226TgA91XP5OET080Pu74LPkEOrE5ERKTgUrgpgI5fSObxn7awIzoOFwuMurUCQ46PwpKZClU6QHh/R5coIiJSYCncFDB/7TjJS39EEJ+aSXFvN35pe5Za216A+Ghw9YSeE7XBpYiIyDUo3BQQqRlW3pm3i5/WHQOgc9k0Pgn4Du8V/5gNAivC7Z9AiaoOrFJERKTgU7gpAA7EJPDkL1vZcyoBdzL5OmwdHU5+h+V8Cri4Q+unoO3z4OHj6FJFREQKPIUbBzIMg983HeeNOTtJybDS1WcfE32nUizqoNmgUlvo+QEE13BsoSIiIoWIwo2DJKRm8MrMSOZsP0EwsXwbNJ3WyUsgHigWDF3egXp3aXyNiIhILincOMD2qFiG/28rx88n8oDbYl7x/B3P5ETAAk0fhlteBe/iji5TRESkUFK4yUeGYTB51WHe+2sP1Y3D/On9HXWM/WAFyjSAXhOhnHbvFhERuRkKN/kkLiWDF6dvZ+XOo7zkNp2H3P7G1bCBhx/c+ho0HQIuro4uU0REpNBTuMkHkdFxDPt5CxVi17PQ8xvKW86aH9TuDd3Ggn9Zh9YnIiLiTBRu7MgwDP63IYqJf67nRaYywGO5+UFABXMWVPUuji1QRETECSnc2MmFpHRembWDzJ1/Mt/9O0pZYjGwYGn2CNz6Onj6OrpEERERp6RwYwcr959h7G/LeDL1a3p4bADAKBGG5Y5JUKGFg6sTERFxbgUi3KSmphIbG0upUqVwcXGx2zX2lpphZfxfu0le/x3T3H7B3zUZw+KKpfVTWNqPBHcvR5coIiLi9ByaCmw2G08//TSBgYHUqFGDsmXLMn369Dy/Jj+cTUzjyU9+peumh3nP/Vv8LcnYyjTE8sgy6PSmgo2IiEg+cWi4ef/99/n555/ZtGkTsbGxvP7669xzzz3s3LkzT6/JD0FGHJ8lPkNzlz1YXb2h67u4DF0MZeo5tC4REZGixqHh5vPPP2fIkCHUrVsXi8XCsGHDqFSpEt98802eXpMfXPxKYW1wP+mVbsH1yfXQ8gmtWyMiIuIADhtzExMTw7Fjx2jVqlW2861bt2bjxo15dk1+8uk5FlzdtR+UiIiIAznsyc2ZM2cAKFGiRLbzJUuWzPosL64BSEtLIz4+Ptsvu3DzULARERFxMIeFm4sznDIzM7Odz8jIwNX1yq9zbuQagLFjxxIQEJD1KzQ09GZKFxERkQLMYeGmfPnyAJw6dSrb+VOnTlGuXLk8uwZg1KhRxMXFZf2Kioq6mdJFRESkAHNYuPHz86NRo0YsWLAg61xGRgaLFy+mffv2WefOnTvHiRMncnXNpTw9PfH398/2S0RERJyTQxfxe/3117nzzjtp3LgxLVu25IMPPsDV1ZXHH388q81LL73EunXriIyMzPE1IiIiUnQ5dCr4HXfcwbRp0/j111+55557SEtLY8WKFZQsWTKrTcmSJbO9csrJNSIiIlJ0WQzDMBxdRH6Lj48nICCAuLg4vaISEREpJHL687tgbMokIiIikkcUbkRERMSpKNyIiIiIU1G4EREREaeicCMiIiJOReFGREREnIpDF/FzlIuz3+22gaaIiIjkuYs/t6+3ik2RDDcJCQkA2kBTRESkEEpISCAgIOCqnxfJRfxsNhsnTpzAz88Pi8Vyw/eJj48nNDSUqKgoLQZoZ/qu84++6/yj7zr/6LvOP/b8rg3DICEhgbJly+LicvWRNUXyyY2Li0vWDuN5QZtx5h991/lH33X+0Xedf/Rd5x97fdfXemJzkQYUi4iIiFNRuBERERGnonBzEzw9PXnjjTfw9PR0dClOT991/tF3nX/0Xecffdf5pyB810VyQLGIiIg4Lz25EREREaeicCMiIiJOReFGREREnIrCzQ06d+4cGzdu5NSpU44upVCLjo5m+/btJCYmXrVNXFwcmzZtIioq6qbaiGnz5s2sWbPmip8lJSWxefNmDh06dNXrc9JGICYmhi1btpCcnHzFz9PS0tiyZQt79+696j1y0qaoS0xMJCIigl27dpGamnrFNpmZmWzbto1du3Zdddn+nLQpauLi4li9ejUnT568apszZ86wceNGYmJi7N4mVwzJtddff93w9PQ0ateubXh6ehoPP/ywYbVaHV1WofLXX38Z9evXN8qWLWvUq1fP8PHxMUaOHHlZu08++cTw9vY2atWqZXh7ext9+/Y1UlNTc91GTLNnzzZcXFwMT0/Pyz77+eefDT8/P6N69eqGn5+f0bFjRyM2NjbXbYq62NhYo1+/fkaxYsWMJk2aGBUqVDB+/PHHbG3mz59vlChRwqhSpYpRvHhxo3HjxsaJEydy3aaoe+edd4xixYoZ4eHhRrVq1YygoCBj6tSp2dqsWrXKKFOmjFGhQgUjODjYqF27tnHgwIFctylKDh8+bAwdOtQICQkxXF1djU8//fSK7Z5//vlsPwuHDx9u2Gw2u7TJLYWbXJo1a5bh7u5urF692jAMw9izZ48REBBgfPzxxw6urHD57LPPjO3bt2cdr1271vD09DR++OGHrHPr1q0zLBaLMWfOHMMwDCM6OtooW7asMWrUqFy1EVNUVJRRvnx5Y/jw4ZeFm/379xvu7u7G119/bRiGYVy4cMGoUaOGMXjw4Fy1EcPo1KmT0ahRI+PMmTOGYRhGUlKS8d1332V9fubMGcPPz8946623DMMwjJSUFKNFixZG9+7dc9WmqNuyZYsBGDNnzsw698477xhubm5GfHy8YRiGkZiYaISEhBhPPfWUYRiGkZmZaXTt2tVo2rRp1jU5aVPU/P3338ZXX31lJCQkGAEBAVcMNz/99JPh7e1tbN682TAMw9i+fbvh4+NjTJ48Oc/b3AiFm1y6/fbbjW7dumU7N2TIEKN+/fqOKciJtGjRwhg6dGjW8SOPPGI0aNAgW5tXX33VKF26dK7aiPkXdrt27YxJkyYZX3zxxWXh5vXXXzfKlCmT7V9LkyZNMry8vIzk5OQctynqli9fbgDGmjVrrtrm888/N3x8fIykpKSsc9OnTzcsFkvWk5mctCnqFixYYADGqVOnss4tXbrUAIyjR48ahmEYv/32m+Hi4mKcPn06q82yZcsMwNixY0eO2xRlVws3t9xyi3HnnXdmO3f33XcbrVu3zvM2N0JjbnJp69atNG7cONu5Zs2aERkZSUZGhoOqKvwSEhLYu3cv1apVyzp3te/69OnTWe+Ac9JG4K233sLX15cnnnjiip9v3bqVRo0aZdtItlmzZqSmprJnz54ctynqFi9eTIkSJWjZsiX79u0jMjLysnEgW7dupVatWvj4+GSda9asGYZhsG3bthy3KepuueUWunbtykMPPcRff/3FzJkzee655xg+fDgVKlQAzO8xNDSUUqVKZV3XrFmzrM9y2kYud7W/e//7neVVmxuhcJNL58+fp0SJEtnOlShRAqvVSnx8vIOqKvwef/xxvLy8ePjhh7POXe27vvhZTtsUdcuXL+ebb75hypQpV22j7zpvnDhxguDgYHr06EHPnj3p168fZcqU4ccff8xqo+86b7i5ufHkk08SERHBCy+8wAsvvEBGRgYPPPBAVpsrfY/e3t54e3tf87u+tI1kZxgGsbGxV/wzmpycTFpaWp61uVEKN7nk7u5+2b/EUlJSAPDw8HBESYXeCy+8wNy5c5kzZ062P+Q5+a713+PaDMPg3nvv5cEHH2T//v2sWrWKgwcPYhgGq1atynq6pe86b7i7u7Nnzx46duzI/v372bt3L2+99RZDhgzhwIEDWW30Xd+8VatWcccdd/DVV18RGRnJgQMHGDx4MB06dOD48ePAlb9HwzBIT0+/5nd9aRvJzmKx4ObmdtU/o+7u7nnW5kYp3ORSxYoViY6OznYuOjqawMBA/Pz8HFRV4TVq1Ci+/vprFixYQJMmTbJ9drXv2sXFhfLly+e4TVFms9moVKkSK1asYOTIkYwcOZKZM2eSkZHByJEjWbt2LXD17xHIesSfkzZFXaVKlQB47LHHss498sgjZGZmsm7dOkDfdV6ZN28elSpVokePHlnnhg0bRnJyMkuWLAHM7/HkyZPZpnafPHkSq9Wa7bu+Xhu5XIUKFa74Z7R8+fK4uLjkaZsboXCTS507d2b+/PlYrdasc7Nnz6Zz584OrKpwevnll/n8889ZsGABzZs3v+zzzp07s2jRomzrhMyePZvWrVvj7e2d4zZFmaurK6tWrcr26/nnn8fDw4NVq1bRt29fwPwe169fn22NidmzZxMWFkbFihVz3Kao69q1K0C2v6xPnDiBYRgEBwcD5vd48OBBdu3aldVm9uzZBAUF0ahRoxy3KeqCg4M5d+5ctn/1R0dHX/ZdX7hwgZUrV2a1mT17Nl5eXrRt2zbHbeRynTt3Zu7cuVmh0DAM5syZk+1nYV61uSE3NRy5CDpx4oRRqlQp48477zTmzJljPProo4aPj49G1efSmDFjDIvFYkyYMMFYuXJl1q+dO3dmtYmPjzeqVKlidOnSxZg9e7bx0ksvGW5ubsby5ctz1Uayu9JsqYyMDKNRo0ZGixYtjBkzZhhjxowxXF1djenTp+eqjRjG/fffbzRo0MD4448/jBkzZhhNmjQxmjZtaqSnp2e16dKli1G7dm3j999/Nz7++GPD09PT+Pzzz7PdJydtirITJ04YJUuWNLp162b8+eefxu+//240bNjQqFOnjpGSkpLV7p577jEqVapk/PLLL8bXX3+dbYp9btoUJQkJCVl/J/v6+hrPPvussXLlSmP37t1ZbQ4fPmwUL17cuPfee405c+YYgwYNMvz9/Y39+/fneZsboV3Bb8Dhw4cZP348e/fupUKFCjz77LPUr1/f0WUVKsOGDSMiIuKy861bt2bcuHFZx6dOneK9995jx44dlC5dmieeeILWrVtnuyYnbeRfs2fP5pNPPmHx4sXZzsfGxjJu3Dg2btxI8eLFGTJkSNaTiNy0KeoyMzP54osv+Ouvv3Bzc6NFixY8/fTTFCtWLKtNcnIyEydOZMWKFfj4+HDvvffSv3//bPfJSZui7vjx43z88cfs3LkTd3d3mjRpwvDhwwkMDMxqk56ezqeffsrChQvx8PCgX79+PPjgg9nuk5M2RcnevXuzTe64qGPHjrz99ttZx/v27eP999/n4MGDVK5cmeeff55atWpluyav2uSWwo2IiIg4FY25EREREaeicCMiIiJOReFGREREnIrCjYiIiDgVhRsRERFxKgo3IiIi4lQUbkRERMSpKNyISJ7Yu3cvCxYscHQZWK1WVq5cyW+//ca+ffscXY6IOICbowsQkcJjx44dHDlyhNKlS1O/fn08PT2zPvvzzz/56aefHLpisWEYdOrUidOnT1OvXj38/PyoXr26w+oREcdQuBGR64qJieH222/n8OHDNG3alAsXLnDixAlee+01HnroIQBq1qxJt27dHFrnvn37WLZsGSdOnKBMmTIOrUVEHEfhRkSu68UXXyQlJYUjR45k7bZ+9uxZFi1alNUmLCwMd3f3rONp06Zddh8XFxcGDBiQdXzgwAEiIyMpXbo0jRo1yvYk6Go2b97M0aNHCQ0NpWnTplnn9+3bl9XnokWLcHd3p3fv3nh5eWW7/ujRo6xduxaAYsWKUbt2bapWrZqtTWRkJKdPn6ZNmzasWbOGs2fP0r9/f5YsWUJwcDBly5Zl/fr1+Pj40KFDBzZu3MjBgwcBKFmyJPXr18/amRogIiKCU6dO0aVLl2z9bNu2jTNnztz8Dsgiko3CjYhcV2RkJC1btswKNmD+EL/77ruzji99LTVr1qxs99iyZQtHjx5lwIABZGZmMmTIEObPn0/z5s05fvw4SUlJzJ49+6ob5iUnJ3P77bcTERFBkyZN2LJlCzVr1uTPP//Ez8+PgwcPsnLlyqxaXFxc6N69+2XhJioqKqu2hIQEVq5cyaBBg/j000+z2kyfPp2pU6dSrFgxgoODCQkJoX///rz11ltkZmYSHR1NnTp1aNmyJR06dGDr1q0sWbIEMDdy3bx5M1988QX33XcfYD75uu2224iOjqZkyZJZ/QwePJguXboo3IjktZvaU1xEioQnnnjCCAwMNL777jvj9OnTV2zz/vvvG/Xr17/iZzt27DB8fX2N8ePHG4ZhGO+++67RoEEDIz4+PqvNM888Y7Ru3fqqNbz55ptGhQoVsvo/c+aMUalSJWPUqFFZbVauXGkARkpKSo5/b0ePHjUCAgKMZcuWZZ174403DMD4888/s7Vt3769ERgYaERFRV3znrNnzzb8/f2zfn82m82oUqWK8eGHH2a12bp1qwEYe/bsyXGtIpIzmi0lItf13nvvcf/99zNixAhKly5NlSpVePLJJzl16tR1rz1//jx33HEHd9xxBy+88AIA3333HfXr12fBggX8/vvv/Pbbb5QoUYK1a9eSmpp6xftMmzaNIUOGUKpUKcB8cvTYY49d8fXX9aSmprJ69WqmT5/OmjVrKFu2LBs2bMjWpnLlyvTq1euya/v06UP58uUvO3/27FmWLFnCb7/9RmJiIomJiezZswcAi8XCQw89xHfffZfVfvLkybRu3ZoaNWrkun4RuTa9lhKR6/L19eWTTz7hww8/ZMeOHaxYsYIJEyYwb948duzYga+v7xWvy8zMZMCAAQQFBfHtt99mnT9y5AglS5Zk+vTp2dr379+f5OTky14lgTlWpkqVKtnOVa1alWPHjmEYBhaLJUe/l9WrV9O3b19KlixJ1apV8fHx4cKFC8TExGRrd7UByVc6/+mnnzJq1Cjq1atHmTJlssYe/feegwcP5o033mDTpk2Eh4fzyy+/8P777+eoZhHJHYUbEckxV1dXGjRoQIMGDWjevDktWrRgzZo1lw2Uvei5555j586dbNq0KVtg8ff3p3fv3rz44os57rtkyZKcP38+27nz589TokSJHAcbgBdeeIH77ruPDz74IOtckyZNMAwjW7ur3fPS88nJyTz77LPMnDmT2267DYDExER+/fXXbPcsW7YsPXr0YMqUKbRv35709PRsg6tFJO/otZSIXNfhw4cvO3fx9VFgYOAVr/nuu+/46quvmDlzJuXKlcv2Wbdu3ZgyZQrp6enZzkdHR1+1hjZt2jBjxoxs56ZPn06bNm1y8lvIcurUqWyvgvbv309ERESu7vFfZ8+exWq1ZrvnpU+kLhoyZAj/+9//+OKLLxgwYMBVn3iJyM3RkxsRua6XXnqJmJgYbr31VipUqMDRo0f54osv6NatG40bN76s/cmTJ3n88cfp0aMHR44c4ciRI8C/U8HHjRtH27Ztad68OYMGDcLNzY1Vq1aRkpLC7Nmzr1jD22+/TdOmTenXrx/dunXjn3/+Yf369axfvz5Xv5fevXszevRo0tLSyMjI4MMPP8THxyfX38lFoaGhNGrUiEGDBjFkyBAOHDjA5MmTcXG5/N+OPXv2xMfHh+XLlzNmzJgb7lNErk3hRkSu67fffmP16tUsXLiQpUuXUrJkST7//HNuv/12XF1dgeyL+BmGQe/evYHsU8JdXV0ZMGAA5cqVY/v27fz4449s3rwZPz8/+vXrR79+/a5aQ9WqVdm2bRvffPMNK1euJCwsjHHjxlG5cuWsNsHBwdx1111ZNV3J+PHjqVGjBuvXr6dYsWJMnTqVdevWERoamtWmbt26V7z2lltuoWbNmtnOWSwW/vnnHyZNmsTy5cspV64ca9as4a233rrsiZWrqyu9evVi+fLltG7d+qo1isjNsRiXvmgWERG7sNlsVK1alSeeeILnn3/e0eWIOC09uRERyQezZs1i3rx5JCcn88gjjzi6HBGnpgHFIiL54O+//8bV1ZWFCxfi7+/v6HJEnJpeS4mIiIhT0ZMbERERcSoKNyIiIuJUFG5ERETEqSjciIiIiFNRuBERERGnonAjIiIiTkXhRkRERJyKwo2IiIg4FYUbERERcSr/B3/kO/kvVJyUAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -3314,13 +3331,13 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.268675Z", - "iopub.status.busy": "2026-08-28T10:50:48.268597Z", - "iopub.status.idle": "2026-08-28T10:50:48.270166Z", - "shell.execute_reply": "2026-08-28T10:50:48.269963Z" + "iopub.execute_input": "2026-08-28T11:07:10.805387Z", + "iopub.status.busy": "2026-08-28T11:07:10.805305Z", + "iopub.status.idle": "2026-08-28T11:07:10.806977Z", + "shell.execute_reply": "2026-08-28T11:07:10.806696Z" } }, "outputs": [], @@ -3342,13 +3359,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.270917Z", - "iopub.status.busy": "2026-08-28T10:50:48.270837Z", - "iopub.status.idle": "2026-08-28T10:50:48.272328Z", - "shell.execute_reply": "2026-08-28T10:50:48.272103Z" + "iopub.execute_input": "2026-08-28T11:07:10.807752Z", + "iopub.status.busy": "2026-08-28T11:07:10.807679Z", + "iopub.status.idle": "2026-08-28T11:07:10.809209Z", + "shell.execute_reply": "2026-08-28T11:07:10.808951Z" } }, "outputs": [], @@ -3373,13 +3390,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.272923Z", - "iopub.status.busy": "2026-08-28T10:50:48.272856Z", - "iopub.status.idle": "2026-08-28T10:50:48.413147Z", - "shell.execute_reply": "2026-08-28T10:50:48.412877Z" + "iopub.execute_input": "2026-08-28T11:07:10.809990Z", + "iopub.status.busy": "2026-08-28T11:07:10.809920Z", + "iopub.status.idle": "2026-08-28T11:07:10.950778Z", + "shell.execute_reply": "2026-08-28T11:07:10.950379Z" } }, "outputs": [], @@ -3412,7 +3429,7 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(len(in_str))\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if i < 100:\n", + " if i < step1:\n", " i += 10\n", " else:\n", " i += 100" @@ -3420,13 +3437,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.414060Z", - "iopub.status.busy": "2026-08-28T10:50:48.413988Z", - "iopub.status.idle": "2026-08-28T10:50:48.459197Z", - "shell.execute_reply": "2026-08-28T10:50:48.458946Z" + "iopub.execute_input": "2026-08-28T11:07:10.951720Z", + "iopub.status.busy": "2026-08-28T11:07:10.951646Z", + "iopub.status.idle": "2026-08-28T11:07:10.996769Z", + "shell.execute_reply": "2026-08-28T11:07:10.996454Z" } }, "outputs": [ @@ -3434,12 +3451,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[np.float64(7.152557373046875e-07), np.float64(5.7220458984375e-07)]\n" + "[np.float64(7.390975952148438e-07), np.float64(5.483627319335937e-07)]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3479,13 +3496,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.459957Z", - "iopub.status.busy": "2026-08-28T10:50:48.459883Z", - "iopub.status.idle": "2026-08-28T10:50:48.472521Z", - "shell.execute_reply": "2026-08-28T10:50:48.472253Z" + "iopub.execute_input": "2026-08-28T11:07:10.997701Z", + "iopub.status.busy": "2026-08-28T11:07:10.997626Z", + "iopub.status.idle": "2026-08-28T11:07:11.008540Z", + "shell.execute_reply": "2026-08-28T11:07:11.008185Z" } }, "outputs": [], @@ -3555,13 +3572,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.473287Z", - "iopub.status.busy": "2026-08-28T10:50:48.473214Z", - "iopub.status.idle": "2026-08-28T10:50:48.475262Z", - "shell.execute_reply": "2026-08-28T10:50:48.475039Z" + "iopub.execute_input": "2026-08-28T11:07:11.009444Z", + "iopub.status.busy": "2026-08-28T11:07:11.009368Z", + "iopub.status.idle": "2026-08-28T11:07:11.011492Z", + "shell.execute_reply": "2026-08-28T11:07:11.011200Z" } }, "outputs": [], @@ -3620,13 +3637,13 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:50:48.475921Z", - "iopub.status.busy": "2026-08-28T10:50:48.475818Z", - "iopub.status.idle": "2026-08-28T10:52:51.192692Z", - "shell.execute_reply": "2026-08-28T10:52:51.192214Z" + "iopub.execute_input": "2026-08-28T11:07:11.012259Z", + "iopub.status.busy": "2026-08-28T11:07:11.012187Z", + "iopub.status.idle": "2026-08-28T11:09:10.902184Z", + "shell.execute_reply": "2026-08-28T11:09:10.901561Z" }, "id": "DZBiw_EepT5x" }, @@ -3656,9 +3673,9 @@ " print(\"Incorrect result\")\n", " sizeofarray.append(i)\n", " timings.append([np.average(python_times), np.average(rust_times)])\n", - " if i < 100:\n", + " if i < step1:\n", " i += 10\n", - " elif i < 1000:\n", + " elif i < step2:\n", " i += 100\n", " else:\n", " i += 1000" @@ -3666,19 +3683,19 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "metadata": { "execution": { - "iopub.execute_input": "2026-08-28T10:52:51.194003Z", - "iopub.status.busy": "2026-08-28T10:52:51.193913Z", - "iopub.status.idle": "2026-08-28T10:52:51.233367Z", - "shell.execute_reply": "2026-08-28T10:52:51.233067Z" + "iopub.execute_input": "2026-08-28T11:09:10.903993Z", + "iopub.status.busy": "2026-08-28T11:09:10.903903Z", + "iopub.status.idle": "2026-08-28T11:09:10.942054Z", + "shell.execute_reply": "2026-08-28T11:09:10.941722Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3733,66 +3750,57 @@ "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { - "0060847d73ee4413b4770132aad88aa5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0072758cb5a441a189c874088e2e4f9f": { + "00018d66c6ba4416a89b82dfff6b4ce7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a819b15c93f48f1ace585cd53454e4d", + "IPY_MODEL_49ddcabcc7e74ea183ef91cdd04f4930", + "IPY_MODEL_b3debfbb74194023aa76ad471799c958" + ], + "layout": "IPY_MODEL_386c2cefc93c4946a14038f8ef5e9365", + "tabbable": null, + "tooltip": null } }, - "0099e0eed0af4be88b3d64f9e7069ca0": { + "0014f231b32443b8bfab117ab121d886": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_d3358f971f0d48f88a5d44c91d3fb7a6", - "placeholder": "​", - "style": "IPY_MODEL_8b95af3fe6ec49b6a2f3d7edfd4172a5", + "layout": "IPY_MODEL_b025dc1794eb469185ae0f899cddd156", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_f6bb84427fc1406bb599d3c13980a0f7", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  74%" + "value": 299.0 } }, - "00c2ce8137c8400d8a248a035dec5b14": { + "006018e1b5ee4779be2bf67464c6cba1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -3845,153 +3853,120 @@ "width": null } }, - "00fa80e77f7741519634dfcf9bad01de": { + "00ab537bb0dd4bb2aec926f542d533f7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_776ad76aba9548ff87f451346ffe5e6e", - "IPY_MODEL_a355e395f10040dfa002089118841303", - "IPY_MODEL_f1e87e57b914424cbcfa344bfadcb60e" - ], - "layout": "IPY_MODEL_eed9040d31db4bd1bec29339e53e3306", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1863824d3efd4c0499f8f9d76002f1fa", + "placeholder": "​", + "style": "IPY_MODEL_95e384cd1d254baeb3afbcef94dce794", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" } }, - "0126894018224984b563e8bcb410d05d": { - "model_module": "@jupyter-widgets/base", + "00c26a01e7784379a19b061b60bd2c74": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "FloatProgressModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_944a3d36f7aa4379b2a983bc7ac55016", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_513d7d38f80149eb9b668d4dca8b9d40", + "tabbable": null, + "tooltip": null, + "value": 19.0 } }, - "01276c00429544beacdb0a66b06f7676": { - "model_module": "@jupyter-widgets/base", + "00ddcba768f2455bbd3f6d393cf0e659": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_aa8f243213e14ddb879fc3cfe6c10b03", + "placeholder": "​", + "style": "IPY_MODEL_b4ffb2e0fd1241a0975082f6b1152276", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  76%" } }, - "01364955bb824efb8419965b3dfd964d": { + "00face300426462b818c3096297f250e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7fa96e9bc18a4cabbba007218253de43", + "placeholder": "​", + "style": "IPY_MODEL_e5eebb51cad54655ac58f2f9dd88f6b1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  99%" + } + }, + "01256c047da4493da14ae32a9a0fafb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "0194287cfbf349ba9a6b415bea46ab81": { + "014a73554b5c42c1bea738f40927d8a6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -4006,16 +3981,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e40fe9987f85442296584419162dd149", - "IPY_MODEL_6a241b90ea934dfbb7681056ccf7de62", - "IPY_MODEL_b87b207d94984923a25fde279d144d9a" + "IPY_MODEL_facca1af79104c58abe31cecbae54578", + "IPY_MODEL_b8f17ab6d50745839aae7f0fd65d6c49", + "IPY_MODEL_3a41e9261135449a83c8c44210e1a03f" ], - "layout": "IPY_MODEL_1d0be30994da4e6798e43238564de104", + "layout": "IPY_MODEL_a516d3458e0948b3940132c58a0f1f2a", "tabbable": null, "tooltip": null } }, - "01fe3f8bfc9441f3a6db7a92d65dcdab": { + "019811250c8c4265a15441274b93401d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -4031,17 +4006,140 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_e7478027f5ad4cd1bbc0960ace565444", - "max": 39.0, + "layout": "IPY_MODEL_89e0bbabedc847349b39bc75c88c9736", + "max": 699.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_5a2877cdbaf34cfdad1e409dc8f388e7", + "style": "IPY_MODEL_9dee15171132423785e164874c7ef163", "tabbable": null, "tooltip": null, - "value": 39.0 + "value": 699.0 + } + }, + "01ab757ca5da461e8b768a1fa474ffb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_96d4ed7b866a43998b0fba08c9272608", + "IPY_MODEL_2a307835b23b41eda95384f01f436666", + "IPY_MODEL_854ec3a8d681477bba97f3a245f61b66" + ], + "layout": "IPY_MODEL_900cef3116ac40dbab13f4199ecda0ec", + "tabbable": null, + "tooltip": null + } + }, + "01b7401a95654327b9d2d49a0586cbda": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "01e4f1bc2f974d9ea6fb9184094f7764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0f9a16a5e2274dbf99d779537f7746fb", + "IPY_MODEL_77ebf88552fc41d5a5f0c5e1221ae215", + "IPY_MODEL_a2e7b50d04404434a1401dc255ea0d5b" + ], + "layout": "IPY_MODEL_3b9f60b3b1dc4564816deb44b0bffb54", + "tabbable": null, + "tooltip": null + } + }, + "01fecabcf5764c239f2c1da85d1352a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4b7a7a6080cd4f03a858101abd7c712e", + "placeholder": "​", + "style": "IPY_MODEL_7d5ea3d0cbb34492b8f76b05274a8590", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "0210fd179f4447ebaec52a81b5edbe1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "0252dffdfd354d2a8150275e552ebee0": { + "0216c0cbb3ac48809a3f7b28b2a3e541": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0220b9c42e2b448ea030289b9f44cd72": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4094,53 +4192,7 @@ "width": null } }, - "026f1affcc3f4093bef8fd601c5e9a78": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_46aedaa7a7d34779837b93dcf3916e32", - "placeholder": "​", - "style": "IPY_MODEL_606fb842ff3c4ffc8dddc6b281d2c021", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" - } - }, - "02c55abb74db4006924148d88a1b3732": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8ab9fcd143bf46919318a3bb77aa3e1c", - "placeholder": "​", - "style": "IPY_MODEL_fe0f230185f2470c963a01e6393ced04", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" - } - }, - "030a6f3fea224c8a82f8cdce0b082606": { + "02427ba1c88340928ae2a9221dc3bf78": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -4158,7 +4210,7 @@ "text_color": null } }, - "0320460434d44245b2d484162e67183c": { + "02597743ea5f499a8259286469b67915": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4211,7 +4263,185 @@ "width": null } }, - "0328cc2d5ff04b8498744959cf91e87d": { + "028d57ef98eb42179a81de20d24fd468": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c0273c527f2342e48179c73f1fb9f7dd", + "placeholder": "​", + "style": "IPY_MODEL_7112463e81b045839ebfbb1667af164e", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 356.74it/s]" + } + }, + "02c59e8839a547448182ebe6c3d275a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_09871af2e8664e43bfc668ac25809fcb", + "IPY_MODEL_1db0bd5d1b1f464ab79e0c100926b1bd", + "IPY_MODEL_ca4ac9a2f5c643d2b16f01cba836bb86" + ], + "layout": "IPY_MODEL_ee2a530b7e5042b4ad01b4b832eb4e01", + "tabbable": null, + "tooltip": null + } + }, + "02ec68869d9948b58ec365abbc9f4dbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_be08a34588634a7cbe7e8f9ccd7e921f", + "IPY_MODEL_4a6371bc526b41a78fb0f2e045a8b04a", + "IPY_MODEL_119cd69811a54adb8eeb481810efce1e" + ], + "layout": "IPY_MODEL_aa302e7632234a9a8d3236e54be0fca9", + "tabbable": null, + "tooltip": null + } + }, + "02f3a258b1134729b738ef9faa00f48b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0308c1dd813b47ddb96246a6136efaec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "033e9d6c632d49a89dfaab95604e100a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "03665d92883945c1813c348ad9c23bc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_083726dd0792422e9e148a1fe4d294b7", + "placeholder": "​", + "style": "IPY_MODEL_df35e0940f1649aaa22c9ef23f9f5013", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "0370bd03504c4ceb855170abe09521a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0372cb8ec37947449d5bd44c977d44a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "03bf9748f94e40ec90195f6644bca4fa": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4260,11 +4490,59 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "033245f09b9b44d89d4679e28ace6ef2": { + "04053217f8dd4271b0d7a7aac21cddde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "04a8b7dd821745fc914e50f13b873036": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "04bbb697ff2a46c299d60c00158249e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "04ee0f633cf4430b86644f5e48d8128c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4317,7 +4595,7 @@ "width": null } }, - "034be21e4dd04b29b643eaa1a9df3b11": { + "058433b8a9be48a4a53a01d3d95f4565": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -4335,33 +4613,30 @@ "text_color": null } }, - "03620e83b2a54d48974c46c04af50a11": { + "0585bd3ba4114cd0ba5973af673efc7b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0d6c2a38346e4a50b1c140774709c45c", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_fe833ec08ef84467be5a41bc49e84336", + "layout": "IPY_MODEL_0f53be30de084c4fa7493e9f5a7077b4", + "placeholder": "​", + "style": "IPY_MODEL_5eacec1c81b5411e8bb2a18375a08d6e", "tabbable": null, "tooltip": null, - "value": 799.0 + "value": " 35/69 [00:00<00:00, 346.41it/s]" } }, - "03cdefc6bcc3441c96d965034eb1c6f5": { + "05c83253a4cc42c4a26d1fea75412c9f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4414,33 +4689,7 @@ "width": null } }, - "03ecefcfa09d4e8384ff3a8c933522bc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ba05376918f94f348dcc480f6bce817a", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_8428758943004c549e3fc8419c1af086", - "tabbable": null, - "tooltip": null, - "value": 49.0 - } - }, - "044dfc445e544deaaf2bc132418a4ac8": { + "05e638b0a4d24f09add74e870206463b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4493,7 +4742,7 @@ "width": null } }, - "04989c6b1d6d487786b5cc6185bbe9f3": { + "05f173a45ab24d17b481680442e99912": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4542,52 +4791,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "04f8f3ecb7ab4726a414c4953afd14f3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_85b2264e560f4dfaa64ee77e144a3d20", - "placeholder": "​", - "style": "IPY_MODEL_766f2422c6c14704bbea3fe759a29a31", - "tabbable": null, - "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" - } - }, - "0514849d6d8c4727a4751a7c66a05ca7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "053c536d46334f02bcc1be9ebad98279": { + "06066fd514d846019d9646ede8235db6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4640,7 +4848,7 @@ "width": null } }, - "0563ab96bb5f4cd0a9f2ce2da290a240": { + "060c4d711a4a4a2089a8762d28cf28a1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -4655,16 +4863,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_0ddc57e0e4f04cbb9469b145769e8c2d", - "IPY_MODEL_632bda88d5834271a6286cec2918ae51", - "IPY_MODEL_c1d5610dee5a455094329f5deb02f19d" + "IPY_MODEL_65d49a6340524bed856032b498447954", + "IPY_MODEL_a02ef4c3d2e543339d9cb7ac47356b0b", + "IPY_MODEL_5da1cbae882749029baaa4c0b450234f" ], - "layout": "IPY_MODEL_a06fa235eb974b11919167dc583e4409", + "layout": "IPY_MODEL_eabd5e7ec89241859936896cdc5169d4", "tabbable": null, "tooltip": null } }, - "059d0fbaeccd4aeea43f24e93d191b08": { + "0622939b090f45c3970397baf7a64815": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -4679,16 +4887,69 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_f22d03c204a342288dd7efe8a22d48ed", - "IPY_MODEL_ddf2ca4ebb8741399cdcd4dc0c972dc3", - "IPY_MODEL_e5d527029e744ec6b36b963d68e2c649" + "IPY_MODEL_369cd22c94c4439db53d36b8b9887e32", + "IPY_MODEL_42413899df1b4546a738aadc58d3e98e", + "IPY_MODEL_8e8859e575224fa8b8c7b6dbc23bc628" ], - "layout": "IPY_MODEL_fd0a818a3abe4d83b5db0d8cebfb7225", + "layout": "IPY_MODEL_b9ecaf3c140c4f9ba60c54de797c8773", "tabbable": null, "tooltip": null } }, - "05ae8b0f921d49dcacef411f7595984c": { + "063ac2284c704b9280d8c4dba8410e8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0643c852f8164b8a950b8438a28531bc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4741,31 +5002,30 @@ "width": null } }, - "062dda88b8404d12a8d6f135b976191f": { + "06c542b4f87b407499fa3333e2de571b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_66e9d77edd784b41a9b35a676021b82d", - "IPY_MODEL_e01c4b3ba4ea4da5849828f855afbb7a", - "IPY_MODEL_d600dbd8924f4d409c5e5a110d276ee5" - ], - "layout": "IPY_MODEL_85a29b2dd1634be7ad97027681f62fb0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_825c17e5f75f469aa183d288ff12b41f", + "placeholder": "​", + "style": "IPY_MODEL_1f293337097945b8b6d9af42553f4171", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 36/69 [00:00<00:00, 351.14it/s]" } }, - "0638947f16b941a39beb81ecb130627f": { + "06e0d6c5ba154c32b21d3708c8e41a89": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -4783,7 +5043,7 @@ "text_color": null } }, - "064f561913a64aa18e47a14c7d705634": { + "078d63a64ec741818647072cca339641": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4836,7 +5096,7 @@ "width": null } }, - "067db5ac65ff4bd989a502badf2ccead": { + "07ce408250e744bd89d3fe9ca3d2da11": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -4885,109 +5145,156 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "067ef8d9b43f475c8bafd8641e82b903": { - "model_module": "@jupyter-widgets/controls", + "07f5cda023544b3bbaa36c10d7e3c242": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "06971c04a2ae4553bf2088ce320a6a02": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "070410c8505741cb9d891b61db4b1d67": { + "07fb3573ab054b70832e2fc617b70e32": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2ce5391336384dce9727c24bebd9cf25", - "max": 699.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_09080df737fc4ffe8e8bb62b25f949d2", - "tabbable": null, - "tooltip": null, - "value": 699.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "0722cdd68ced4db8ac1516a4c8e0852b": { - "model_module": "@jupyter-widgets/controls", + "083726dd0792422e9e148a1fe4d294b7": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "075e2975edcc4b538157b98ef22e4ad1": { + "083d597e30d34df1ad26947634d26f64": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ca63e6ec056c4aa481e9895ffec8aece", + "placeholder": "​", + "style": "IPY_MODEL_269418aec0564953b87e2a3737815ff3", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" } }, - "07847480e58a43e9ae3aa39669ceb5a2": { + "0871d638a80a48bfae0a624154af9132": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -5002,15 +5309,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f60661654b89466394e752e2c5aafd51", + "layout": "IPY_MODEL_e1df6f2066f34e3587170990416186bc", "placeholder": "​", - "style": "IPY_MODEL_bf3b64c6daf34adb94322fe66be5485c", + "style": "IPY_MODEL_4d2ac87224c845d2b404995d80615a9c", "tabbable": null, "tooltip": null, - "value": " 74/99 [00:00<00:00, 273.30it/s]" + "value": "Converting outputs to QuPath JSON.:  73%" } }, - "07b2a8bef0984a42a8b9bd4f68671314": { + "087f9233505e4f38b5e276a8fb744d62": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5063,54 +5370,49 @@ "width": null } }, - "07d17c41ab2d4770bb6098c26363e34b": { + "0887380ca11d47c5bd346ff600ae5ba9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_39d947fbc8bc4b239cfdb1a73869ec61", - "placeholder": "​", - "style": "IPY_MODEL_edbc56fcfef44c16a94f76c9082fe44f", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "0866b3ae2bb64864bc472d1e3501d49b": { + "08b73cfbb8b243a9aee3c9543daa634d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f038310c56d84ff98cd045fc75d74752", - "IPY_MODEL_9fc95f811a0643df88cf59a88f77e44e", - "IPY_MODEL_5dc8a57043634ef88b6a71d614a0e786" - ], - "layout": "IPY_MODEL_7021866ffaf74b48b951a0d457173c2e", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_05c83253a4cc42c4a26d1fea75412c9f", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_63e0cc98313a4238a7b905ab4956df34", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 399.0 } }, - "0870533661634ff0aba3af61c7d1f45b": { + "08b77c7e63524316b42c0781a8840904": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5163,7 +5465,30 @@ "width": null } }, - "08925efaf2434c049defe77e47ce5277": { + "08d49b42f5ad4d9591b07f2edfbc7609": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_17d1b2af161546078819bbf8dba745ed", + "placeholder": "​", + "style": "IPY_MODEL_3f44772075a84396b50d6f348e95da0f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  91%" + } + }, + "08f2eb43ec5744e4a0cf47e083e8d02c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5212,11 +5537,57 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "089482d21d104b2091c8783589513134": { + "093ef839989f4971a4fbf57157b4144c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9c0e7ff131724b9ab99421ec5b86189f", + "placeholder": "​", + "style": "IPY_MODEL_b3c49f7322214952855810016b5872bd", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  98%" + } + }, + "09871af2e8664e43bfc668ac25809fcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_694b01eb169b48dab92ee4b39d34f7e4", + "placeholder": "​", + "style": "IPY_MODEL_a6945edce8d140bfa82de7cfa227ae82", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "09bc7553943a451db3d1e7c4c0167763": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5269,7 +5640,7 @@ "width": null } }, - "08a4c1252645469aab123b139f486913": { + "09ee7ad2811c4a4e9cb196d391cb0748": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5322,7 +5693,74 @@ "width": null } }, - "08b2544827604ac88f95a23a1587e481": { + "0a21bf172fa84989a24711c9887c8560": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bac21c5ee3234e99b8741d14d56a2b36", + "placeholder": "​", + "style": "IPY_MODEL_3d49d623fdf94fb59e5779765eeb932a", + "tabbable": null, + "tooltip": null, + "value": " 35/69 [00:00<00:00, 349.65it/s]" + } + }, + "0a31f5c3e3b94f26a9bdd7f05f3a0b4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b115d600d7f42c3ad2ceb02cfa2ab0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3b0c9b2f34fa46bc8f98a35807f852f3", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_64ca28fa8b57488d87517b5275f838ff", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "0b13a5d3a66f497a8f64b903a3d6dcf1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5375,7 +5813,25 @@ "width": null } }, - "08cf7d4ce5764be7a8d1a0d02365cd19": { + "0b3645ef51674ceeb20cb60cfb3687c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0b7ab4273a604b0d9948178b5eed6864": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -5390,15 +5846,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_12492cb92bbf4157a0bdff36097e517e", + "layout": "IPY_MODEL_d772f36f1ef44ba9953b55f6e134c017", "placeholder": "​", - "style": "IPY_MODEL_10f63dcb334a4b37ae3e23201fdad024", + "style": "IPY_MODEL_c22eb2b7dc84430ca844699b9b3bec57", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": " 295/299 [00:00<00:00, 348.60it/s]" } }, - "08edb965c1a0472287c034112093d682": { + "0b7d4ed5765e4aca8bb6141cc943eed9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -5413,31 +5869,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_1b359157d85a4f4b8e7b457e72ef4b20", + "layout": "IPY_MODEL_f4cff59a64ea49b0ba529be7751669f5", "placeholder": "​", - "style": "IPY_MODEL_7249d35604ea4dd5ad74f2f58dc166b8", + "style": "IPY_MODEL_8100c3c3f3e549d39c669afdf6656465", "tabbable": null, "tooltip": null, - "value": " 72/89 [00:00<00:00, 355.19it/s]" + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "09080df737fc4ffe8e8bb62b25f949d2": { + "0b80afcbf3674e3a9ea902a7c2d8f1c9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "0936de0747cb4882ab7e6f256d7aa4eb": { + "0bae579ff56d432485df4d966054ba63": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5490,30 +5948,59 @@ "width": null } }, - "09758263bc224d42ab0415b16f594e8d": { + "0c8f156a0dee46a0aee4dda2988cc23a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c04222edb66a41d89829c004a0a610ba", - "placeholder": "​", - "style": "IPY_MODEL_59ffdeae8b104c3fad63490531b041ea", + "layout": "IPY_MODEL_603a889473154bf0be31c2f6252c5ad3", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_75122864ec6847fd9247373a01af451f", "tabbable": null, "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" + "value": 799.0 + } + }, + "0cf89b4042ee44f89d3e53c4e6671756": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9366946ef7e14c51ba46def7c98e074d", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7285f3cbf7c84a0986d0d5a459ada8c2", + "tabbable": null, + "tooltip": null, + "value": 79.0 } }, - "09896c1482f9411ead4ab9b1e53033df": { + "0d0413dff8834c16882a4ff65642f2f8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5566,7 +6053,33 @@ "width": null } }, - "09b6451b6d2a470a99ecf69281636987": { + "0d450d0fcddf475eb9a4055a9e08ae1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b5e89d421ae34cc6902ea09438556b0d", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_76d9e0ea8bd14332802ebb8ba9f2067b", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "0d5f5140a82642bda3459bcff9480776": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5615,11 +6128,61 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "09d89a1d3bb64595a47d85dfecf2fe5e": { + "0d6c5c8a761b4d42896494df7083ed51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e3f58d2864e64688a129cd315423e642", + "IPY_MODEL_a9e9d589b357412aa16caf06badfd984", + "IPY_MODEL_328695d425cb424993c5f98bb01264cb" + ], + "layout": "IPY_MODEL_62b49871b3f344e09b874af7c381742e", + "tabbable": null, + "tooltip": null + } + }, + "0d753255846948a2bb93aec74c8bc444": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_587990fb11284746920ea8fe9badca6b", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_04053217f8dd4271b0d7a7aac21cddde", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "0d8c517392054f02957a8e34aa46ef46": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5672,33 +6235,7 @@ "width": null } }, - "0a320e2aa9eb4d89afaf9573cfcc5216": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e4f00fc898ac4023b7ff5b6a84d59c44", - "max": 69.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e0bb0891085947018543e0b25fe6a5dd", - "tabbable": null, - "tooltip": null, - "value": 69.0 - } - }, - "0aa5d390f8884c5483607403b475ec17": { + "0dd68639fb61466d8c4e4dd16f34d07c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5751,41 +6288,7 @@ "width": null } }, - "0ab0066603cf4d5995c04bf52784df9b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "0ab84b3feb0e4fb9b398271421a62892": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0b1fe2bfddaf432e8689aa62f0b7a7fe": { + "0e06f27415cb455ab610931fd9497cf7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -5800,74 +6303,68 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_37aa79bf53a44b3aba45d335e01a52c4", + "layout": "IPY_MODEL_b0fee13778044f908c58f4c29db9ddb6", "placeholder": "​", - "style": "IPY_MODEL_5343a2a9a0d145e9b772c8a2bd7f9c3e", + "style": "IPY_MODEL_5fbbefe59a684a8f9bf4da79f03fdb37", "tabbable": null, "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "0b20702be4c64ecd98b5e0d942983f28": { - "model_module": "@jupyter-widgets/controls", + "0e418415487743fc92d75f83c3f16a4b": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "0b3333a3f2d242eeab9043467a135115": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9994d11815364fe0a205a24457276f26", - "placeholder": "​", - "style": "IPY_MODEL_2b89575e8d774ab289d214e70fc2ee7d", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" - } - }, - "0b5a2fd13fcf4d4b8845daec25f835c2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "0b9d5860db89472eafcd3106dc31cdeb": { + "0ef57969f17642eeb71d761870343c1b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5920,33 +6417,7 @@ "width": null } }, - "0bc9005f8c1c4516afe4fa8b208fb1eb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d5fb1762b5754525b2dfdefa48b7826a", - "max": 59.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_296269f997e44a7081d95fa892581460", - "tabbable": null, - "tooltip": null, - "value": 59.0 - } - }, - "0bcedd3d0a1647868942cd10b21bdc7a": { + "0f53be30de084c4fa7493e9f5a7077b4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -5999,7 +6470,30 @@ "width": null } }, - "0c358a0b1a04406b8c14c18ae63b7091": { + "0f638ebe107040cf9a64cbf06516ace7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c19be2c73b2549bf83276ad2f7fa21df", + "placeholder": "​", + "style": "IPY_MODEL_47d9d90e096b4c29b6a037e99b439f1f", + "tabbable": null, + "tooltip": null, + "value": " 368/399 [00:01<00:00, 360.80it/s]" + } + }, + "0f695329870540f3bcf2fb1cb665d34d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6048,11 +6542,34 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "0c35d03637944273aea93bb69924aabc": { + "0f7eb2d470e9485da4f1115acc2f2fab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9f2d1b1364024a939cea0045a8e558d3", + "placeholder": "​", + "style": "IPY_MODEL_d826a2c7e5b04783ba7fb089403f8ddb", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "0f80f42d60484e3f8df239c941ebf463": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6101,37 +6618,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "0c5255b8243149c3a080248829a09f85": { + "0f9a16a5e2274dbf99d779537f7746fb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ebfc2591c3ff485e803aee787d8ed593", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_204c00aaed314746bba9ba40a91e8dea", + "layout": "IPY_MODEL_5fd81d37c8c148f4a1b85b04c508a3e3", + "placeholder": "​", + "style": "IPY_MODEL_ded69506bd014ce6a228da04832b18bd", "tabbable": null, "tooltip": null, - "value": 49.0 + "value": "Converting outputs to AnnotationStore.:  90%" } }, - "0c6502ee8c2c42b7ba21f18ca572eac0": { + "0fb58817bee248f2887227e04a10e2c5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6184,47 +6698,69 @@ "width": null } }, - "0c83849d2aac453b9384639ee6bb8cca": { + "100854f2e558489b8c0777e930f1aa82": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_33fb7da188e444138750822e841e9b94", - "IPY_MODEL_0c5255b8243149c3a080248829a09f85", - "IPY_MODEL_40e2610cd39e4eeaa107c8784ab9323a" - ], - "layout": "IPY_MODEL_1cf274d7bb2f4275b01d4ef77e61d5cd", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "0d1f00eccad145d18d77ffacd34fdcfc": { + "1008e4d62ad6437589931a2f33acb1b3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "103a7a1aa9094d1bb78c6b9ec7ade33c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f7ae1100dbdc4027a186f8e8e97f9732", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_0372cb8ec37947449d5bd44c977d44a6", + "tabbable": null, + "tooltip": null, + "value": 999.0 } }, - "0d50d58d19724a3da81062fd5cb4b2c1": { + "10599ad6cce34f23abe77b6a4d3056d9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6273,11 +6809,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "0d5640937572475e883381477c91ee26": { + "1078e72727fb40578ac947e90578782d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6330,31 +6866,7 @@ "width": null } }, - "0d5b733a0be84859b36df24d1a76e762": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_68433c7916cc4732a85ef3ed3a3c6e56", - "IPY_MODEL_10e7fae882104853a4eb4c34f69caed3", - "IPY_MODEL_a8e1874938074203ac81d478fd1e201d" - ], - "layout": "IPY_MODEL_d9af00f60d5446acb1d9c1cc0cfe770a", - "tabbable": null, - "tooltip": null - } - }, - "0d6c2a38346e4a50b1c140774709c45c": { + "10a5b7dd74c843199aabd953adc53c8a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6403,11 +6915,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "0d9da7bf768a43f7ad3e279838a2bfce": { + "1109ba3c8a164801a60f1d6eef1f9f56": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -6425,54 +6937,25 @@ "text_color": null } }, - "0db8d88810a3451c80f64a5362480743": { + "1136f9c98e2e4cd4820cb10e0b0e5757": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6e31475de7ac433caaf1847bea3ee857", - "IPY_MODEL_cc625e16f1c64d55a0d24ea0984f4d81", - "IPY_MODEL_5ea60f460a0e482182651d158dcb90f1" - ], - "layout": "IPY_MODEL_9cdf78cc7bd642e0b9d7982209392e22", - "tabbable": null, - "tooltip": null - } - }, - "0ddc57e0e4f04cbb9469b145769e8c2d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ea5e890d80d74f688eb8f80994f47716", - "placeholder": "​", - "style": "IPY_MODEL_3a6c6ab14c9948da847a706bc8b1d7cb", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "0e483bb542e74106a15fecceb78d8e19": { + "11448f49a2b14f7fad4a569ab23b2225": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6521,11 +7004,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "0eb06dd7112d444185d8378055502557": { + "1149599e5af94bd5811ba75eb36bec30": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -6540,15 +7023,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f8c19883440b464ea6907f88ecc20cb6", + "layout": "IPY_MODEL_cbd01f9e92e04f2fa3a0add1d4474ff9", "placeholder": "​", - "style": "IPY_MODEL_7e4e24585c9349c498bbd58bbdcc7254", + "style": "IPY_MODEL_fcf1eaa6c2e546b4a57fa17a69a60847", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" + "value": " 36/39 [00:00<00:00, 351.59it/s]" } }, - "0ec6c1a9fa2a4df48758b1978a5a2fd4": { + "1151fb176277438b91d2e5b44a2ac6ba": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -6563,68 +7046,70 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_6866a64e6a494644ae47e04fbe9567af", + "layout": "IPY_MODEL_2e602e5c4b1f4d32aa4dfce94be855f8", "placeholder": "​", - "style": "IPY_MODEL_0b20702be4c64ecd98b5e0d942983f28", + "style": "IPY_MODEL_c43f7932862a44eabb362bb93a935920", "tabbable": null, "tooltip": null, - "value": " 590/599 [00:01<00:00, 363.42it/s]" + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "0eff6eb6b0464bb99d15ed98f3c6528a": { - "model_module": "@jupyter-widgets/base", + "119cd69811a54adb8eeb481810efce1e": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f4dc3d9672c44f58bd984593ad00e3fc", + "placeholder": "​", + "style": "IPY_MODEL_75a22ce6730e4173bd312b9fb01aeff5", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 356.60it/s]" + } + }, + "11f5024b723e44f3b8adceb04984fae2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1202fd5ef10741d4930d50263089b513": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "0f5169afe8414d4a8f7c9c1aac77f5dd": { + "120dcd4a339f4a129d800208a181a8c1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6677,33 +7162,31 @@ "width": null } }, - "0f52b0bb14a2422f8255a59614352d54": { + "121d5315dfbd4cb98ca39735e43db5eb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1bf227c4b0f642bab9bc53c6b7c7746a", - "max": 89.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_0ab0066603cf4d5995c04bf52784df9b", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8c00761acac24a84ac935fbb4403bb1e", + "IPY_MODEL_ca46d5b4b9f54df79bcb2845bed3aca8", + "IPY_MODEL_3f15d96b41f544c483655ee1e4a3220c" + ], + "layout": "IPY_MODEL_39fe1afbc84a42879db56c483fe4d8a1", "tabbable": null, - "tooltip": null, - "value": 89.0 + "tooltip": null } }, - "0f7a69eb5e3a4dc39b672b48028fa0dc": { + "1247e21db9ee46fe8068f9480678cf77": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -6719,61 +7202,63 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0c358a0b1a04406b8c14c18ae63b7091", - "max": 9.0, + "layout": "IPY_MODEL_d3898e3187bf4657b9e4fd9afa7ccc5a", + "max": 199.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_b8decf0a9fb24d29aa2988e1f1347b5f", + "style": "IPY_MODEL_f4857f5d0e7a4fbfb835cce2051fdd90", "tabbable": null, "tooltip": null, - "value": 9.0 + "value": 199.0 } }, - "0fd9e4cf02f640b28c1218a6c408a1eb": { + "1284815ffa324bd9b5876b59a86c67f4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0d5640937572475e883381477c91ee26", - "max": 399.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_318876949a134d929ae4b8120885c81c", + "layout": "IPY_MODEL_078d63a64ec741818647072cca339641", + "placeholder": "​", + "style": "IPY_MODEL_2d0079086968463384aa65ecaa9ca32d", "tabbable": null, "tooltip": null, - "value": 399.0 + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "0fe3cac99b2b4e26a5ae84ed7da87675": { + "12a8f7431a7b4a1884f2f8afce587b78": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_601a678eabc2447a810126d2ff6af171", + "placeholder": "​", + "style": "IPY_MODEL_a953a66662c24f4aab5308e30a2e8dcc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" } }, - "0ff2fe8894674c18a3cb96ccb71fdf21": { + "12ae94c01a8d4871b23d5b6cba01d4e6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -6791,7 +7276,7 @@ "text_color": null } }, - "102f1848b58d41f892867c43637f8b4e": { + "12f1a26e3cd74367809e13eb5c659826": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6840,11 +7325,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "108807822cd546bf8582c7b3ffaa5591": { + "130eecf034c249e6a7fd2db05201896b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -6897,7 +7382,7 @@ "width": null } }, - "1098bcfa42894381a07c5883849c651c": { + "13841302755946aa9b5b624933344cae": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -6912,33 +7397,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_4acc29a2907645d7a33c08f06a804407", + "layout": "IPY_MODEL_9b23c6d7cc324d56a100a882f6266c82", "placeholder": "​", - "style": "IPY_MODEL_e231ca64eb4a4161bd34c8ec0ce9cf95", + "style": "IPY_MODEL_aa0eaa941c64493e84fa94ad7ce9aaf1", "tabbable": null, "tooltip": null, - "value": " 778/799 [00:02<00:00, 362.62it/s]" + "value": " 35/49 [00:00<00:00, 347.53it/s]" } }, - "10d96c31ac9040508c5e8a8efdf66596": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "10e7fae882104853a4eb4c34f69caed3": { + "13a0882ac5144028a742e6525c0d687e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -6954,61 +7421,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_275651dc7c7f4b0a938d1f4bd41ecf88", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_6bb48ac44e154515865180e401f675f3", - "tabbable": null, - "tooltip": null, - "value": 499.0 - } - }, - "10f63dcb334a4b37ae3e23201fdad024": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "114b76517f2a4cb4aef8905cc5a7c01c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b8c4862861714cb1bb160e7e94a61bc0", - "max": 199.0, + "layout": "IPY_MODEL_797d8fb72ab043e4a8939caa006de9e2", + "max": 899.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_64e89c05702c45f3ac0558317f9f55d5", + "style": "IPY_MODEL_47192803c7964534a1f1018460fbd86a", "tabbable": null, "tooltip": null, - "value": 199.0 + "value": 899.0 } }, - "1188553b527c416585862b84380cf028": { + "13bd90422b144d9bb98ecbb8629e43eb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7057,77 +7480,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "1190eeb17c3f46cbbf57fa9f36f7eca4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d52f7fe0ac544f58b726245383cea7fb", - "max": 199.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_adf76844a8d94c318d7b11f124e05ca9", - "tabbable": null, - "tooltip": null, - "value": 199.0 - } - }, - "11a731d616f640199f64e0145367c5ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5a378788140448aa8817ca9f5373d77c", - "IPY_MODEL_6a2ef554ab7548399ae616331f89d96c", - "IPY_MODEL_7fa4aebf91ec47cc946851ec20bb3700" - ], - "layout": "IPY_MODEL_bdb137f7a4a846c2b65249870ef077a1", - "tabbable": null, - "tooltip": null - } - }, - "11b70c1674db47d8bae8cb991942250b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "11fd9acc6eec4a58b00464a6a6748efa": { + "13c1e395326b4b698d4f4b465da7c537": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7176,37 +7533,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "120ef5fdd51e4140bb835b9f80ae8b23": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fac12ab2299f4eb49e2f2ad4ab157ae7", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_2e400fcf8095414483146e907b8025f7", - "tabbable": null, - "tooltip": null, - "value": 49.0 - } - }, - "1210f02976414c3789c0b00cbe9ff17d": { + "13e40c06735540a48095222abd7a3f8e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -7224,7 +7555,7 @@ "text_color": null } }, - "12492cb92bbf4157a0bdff36097e517e": { + "13f2f6e445544699b81eefc61eadc7b9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7273,45 +7604,88 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "12a1fd63340146cfaf0b672ecdbde2a2": { - "model_module": "@jupyter-widgets/controls", + "1413473634414eb9b9fded83b8e3f594": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "12a69feb639a449da46fcb07f90a585c": { + "14143480bc66483c9a574f4f2985b558": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1bbdf8435d114a389e8795dd05e5a681", + "IPY_MODEL_48fa604014a34a80a66f1f961d5956e8", + "IPY_MODEL_38ca9c8f2c3c4b4e97985bdaaa98446c" + ], + "layout": "IPY_MODEL_583ae5fa865e44e58095f6d1e0653cda", + "tabbable": null, + "tooltip": null } }, - "12a6aba1c13649ce83260edd991ec1cc": { + "1465ca55900843ceb59658b2b6f733a6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7360,11 +7734,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "12fe1abb25ea47dd9478f195b718974d": { + "146dde9d95b847e68de4240f3d95b4f2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -7382,7 +7756,7 @@ "text_color": null } }, - "12fe941e2aff47c6af6415035cbe59f7": { + "14b540bbd78845488fdca7e097b222b5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -7397,15 +7771,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_fd7f07c8304e4edc81106a886df8d71c", + "layout": "IPY_MODEL_7607e3b62c5e46fb961ae68e2cc7996c", "placeholder": "​", - "style": "IPY_MODEL_c883da9f1be14cc7b0994683eb3b6426", + "style": "IPY_MODEL_62d9f795efd74b41a79a9ea08c8d6127", "tabbable": null, "tooltip": null, - "value": " 592/599 [00:01<00:00, 362.75it/s]" + "value": " 589/599 [00:01<00:00, 360.32it/s]" } }, - "132a0fb522764f228fc5e2353294c6e4": { + "14cff2d7cb764a50bdf85f175e99979f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7458,7 +7832,7 @@ "width": null } }, - "1349031413004abd8f5755f9de81d47c": { + "14d42043c88d4a739d89132f9e39200e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7511,71 +7885,137 @@ "width": null } }, - "13f0f814d19d4c7eb8c2a28a50175477": { - "model_module": "@jupyter-widgets/controls", + "14d7440977dd4a0a8f665aa4c814c013": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5e1de8a0d9a44b9a9e4289d02fd4b22c", - "placeholder": "​", - "style": "IPY_MODEL_f0c8be8468434012b19d9f4969a16cad", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  96%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "1467cab00aa44370904975393b23f428": { - "model_module": "@jupyter-widgets/controls", + "152447a4782f46e8be1641ffe1780f49": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "148576e0fb2141a0808464ed94b127fd": { + "1524e9bdcbc74c67a7d05275006c5905": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b0683478a18b4a92a1e2c29f78fa8ef4", - "placeholder": "​", - "style": "IPY_MODEL_166e772557624d1bad5b3f093b4f991f", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b06bf1c41d6b425e9a6c284a9e470709", + "IPY_MODEL_2858402c291b4798b91377159ad05e62", + "IPY_MODEL_586d1116b5504762aae83152ed41c17d" + ], + "layout": "IPY_MODEL_232a5631630040eb9f978f62f07181cb", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.: 100%" + "tooltip": null } }, - "1498e2383e4b4f8d862f6580681818e8": { + "1526d902ee03455a9c0474791ac1f234": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -7590,56 +8030,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7bb460b12a98451bb3dbb3b6d28548ee", + "layout": "IPY_MODEL_6fd53aa9c116481289bbac5e00168f12", "placeholder": "​", - "style": "IPY_MODEL_8c71d8800d2440a78faae5237b85fda1", + "style": "IPY_MODEL_58e56b80b55a47dfa5df724a1b285c99", "tabbable": null, "tooltip": null, - "value": " 36/49 [00:00<00:00, 357.70it/s]" - } - }, - "149e8cd40de74f6d923525b2e157aac1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 694/699 [00:01<00:00, 359.83it/s]" } }, - "14c4c1d89dbe4de68035c60d5834acff": { + "15345c59a009437c88d924df885b75bf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a7a2d91e2baa48c3a34cbfa0e37672f6", - "placeholder": "​", - "style": "IPY_MODEL_d784ada454e9411dab47048443652156", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4a3426a7691b4e89ad7d104a9614e345", + "IPY_MODEL_68578e172c194160a613d16c6a6b5eaf", + "IPY_MODEL_fdf507c4776e4a4c95efa21a8b0d0eeb" + ], + "layout": "IPY_MODEL_e11011e3cbcd44cb98785d093cfc181a", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.: 100%" + "tooltip": null } }, - "14e7ebfb9a4f49998a14dc5abaaa5802": { + "1546f73e54af4e55a1d94bd8dfeb9976": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7692,7 +8115,7 @@ "width": null } }, - "15469e8d34ba4a6f80813b8992edbd61": { + "1557d81245854706ae3e7d470f0d33d1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -7707,47 +8130,74 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_48ec6902fd1643c6a101327124719189", + "layout": "IPY_MODEL_76c042875c5b4193a77e8e56bb65e422", "placeholder": "​", - "style": "IPY_MODEL_6d93a53d604049e08e5720f826739d68", + "style": "IPY_MODEL_26d069772291427cba877d124b98e4bb", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  73%" + "value": " 73/99 [00:00<00:00, 362.58it/s]" } }, - "15562d5515c54685a0418ac312a70993": { + "15cfc79fc9d94459bdd5e1ce0c72415e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "157298b29fda4f85b5d13b1be48369b9": { + "15d20b7f73704e788ca23d835b6e4d8f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7e56697f340e4fa4bd204f3e7b3f8ff2", + "placeholder": "​", + "style": "IPY_MODEL_7b78816f860644e8b4460f40366e8b8d", + "tabbable": null, + "tooltip": null, + "value": " 699/699 [00:01<00:00, 359.25it/s]" + } + }, + "15f3688de22c4a81b5e4da26b0174867": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "15bacaaa83cc4d4d8178c97f3132e31d": { + "16023c7981a4428e97185e80eb5137a6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -7762,56 +8212,73 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_21d4798508e247b2b35fb6cf9cb26e84", + "layout": "IPY_MODEL_3c5c0356f3554558ba8674e036be7ea6", "placeholder": "​", - "style": "IPY_MODEL_5ad8c3961cae45b79690253e0124bae9", + "style": "IPY_MODEL_92c59c6ccfbe445392b1c5134017e1f7", "tabbable": null, "tooltip": null, - "value": " 665/699 [00:01<00:00, 359.39it/s]" + "value": "Converting outputs to AnnotationStore.:  92%" } }, - "15c9cafd7e2e43548f1d26762b9e26f4": { + "16096e81cf354cf58b0cd9e80a944d70": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_1b200bebec8a43fa8f2a8fb9be9b64d6", - "placeholder": "​", - "style": "IPY_MODEL_d55dd11d79a54468980f37f40d4d37c1", + "layout": "IPY_MODEL_cba998b96e4f48468e6eea4fcae8c1ad", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a5c0f436502a48e9b890fbb59edd5a27", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" + "value": 499.0 } }, - "166e772557624d1bad5b3f093b4f991f": { + "1617bbb5fdc14bd1ab4eaaeb4484e623": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" + } + }, + "166610b9a0504e9bbd32e9a1554c15da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "16ccfa99b84c4b9abd8ca4cbbedfa94b": { + "169b4846cd464296a25a2352c438bfa1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7864,33 +8331,7 @@ "width": null } }, - "16d282bd9e0642ebb9e2731ca6c78aa1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_7784ced197a241ce8f72d0b75833f4d6", - "max": 399.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_191050bf2ded413a901361c405f2bacf", - "tabbable": null, - "tooltip": null, - "value": 399.0 - } - }, - "16d5f1a63c72466f99b07550fa43ccda": { + "16b8d3a44e474e1b8757f409b2a31546": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -7939,11 +8380,27 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "17053bb3933543e69322a36217dd2d99": { + "1730ffb71cfa42f0a45291929d0e52f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "174dffa815ff4073a25e33329bc66d36": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -7958,68 +8415,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_14e7ebfb9a4f49998a14dc5abaaa5802", + "layout": "IPY_MODEL_8f4e91bbf0bb4777ab17b2e196806154", "placeholder": "​", - "style": "IPY_MODEL_149e8cd40de74f6d923525b2e157aac1", + "style": "IPY_MODEL_7fb78a276ec649c3ab4fb1157baa8da0", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" + "value": " 272/299 [00:00<00:00, 356.44it/s]" } }, - "17301b11d79b48ff90855f239fcd32cd": { - "model_module": "@jupyter-widgets/base", + "1755084894eb4a85aff831213eda8f12": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "1749fb2f460f4b1d926e6a554d8645d3": { + "17b7aae4d6944625be91605250dc7176": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -8034,15 +8456,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_48fc3741271344b695c79656379a6962", + "layout": "IPY_MODEL_c20c394b7972432099e1ac5f2c67b11a", "placeholder": "​", - "style": "IPY_MODEL_78c944b5ea5c4cdeb515d72c4eee6022", + "style": "IPY_MODEL_ad9d483153824272b416be214c50d020", "tabbable": null, "tooltip": null, - "value": " 991/999 [00:02<00:00, 355.71it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "18179e83577c4292a4b0c6264d39ebe0": { + "17c0e221ace64612a2cdaf899887c83d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -8057,33 +8479,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_aa449fc079084c5c855152f32565c1c3", + "layout": "IPY_MODEL_39997fa549ce462cbf90e4790babef6b", "placeholder": "​", - "style": "IPY_MODEL_a241f36ed23240d698bc228bebf55681", + "style": "IPY_MODEL_30732c8f35de4e359349cbed4fe2c042", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" - } - }, - "1817cfe1c4d045f38e2e022bf07a9b33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 481/499 [00:01<00:00, 365.94it/s]" } }, - "183774794cb14f0e83961426f95f60be": { + "17d1b2af161546078819bbf8dba745ed": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8132,168 +8536,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "187ea56dade04dcf9af1d225eee8ac22": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "18f9076b3e5c4efa9772a28815505070": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a0201e82ba4c49d08d45d4dc2a347490", - "IPY_MODEL_9f386df69e474796bb2042258c34baca", - "IPY_MODEL_52ca007a9acd4e478ae895caf88e50ef" - ], - "layout": "IPY_MODEL_2d3b7171c63f4f31aa5dbfd09655dfbe", - "tabbable": null, - "tooltip": null - } - }, - "190e7fa99dad4ca1b3656e8ca37da0db": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "191050bf2ded413a901361c405f2bacf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "194308c29a03407fb4ce79fee27689aa": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "194cd83a23854561931c7f0c17fe6dba": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ede85cad6ca14078b9c0f3f17c56b72b", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_493405a5fdc64ee7a63e698014ade54a", - "tabbable": null, - "tooltip": null, - "value": 99.0 - } - }, - "19892871612e45f6ac1c74d736c4cd2a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_19cd0e26132149cebe67f05f53160bf0", - "placeholder": "​", - "style": "IPY_MODEL_bfa9cf76b606481e8c8e2c2e59cde948", - "tabbable": null, - "tooltip": null, - "value": " 73/99 [00:00<00:00, 362.15it/s]" - } - }, - "19a544bf339e4591b7dac54f64ee27a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "19cd0e26132149cebe67f05f53160bf0": { + "182311da489b4aeab46ef8374b1972cd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8346,7 +8593,7 @@ "width": null } }, - "19fdb976dfaf42e8ac15f8a64ab307fb": { + "183eb543201c45c3990047737f88b3b3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -8361,39 +8608,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f0dfe5c6ff1147f98d8a9dd72055bf62", + "layout": "IPY_MODEL_a6f796ff46704ebb9ff313c51baa4d61", "placeholder": "​", - "style": "IPY_MODEL_3afa6238e67243a99483f24042547e9b", + "style": "IPY_MODEL_a60d6a4d11ce4e638dbda3cb0668d5f7", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" - } - }, - "1a0dc3042dc7417b8ca7c20f1483b07a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d6830f03091b4122bf8a35adb6ef3b8e", - "IPY_MODEL_114b76517f2a4cb4aef8905cc5a7c01c", - "IPY_MODEL_d90671b9538c4f328aa0c02f47852a76" - ], - "layout": "IPY_MODEL_c61c49647d074eafbd5c1537449a6300", - "tabbable": null, - "tooltip": null + "value": " 294/299 [00:00<00:00, 362.74it/s]" } }, - "1a714d8e6df84f2b8bf9ee0425255741": { + "1863824d3efd4c0499f8f9d76002f1fa": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8446,7 +8669,7 @@ "width": null } }, - "1a8ca8069f06429e901b97416032595b": { + "188027fdf4ed4ef09dad099b06c01ae6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8499,7 +8722,7 @@ "width": null } }, - "1af75f6281d645f2a31d3370ba5191f0": { + "189893f87cfe49ff801a805a0ae06f07": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8552,7 +8775,102 @@ "width": null } }, - "1af8a41f5c224b1e84dc8f3622533e49": { + "19106aef732d420bad5cb5905590fd70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1988658a4be743acae0c7010c4ccb6b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "19956e1d85644868acd194f5b2b35523": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3476d657b64243438e5c3e4c93524896", + "IPY_MODEL_4f06e14bc60d4262b4cd806c6a30ef5c", + "IPY_MODEL_71cecd7b751d43969aca71d9db9b5767" + ], + "layout": "IPY_MODEL_4fa0161d047048f7b95ed7972a2892af", + "tabbable": null, + "tooltip": null + } + }, + "19e460311904475d8fe577824b5c9f6b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -8568,41 +8886,97 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7ff2061a53d64858a4966097763166cc", - "max": 79.0, + "layout": "IPY_MODEL_3af546af79cc471b890ac3d935300b94", + "max": 39.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_a2e89e916dd04db9bfd98eee00a49147", + "style": "IPY_MODEL_859646c302f64c5cb7fb6d9479b0f0e3", "tabbable": null, "tooltip": null, - "value": 79.0 + "value": 39.0 } }, - "1b157ac0610f4547bd00b2c6af8c929b": { + "1a42b6e31ef940d6af68a8240c3ecadc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1a4e03a2097f45d49dc3cfacffdcdcc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1a9864ef79c246aab32ef7d3d2fe38ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_7e68d485ea5947429b58a31ce3fc975b", - "IPY_MODEL_4aadf2868d614294b42a068cbc3fb588", - "IPY_MODEL_ead10f9e718748628b5767cb4fa7f2f0" - ], - "layout": "IPY_MODEL_4dd9dc50534c410cb648a6a74fd3a74b", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a862b46ccd640bf8256c253221cfda2", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e4401709c0c347a3881f5199c38186a9", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 799.0 + } + }, + "1abd526f7a964f82b5169926d97b7128": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "1b200bebec8a43fa8f2a8fb9be9b64d6": { + "1ad4976a6a3545328728e43198f3c4d4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8655,7 +9029,7 @@ "width": null } }, - "1b359157d85a4f4b8e7b457e72ef4b20": { + "1b03481b32e143f6b7020925f5c4ff8f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8708,33 +9082,7 @@ "width": null } }, - "1b3ce017807544c1b918460d658f8161": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6735bb8ce55b4d74a04e686baa7c3894", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e6b5834bbff443c1868868bd4f2da9c3", - "tabbable": null, - "tooltip": null, - "value": 799.0 - } - }, - "1bed2502aa8c4773b2b33950356f8124": { + "1b15cd7aafa8471d922c367abaad9d55": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8787,7 +9135,23 @@ "width": null } }, - "1bf227c4b0f642bab9bc53c6b7c7746a": { + "1b2a4aeb9f9a427a800dbdcfde9d35f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1b4ec66b20774352bdff7b2005092546": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8840,7 +9204,7 @@ "width": null } }, - "1c115f9d563f46c1ad7126da2121989e": { + "1b532744185242edb76ed6f27d13a381": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -8858,7 +9222,7 @@ "text_color": null } }, - "1c1386ede9054a138b858dc1545ac542": { + "1b8d05386e7942a9beec9e6f906f538d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8911,7 +9275,109 @@ "width": null } }, - "1c33f01e4a684804bb4510536b3192cd": { + "1b92b86db8634e28ac634759ce47d41f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8ff767e6a6d4b9cb1e2117558a1c911", + "IPY_MODEL_c28aac1883074095bcd1a4116cf4497e", + "IPY_MODEL_81da6dc3eb504ee29431dced068f667f" + ], + "layout": "IPY_MODEL_d0b41e8c5b6a4f23b6c104c307736114", + "tabbable": null, + "tooltip": null + } + }, + "1babe0b8e7e34e458bb5ab7df6d0d96f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1bac9679c59f4c75b75f4a200f495d0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b77b87c613dd4902b32d29daa1d1bdde", + "placeholder": "​", + "style": "IPY_MODEL_2583e07b174248cda40e6597533468cf", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 359.61it/s]" + } + }, + "1bbdf8435d114a389e8795dd05e5a681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8aa5c35d34274ec887dc7cec48e11e23", + "placeholder": "​", + "style": "IPY_MODEL_15cfc79fc9d94459bdd5e1ce0c72415e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  73%" + } + }, + "1bc3b9a7b7c54a349760b5fecf20019c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1bd4c0a21e4b4f1aab5c09636e30c61a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -8960,45 +9426,52 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "1c58af823dc347839514e268e13910ee": { + "1c05050d1bc64b3a96c8e0270d11911c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bdade6cbc64c40968082e0174e5efa1c", + "placeholder": "​", + "style": "IPY_MODEL_8aedc79dce4e45da9ce07692a4a5cec8", + "tabbable": null, + "tooltip": null, + "value": " 663/699 [00:01<00:00, 314.26it/s]" } }, - "1c91299ac2294eccaf1a907f5b737b55": { + "1c12006a3dc14f73b4cc0284d4e1a902": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "1cf274d7bb2f4275b01d4ef77e61d5cd": { + "1c89e4f87a5b4c1f8bf5d5e6f2dbd31a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9047,11 +9520,61 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "1d0be30994da4e6798e43238564de104": { + "1c9cd3297f6e48dfb0dce6261805b40d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8f243a6103b46e3b7a8bd38428abc7d", + "IPY_MODEL_bcdd6c3d31de4273ae026df54e0c5291", + "IPY_MODEL_b7542732ee5545e09341723cdbeda907" + ], + "layout": "IPY_MODEL_db6e25f9010d4810ae6fd7e7e919c5eb", + "tabbable": null, + "tooltip": null + } + }, + "1c9d3fe672cd44f2b68eb053d2f69ace": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4a23ccd933d34b8ba087596923059706", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_69f4350a7c844c6a82b533745ee31e8a", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "1ce013f55b0d45d78b3293578964e2de": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9100,35 +9623,53 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "1d5faaed9b6c423e825a6a573133ae96": { + "1d3d8307b76c40da956fb3eb6d0b20c3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1db0bd5d1b1f464ab79e0c100926b1bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f0208ba48bac41138021991cc6fab964", - "IPY_MODEL_6977c8e870d6452fb31d45a02e09d113", - "IPY_MODEL_22db397a2f524b3e9a80885ea5887223" - ], - "layout": "IPY_MODEL_b6234c14756549c19227699e587fa72d", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_83bf380dc89945bdb86fd7e917d3f7c5", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3edb1763c62046b581289258d59fc1f4", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 19.0 } }, - "1d7d48573d2544f898b30176610f737f": { + "1db4a1ec464b474882ea4462a65a0207": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9181,7 +9722,111 @@ "width": null } }, - "1d8a9819f75143a792325a6a1e24c888": { + "1e37aafd22f6451b886162c9c47f6df1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_84a197ce9f1448f8a167692036264ff0", + "IPY_MODEL_cc84ab39a0134034830163b78cf9dff0", + "IPY_MODEL_5023d09e48bd4a68aca352e9900ccfcc" + ], + "layout": "IPY_MODEL_c616b7e586454f82b9b2be849f4e26dd", + "tabbable": null, + "tooltip": null + } + }, + "1e765df6b20b49f3a8c15b4f31214cb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1f7783ae7e1c432a8e7fa5b48fccfc20", + "placeholder": "​", + "style": "IPY_MODEL_afcb4005b3784a9e8adfeae0c6685e8d", + "tabbable": null, + "tooltip": null, + "value": " 884/899 [00:02<00:00, 359.85it/s]" + } + }, + "1e8a516b8ab148e9af3de02174149338": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b7fb937234034362b0c0a03c1f3a3bd1", + "placeholder": "​", + "style": "IPY_MODEL_db0ef9660b694b2aab5c9bcb64831229", + "tabbable": null, + "tooltip": null, + "value": " 768/799 [00:02<00:00, 357.98it/s]" + } + }, + "1eae0ebf45054ef199fc5305f17f07a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "1eb25e3cd76747948288dbd807bf831e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1f293337097945b8b6d9af42553f4171": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9199,7 +9844,33 @@ "text_color": null } }, - "1dc5f7a42c654151b547c0c19fb8e969": { + "1f75704140cc422bb31491822c43c016": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_09ee7ad2811c4a4e9cb196d391cb0748", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_af653c02ca594f969765d485cc49e0c8", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "1f7783ae7e1c432a8e7fa5b48fccfc20": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9252,7 +9923,7 @@ "width": null } }, - "1dfd6ca45c2648d4a76b5550135d6d12": { + "1f94c34da1234a3796318665b1a050ed": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -9267,15 +9938,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_d0d6bde4d189485294b8de5496d5badb", + "layout": "IPY_MODEL_f2ad6c21a37541efbd32362e2ac7397a", "placeholder": "​", - "style": "IPY_MODEL_7ee8a152f1f64b188e96971d435a98b3", + "style": "IPY_MODEL_4c39db267de8446ba596c8f802013a4c", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" + "value": " 295/299 [00:00<00:00, 361.65it/s]" } }, - "1e1926b7480247a28fd62e30ee03d627": { + "1fbf5a76528d4ab5b928e74966a5da23": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9324,89 +9995,87 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "1e42e38b82d640d0b9bcaa8704520e26": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "1e55dde614fe458d843e223be3c29836": { - "model_module": "@jupyter-widgets/controls", + "203279656d204c4d8ba4fd094ac4b3f4": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "1e9dc8e16b7442e8b4b6cbd2ef6bfd63": { + "204a680037754d4aa072f9cce0bc132a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_4604ef25e8484ff194b66b76c120ce9e", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_4864c39e3a4847a6a2188ded9f10cbf1", + "layout": "IPY_MODEL_9f9c5e57870b401995bea4fff59d0188", + "placeholder": "​", + "style": "IPY_MODEL_2ea75374289e4366bc7bff5292d23841", "tabbable": null, "tooltip": null, - "value": 899.0 - } - }, - "1ebe8286cec04816be72266652031bea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": "Converting outputs to AnnotationStore.:  71%" } }, - "1eef03ceabf1453ca62cc83a0cc21bd5": { + "20c91c903fe347b2a9ca629d5ca99183": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9424,7 +10093,7 @@ "text_color": null } }, - "1f0ecc10f2924d7ca0e7f1b104b9ed8f": { + "20d78db71ee24fa79cd681ddc67f28c3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9477,7 +10146,33 @@ "width": null } }, - "1f2c2c11ebe2411582678f05e8b84732": { + "20f126d0e20f4d94b8112e0b5e42fba8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_af62ea5119c54f51920c5598dfa83ebd", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1eb25e3cd76747948288dbd807bf831e", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "2165df5337e048db8b0324b7733fa418": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9530,7 +10225,7 @@ "width": null } }, - "1f3903e21d95428c97d968f475397059": { + "21e65a968512456b825ba37edbb11d35": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9583,72 +10278,60 @@ "width": null } }, - "1f5389db68f140c5973775f895865a38": { - "model_module": "@jupyter-widgets/controls", + "226a3cbecb0542a3b5d7d303b519b29b": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "1f53a34375ef477184c006926f62ac15": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5365c82a72284806b762b8b39f871c43", - "IPY_MODEL_43b0d4154a0f427199b58b18edc1e713", - "IPY_MODEL_c175f1bc85e342d08c1dd6191c573ad0" - ], - "layout": "IPY_MODEL_c159c6407cff49d4b01c7854215df991", - "tabbable": null, - "tooltip": null - } - }, - "1f5b3ccaf27a481d8288195af1ec372f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c6ca16b56fb84b379b715bfe58d42734", - "placeholder": "​", - "style": "IPY_MODEL_4642f5293b54495da8257c656cffc423", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "1f6a6f57060e425da6a3efdc19c423b2": { + "231757bf988b424d9cbfe5d97da99630": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9666,54 +10349,86 @@ "text_color": null } }, - "1f8858dbcbf54a4daea0d698396e3d0e": { - "model_module": "@jupyter-widgets/controls", + "232a5631630040eb9f978f62f07181cb": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8d3a2ef735174a10bee2b092d744275e", - "IPY_MODEL_0a320e2aa9eb4d89afaf9573cfcc5216", - "IPY_MODEL_f7829ae2c54e434f9a22005fc3dae290" - ], - "layout": "IPY_MODEL_69af71543bad4eca9e1fc061c2029a09", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "1f92f0e2d4ca49c58361bab50d093a43": { + "233985b5ee4d4e259db25ea8b2965a79": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b6f325f9cff2428aa16134558ef6514a", - "placeholder": "​", - "style": "IPY_MODEL_e86dd5462de24a36b290ae8edf850afd", + "layout": "IPY_MODEL_5ce7b8aa000543458fa61abbcb29ff3f", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_54cb0d0cf7664fdcbc4fa0bf2525e342", "tabbable": null, "tooltip": null, - "value": " 36/39 [00:00<00:00, 355.33it/s]" + "value": 599.0 } }, - "1fc31890d70149829ae5cf8efb6ff8ac": { + "238223f9e57145a8bf37fb06676869b8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9731,31 +10446,60 @@ "text_color": null } }, - "200cd5fcaec74d1bb60f371831b3926d": { - "model_module": "@jupyter-widgets/controls", + "2387eb6414e042ec94b6d8456cb0661b": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_02c55abb74db4006924148d88a1b3732", - "IPY_MODEL_76570316d23f43809be5856b491f1b0e", - "IPY_MODEL_edc8d6ee12a24ff0953ab319cebabee2" - ], - "layout": "IPY_MODEL_0d50d58d19724a3da81062fd5cb4b2c1", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "2037dae5bfa342adac4d8a9a4a822809": { + "23a2aff8404b494d91b1de589f488d3d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -9771,33 +10515,35 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_1a714d8e6df84f2b8bf9ee0425255741", - "max": 599.0, + "layout": "IPY_MODEL_006018e1b5ee4779be2bf67464c6cba1", + "max": 89.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_41c64b0d1781437499a7bfce03cd5ff9", + "style": "IPY_MODEL_2e0177472a82483bbd5cc06041c2f822", "tabbable": null, "tooltip": null, - "value": 599.0 + "value": 89.0 } }, - "204c00aaed314746bba9ba40a91e8dea": { + "23af2efd63c34545bff4f28479e9ddf9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "205298a761d64130beb1f7385fe7a829": { + "23b47b57d93947fd8c2644f14c39645b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9846,11 +10592,29 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "20addb377519462bb870e2a0d73d2545": { + "23b7b638353145eeb23230747a0e18c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "23bcddffb1a64b519dcf42fde50772fa": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9868,7 +10632,30 @@ "text_color": null } }, - "20c44e454ad94ca4b1ace2b8df13277f": { + "23cb62817a984f6bbecbbb6157871411": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_14cff2d7cb764a50bdf85f175e99979f", + "placeholder": "​", + "style": "IPY_MODEL_df73d65092e140f29f7d202808ae0960", + "tabbable": null, + "tooltip": null, + "value": " 35/59 [00:00<00:00, 349.19it/s]" + } + }, + "23cc90104e2649a0986b899e3974e9bc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -9886,7 +10673,7 @@ "text_color": null } }, - "20e4029fe553444393f77ddd54abcb1d": { + "2440e333c75041c1b28a9ad90238cca4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -9935,34 +10722,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "211a1375c2a64e3f8c8ce44c3d3896a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_22ba541fb40d41928f18d1e0d9d5aa38", - "placeholder": "​", - "style": "IPY_MODEL_83c7ad2db9f441ec97e8e2ea74cbba91", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" - } - }, - "21501175081b4658b0822f3de54dba62": { + "244d80f7d02b4ffabfbe6199ecb7f500": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10015,7 +10779,7 @@ "width": null } }, - "21731e6282aa41e49caa3e7262fc9eac": { + "245183e44125490ea7b8b868149793b9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10064,27 +10828,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "21cc9aa1a7664ff387d33fa6b0387b97": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "21d4798508e247b2b35fb6cf9cb26e84": { + "246331bf94644fb7a7bcffac32433bbb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10133,11 +10881,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "21df0c639e8440a1a27f799e8e2ab808": { + "24d6ba13377444a3bafa63f99d322c2f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -10152,77 +10900,31 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7c90fc17341947eeabc79ee2cc52c82c", + "layout": "IPY_MODEL_f6ccac5711bf49f3983e35d3b4814e87", "placeholder": "​", - "style": "IPY_MODEL_552d3ff7b22248b29a022782a04a8d6d", - "tabbable": null, - "tooltip": null, - "value": " 184/199 [00:00<00:00, 363.47it/s]" - } - }, - "22392eb6be534bfda8c55756fe6f84ba": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f2885b35b3db481fb368939ef8d508ce", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_21cc9aa1a7664ff387d33fa6b0387b97", + "style": "IPY_MODEL_1eae0ebf45054ef199fc5305f17f07a4", "tabbable": null, "tooltip": null, - "value": 299.0 - } - }, - "2259bbe9ce08411a90c41377cc330c48": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 73/99 [00:00<00:00, 359.33it/s]" } }, - "226b394a4e034a7085a9f6305aa0e2dc": { + "25177168c13e4aa69af0438a4072f66d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "22b46da5eaa648dd88272a46a47b45ae": { + "253847aa90ac489a9871939127d1d593": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10271,11 +10973,29 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "22ba541fb40d41928f18d1e0d9d5aa38": { + "2583e07b174248cda40e6597533468cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "2647cebcc2fb41369c60271f6d492e2b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10328,30 +11048,43 @@ "width": null } }, - "22db397a2f524b3e9a80885ea5887223": { + "269418aec0564953b87e2a3737815ff3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5ace9e3cea30467786e4bdb4f124bdb9", - "placeholder": "​", - "style": "IPY_MODEL_60dae5c3458c4f2490dc11353474cb58", - "tabbable": null, - "tooltip": null, - "value": " 890/899 [00:02<00:00, 367.21it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "22e29211dfe1433793ee2567179c47ac": { + "26d069772291427cba877d124b98e4bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "26f5d57c9ab449f19e9c06d29906ef76": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10400,35 +11133,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "22edab40b3914d349aa684b441522e7e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e4496b6b73d04e97ae3c28b8a03e85a3", - "IPY_MODEL_03ecefcfa09d4e8384ff3a8c933522bc", - "IPY_MODEL_f85bf7cfc17d422ebacea7480fee420f" - ], - "layout": "IPY_MODEL_6489a182240c431494fe27e8130d66e0", - "tabbable": null, - "tooltip": null - } - }, - "234835fc04c8441ea0afa11669ca3eee": { + "274d5383ac43426bb2a3ad46a6143774": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10477,52 +11186,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "2350789de04c456dac05fa481491a01c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "23544f3341004d698f38b4deb7bc262f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_22e29211dfe1433793ee2567179c47ac", - "placeholder": "​", - "style": "IPY_MODEL_5349dd59be974d739ca43d2befd9aa1b", - "tabbable": null, - "tooltip": null, - "value": " 492/499 [00:01<00:00, 364.27it/s]" - } - }, - "2384ab9a24d54e6ba660d724d28817ad": { + "275a557e774148eea3ebb9a83d8df3d2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10571,11 +11239,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "23cbdff2e40843549fb4ecbf3eaccf86": { + "27632bd107564e7d9ed4a16a3855b61c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10624,11 +11292,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "23d38259eaad459380bc3c0f4040cec2": { + "276d413b7cb74825a4e97ab60cce062d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fae700a28be54601897911ae558e203c", + "placeholder": "​", + "style": "IPY_MODEL_cb8319dbbdda4d9b87ca200f04c8831c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" + } + }, + "2786fcf242d247699682b01adce9c3d6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10681,51 +11372,84 @@ "width": null } }, - "23d407b0c7f74a0c85f8d771e72b3e4b": { + "278a6ffa1b8c4cf386e19e0bddb382ff": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b7de920b2f34f3e908182afe2e48467", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_4408ec1204eb40538263096ca57b566e", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1284815ffa324bd9b5876b59a86c67f4", + "IPY_MODEL_b2eca7b5574a4b3db78272c2c6b6cc04", + "IPY_MODEL_aa323f9226bb44f991ad2e5c97ce70cf" + ], + "layout": "IPY_MODEL_152447a4782f46e8be1641ffe1780f49", "tabbable": null, - "tooltip": null, - "value": 299.0 + "tooltip": null } }, - "23fdf25c2f62496cb2a46a757859536a": { - "model_module": "@jupyter-widgets/controls", + "27a5f87081fb426db2eabef1c274afad": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "241c4bc13fed4998b5523c3305c8a032": { + "27b727ac94344198b60b6c8f35f71a94": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -10741,49 +11465,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f236ca780b3a4051a5992f7b138766f9", + "layout": "IPY_MODEL_f941248bd1ef4a09a9452d3c876b400f", "max": 399.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_63d481c2220943d4b7153dbdbbd01710", + "style": "IPY_MODEL_1babe0b8e7e34e458bb5ab7df6d0d96f", "tabbable": null, "tooltip": null, "value": 399.0 } }, - "2429619dc67346888ea2f4cc9564a4df": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "242d249d623e4070998cfac6f5a7134b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "242e890a22f547c88a91c5ce4029d7a2": { + "2846bfb4a0a24a8b9693f1e4234d68a7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -10801,7 +11493,7 @@ "text_color": null } }, - "248ae7c615c14b5692b719abb04d9f44": { + "284d8701b3b94d8e80ffedc6b3956dba": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10850,11 +11542,37 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "24951e7781bd4944bff41af1367209fc": { + "2858402c291b4798b91377159ad05e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bee09ea681244bfdb1e17964fd86ce3b", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_7fa232374d634f96b82babb9aa41da4a", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "28890c573bec4fe0b2c62b7144211780": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -10907,33 +11625,46 @@ "width": null } }, - "24beb2defa5a4780ba4dc286afbac5e3": { + "290011cbdf5b497ab3ab81d503689bdf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_fd933da07e674cddb3bcfa7d6eed1d67", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ea671a54605c4fd09b00a497010b515d", + "layout": "IPY_MODEL_6eef21ee72594bdfaadb724457930c01", + "placeholder": "​", + "style": "IPY_MODEL_3bd192336448457b84577abb5a13a391", "tabbable": null, "tooltip": null, - "value": 999.0 + "value": " 73/79 [00:00<00:00, 358.49it/s]" } }, - "250b9961e7384b11b02d9fcfca4002ec": { + "2911b334e7c44fce9a54641247b46423": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2959fc1bb680465ea20c81966066de34": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -10949,88 +11680,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_4af90e24693b48a2b1887129dd8a5444", - "max": 899.0, + "layout": "IPY_MODEL_e91a10aca0704569bb19ef67cec91fa5", + "max": 59.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_4c6c3a4c1b494ba0b5fe71c4c54f4100", + "style": "IPY_MODEL_3a38659984e64a7abf6716e2c89ffc09", "tabbable": null, "tooltip": null, - "value": 899.0 - } - }, - "25239cb5cb2c40b3b9f88c91fa11bfcb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": 59.0 } }, - "255b617c965b4b66a67b74ce249e7643": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "255c3cb7d7114ad2a8162710a4c06ccb": { + "295c626c6e4347e8b91c309531cb9b91": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11083,7 +11743,7 @@ "width": null } }, - "256819f1cb0c41b29b446229cfbb74a4": { + "295c6767a5784dc29346fe8d13a65c5d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11136,7 +11796,7 @@ "width": null } }, - "2582ee3ecb8f40a4a915e20cf76d3034": { + "298efbdb99d44d269ef573678898bc84": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -11151,15 +11811,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_63f988873c6b4f44890eaf9a6878be72", + "layout": "IPY_MODEL_41a366de5d25442993f37793a3ebd386", "placeholder": "​", - "style": "IPY_MODEL_5f431b448ddf4717bf79b3af34395635", + "style": "IPY_MODEL_7072d198ccfc44eca813f458a163c6ec", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  99%" + "value": " 0/19 [00:00<?, ?it/s]" + } + }, + "29e24014d7fe4d3197d1c0a9ff16eb6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_69e8bd2b865545d0b5b015c4d2eb5f01", + "IPY_MODEL_79db4b3171064ff3978cfe64d3d2fa37", + "IPY_MODEL_94d3ef450eb546e1a20802055ca484a4" + ], + "layout": "IPY_MODEL_e1058597caa7456f91b9a0374fbcbb9f", + "tabbable": null, + "tooltip": null } }, - "258500a849bf40ce9144c54163b0f70b": { + "2a2a9e9125f0428b93fbd2b8de7774a3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -11175,25 +11859,33 @@ "description_width": "" } }, - "26adc41a09eb4024b14e199b23ee1268": { + "2a307835b23b41eda95384f01f436666": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7ceb7f50be444f489587261eccc85900", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_edece67fcf5d4de686a9eca080f9db0e", + "tabbable": null, + "tooltip": null, + "value": 999.0 } }, - "26f6decc30544462b6b1487cbab83353": { + "2af39222078242b4b6f1f65b0fd6dd38": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11242,37 +11934,27 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "271d7987b90b4aa89a8d8df30897064c": { + "2bc60aaa3620476ea0f5690bb12dbee5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_da02205a6765423997b76576f7338f55", - "max": 39.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e383b2024372464abe591908ce466a8d", - "tabbable": null, - "tooltip": null, - "value": 39.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "272c6e13d6bf4f6d91e775b05ba90942": { + "2bf53299cd6148dcbfbeec2fe341b2f2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11321,11 +12003,104 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "275651dc7c7f4b0a938d1f4bd41ecf88": { + "2c04fe33220c4c43b72455c79f25c61a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5f626046347e4560bd0b2c7d2b12b80d", + "IPY_MODEL_ff8f54328c1644e3809a1284e38aa37a", + "IPY_MODEL_47fdcd00aca04f539b5744cfbceafde6" + ], + "layout": "IPY_MODEL_c095ede63d58457b832ab2769da77fd3", + "tabbable": null, + "tooltip": null + } + }, + "2c3efed89a724685b68bd2de27ed7c5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_acb325923fac40dab9ad6e4ba696e3bb", + "placeholder": "​", + "style": "IPY_MODEL_7c3d29e225e24d408c436977640994a3", + "tabbable": null, + "tooltip": null, + "value": " 478/499 [00:01<00:00, 362.15it/s]" + } + }, + "2c4042132ebe4f18b90cc76d94ebb5d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b9f591c574624533858c0a2ac3c595bc", + "placeholder": "​", + "style": "IPY_MODEL_fb0537663fb14f6880ada7ecb8c32661", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "2c57f3d785fa486588b9afc05eebbcb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f12fad9e7f9d4bc5b1a5ce563e159fd6", + "placeholder": "​", + "style": "IPY_MODEL_eafc334345514b188ef19bc19745ad65", + "tabbable": null, + "tooltip": null, + "value": " 73/79 [00:00<00:00, 358.31it/s]" + } + }, + "2c9cc2fafd414443a493cc1e79d7fa22": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11378,95 +12153,85 @@ "width": null } }, - "27888a19cb4949a5955db0810887d01c": { + "2cd3ec7ecf5e4e54a8c3b766efd4d32d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c7b23113d4dd49cbac62b15e6b6b4c4d", - "max": 399.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ee94d2d7c18b4cb8810f14c855e1b2b3", - "tabbable": null, - "tooltip": null, - "value": 399.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "283a5ae3c76046ee9011294a32e8d487": { + "2d0079086968463384aa65ecaa9ca32d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "288fb6b917c54da3a47b962f1c563580": { + "2d39479f14544b8c96076af536cce951": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_7ecea0052a7a423db97e345dbf84e1b0", - "placeholder": "​", - "style": "IPY_MODEL_875113f8ea91403f82deffd8f48d689b", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  74%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "28d07f56029c49e59ccf4d2e358dd949": { + "2d4107fde9bb45f8899567b6ce72c654": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fdb22cf92086422f87a8e173bf688af4", - "placeholder": "​", - "style": "IPY_MODEL_90e083fd95754dbca7d6f77d89a8aac9", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f318ac7b52f142da9224ad61eca47a08", + "IPY_MODEL_94bf5dfb8af74d4daa2c9bee5d7c3d5e", + "IPY_MODEL_4fd9a0546547485c9d1da2d4db011130" + ], + "layout": "IPY_MODEL_5e2bad298cf94edebfcee17f9ae175b5", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  61%" + "tooltip": null } }, - "28dde8a12e6f41848497e696498220fb": { + "2d8cc8de11c8466f825698ae268bf35d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -11484,7 +12249,49 @@ "text_color": null } }, - "28feb5aac0de4bb490a80c66d22b8daf": { + "2dbfe8df36f940e6a71e17fa76d83bdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2dc876b11d8a48388110a94a30f05ae9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_55fcb49df3464631beee1d02c538bf09", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_25177168c13e4aa69af0438a4072f66d", + "tabbable": null, + "tooltip": null, + "value": 499.0 + } + }, + "2dd25c677b4a4b7c9e28fb07ac22afa8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11537,30 +12344,39 @@ "width": null } }, - "290c3be5b2ff4f278a639007eb07ecb4": { + "2de6d80caf2743c3869b7f67608fe533": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8154d81442eb4d539c6f9ae3f50d134c", - "placeholder": "​", - "style": "IPY_MODEL_f360e6312e5a4403863bb5ab1ba58459", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2e0177472a82483bbd5cc06041c2f822": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "2927b89096ec44288bc314528c24f65f": { + "2e2b910756ec4e7780d4c7a09d3c699c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11609,11 +12425,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "2943c575311a4d638cfcf9ae49e165af": { + "2e2ea624b9754e9eab65970f6234780b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fd34101632d74ecfa8afefeb68ddd5e0", + "placeholder": "​", + "style": "IPY_MODEL_c428c7b2a924486191a6fdf6df696810", + "tabbable": null, + "tooltip": null, + "value": " 37/49 [00:00<00:00, 360.86it/s]" + } + }, + "2e602e5c4b1f4d32aa4dfce94be855f8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11666,23 +12505,7 @@ "width": null } }, - "296269f997e44a7081d95fa892581460": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "296b41f78d464b6d8a4c161f5cbcb8ce": { + "2e70285b0b414daea22e70b78302017d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11731,29 +12554,34 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "29ed50dabf784806aad2fe583689beaf": { + "2e731324be0b4d16b8b6b4f9ebf21650": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7a64f216006e44bc9f30528179470a56", + "placeholder": "​", + "style": "IPY_MODEL_15f3688de22c4a81b5e4da26b0174867", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" } }, - "29f90c5cc8e747a0ab22a7d7e6f1817b": { + "2e9c800b2f9a45bcbf61734fea27fc71": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -11769,17 +12597,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_85fb74ae8c21489198b8c41dd88ae229", - "max": 39.0, + "layout": "IPY_MODEL_cb0f6075ac614de19e87d0c4d55a5ecb", + "max": 899.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_abc32f9329d04aea9313056d069ae33a", + "style": "IPY_MODEL_3547876e9b2443b1870291380914aa94", "tabbable": null, "tooltip": null, - "value": 39.0 + "value": 899.0 } }, - "2a2b49e661b84e3da9663b9390f47aee": { + "2ea75374289e4366bc7bff5292d23841": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -11797,7 +12625,7 @@ "text_color": null } }, - "2a3a3aa6cd8c4030b0db46dbff2b0422": { + "2eb17b69ff5e47ebae91df68518a54d9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11850,65 +12678,7 @@ "width": null } }, - "2a92c6051e9849b9a9fdb69ea34e1a24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d9f6193af70e4e5ca8a48e246903e57e", - "IPY_MODEL_3f8945f19eb24ecaadcd3b7a33cafd0f", - "IPY_MODEL_5741df7837e041efb9c3f5272a447263" - ], - "layout": "IPY_MODEL_a5919878920d41b9b612514c78460e91", - "tabbable": null, - "tooltip": null - } - }, - "2abd18ce78f4431fb12a9068651c4590": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "2ae5a381bb6546309986b04b77fa66d5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2b1ce2ace64948fe9ebf69eae5e0230f": { + "2ef2712eb11743d79fd85dbb0964bc3d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -11957,11 +12727,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "2b45c72793a7403ea28982b692d23f36": { + "2f2bbd8357da451091dbc30a78476caa": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12014,33 +12784,25 @@ "width": null } }, - "2b56a0ae92af48a285260a8d75e33180": { + "2f9b9ec5691342d0a22d0458ff734240": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_16ccfa99b84c4b9abd8ca4cbbedfa94b", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_1c91299ac2294eccaf1a907f5b737b55", - "tabbable": null, - "tooltip": null, - "value": 499.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "2b5c7bbcce984435b1cf4c7029aec5c8": { + "2fd359be9a0342a4afc668ed1fc7fe14": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12093,25 +12855,7 @@ "width": null } }, - "2b7e2f2529d3499f9b631e8623105d46": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2b89575e8d774ab289d214e70fc2ee7d": { + "2fec5a0c7de7499b96b252c7429cce70": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12129,23 +12873,7 @@ "text_color": null } }, - "2c7bfcf515ec40ecadafcd73332df488": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "2c87e239c66c41b5ada589a29b583e6b": { + "3003cebab11f4fe98273b3abf4e2fec8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12198,60 +12926,25 @@ "width": null } }, - "2ce5391336384dce9727c24bebd9cf25": { - "model_module": "@jupyter-widgets/base", + "301771feabe84c3d911acccbcd74f07f": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "2cfead4a1407452fb847f9fafea1cc18": { + "301b81d03e37420d8a1d12568eceb284": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -12266,68 +12959,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b732443cad9f4984b424f182f682f953", + "layout": "IPY_MODEL_063ac2284c704b9280d8c4dba8410e8f", "placeholder": "​", - "style": "IPY_MODEL_db506087065141bd9360f9d96b38e047", + "style": "IPY_MODEL_4e09c6f855624f92a7b49369ae31bbf8", "tabbable": null, "tooltip": null, - "value": " 96/99 [00:00<00:00, 305.80it/s]" + "value": " 0/9 [00:00<?, ?it/s]" } }, - "2d3b7171c63f4f31aa5dbfd09655dfbe": { - "model_module": "@jupyter-widgets/base", + "303cad02f2c8469e95efd4070437e40e": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HBoxModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c677aa821c394a3da2c9a8d555633c37", + "IPY_MODEL_7291352398564cb89a8fa097aa96e49e", + "IPY_MODEL_ff9c06f0a705471185d1649383026c93" + ], + "layout": "IPY_MODEL_36d775385a074e3881ef559d1a73b8f9", + "tabbable": null, + "tooltip": null } }, - "2db019ca42504212a3233c8e22ba73fc": { + "30732c8f35de4e359349cbed4fe2c042": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12345,7 +13009,7 @@ "text_color": null } }, - "2db07d5df0234a4cb27f2e7124271ada": { + "3073387c75ca4ddea20a8563bdcb897d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12394,71 +13058,57 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "2dd9ff6d11ad475da767edbca22fde12": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "2de0d0d0c2f44cf69f01ede67f25b002": { + "307bd8d7a31549ff8cff744c616079df": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ff2cbdf66e284671a9581f68bbb8a921", - "IPY_MODEL_72040055ac464cc5ae07bbd7b8f42d85", - "IPY_MODEL_d7896b8022424b25b876bfaa8d644595" - ], - "layout": "IPY_MODEL_bf942b0276b340fe97e503e5c27eb4cc", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ebaf078a9cd844d6aae78de6910bb6be", + "placeholder": "​", + "style": "IPY_MODEL_a7c49a2242de43b08eb9b76b6853d5f4", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 478/499 [00:01<00:00, 363.79it/s]" } }, - "2de0edc89e0048bda7a1a1f4ef9914e0": { + "3095c57304ab4f2f9d96c2870893365b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2eb17b69ff5e47ebae91df68518a54d9", + "placeholder": "​", + "style": "IPY_MODEL_71668fd6d677488fbbeea29f7c9a2a0a", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  98%" } }, - "2e14f23461204db0b7c93b459e20c2c4": { + "30ad7c40e4624ac2b5087aafdad39c2b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -12473,138 +13123,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_8bce25e51a4f433faf80447c79476251", - "IPY_MODEL_b7ee1f2389c4437f88556be7c5ca20e2", - "IPY_MODEL_42311ad84af442b3ac790c5ba3599136" + "IPY_MODEL_0e06f27415cb455ab610931fd9497cf7", + "IPY_MODEL_19e460311904475d8fe577824b5c9f6b", + "IPY_MODEL_4a79545a2a81460ca04491a89f125f60" ], - "layout": "IPY_MODEL_9ba4c18dcdfc4ed092d98d9596488a6e", + "layout": "IPY_MODEL_d66f792529a1444199f52bc3c124b78a", "tabbable": null, "tooltip": null } }, - "2e400fcf8095414483146e907b8025f7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "2e6558c07cf94401815a790e9d03dcaf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2e77c5df0a71486c84a989a79338aeaa": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2e92a5fc089c47d6923d68205e464c19": { + "30d0d73e82724d95a9eabfefd74e7913": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12657,49 +13185,66 @@ "width": null } }, - "2ea4afc14a0046d198c3a249246a0246": { + "30e266582f974a3e930f9e56f2395317": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b1f1056fbadf4ef28147dbb1ffd2f01d", - "max": 9.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_4d883c2504904f56a0248e68d05cce92", + "layout": "IPY_MODEL_3fa0aa3d2e9045d49bd56fd7a68fd3ab", + "placeholder": "​", + "style": "IPY_MODEL_a4a2064e1ee043889936721ea0d74506", "tabbable": null, "tooltip": null, - "value": 9.0 + "value": "Converting outputs to AnnotationStore.:  73%" } }, - "2ecfa31322e4498d9bdec04ab535b826": { + "30ea34fec1184bf19aeae46cdffcca29": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3128c3ace7154a1e82478caee8ed4ec1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "2eee24513db1454dab4e04b9a357172e": { + "3159a15269e34291a3134c2c21bb5739": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -12714,16 +13259,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e913215a765d411080f03f4b8e81a3c4", - "IPY_MODEL_271d7987b90b4aa89a8d8df30897064c", - "IPY_MODEL_37afdd026ed0419e996968bc98086562" + "IPY_MODEL_d77ee350aa984be6a497883e1f64a501", + "IPY_MODEL_9231cb74058044aa96c81eb63b651ac2", + "IPY_MODEL_1526d902ee03455a9c0474791ac1f234" ], - "layout": "IPY_MODEL_a2366512a78941d9b2e293d1b6fb9c99", + "layout": "IPY_MODEL_cffaceef4a504348bc269dfe245819e2", "tabbable": null, "tooltip": null } }, - "2f2549fe184843d3a55c2bdf93bdc1b6": { + "317595359d6840338f3cae4eabb6a127": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12741,7 +13286,33 @@ "text_color": null } }, - "2f443fe263424ffba5ee02553a353f13": { + "317fa0351c114464946bd2ad8126dbd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a0c5e377d5f455fbbbae00e4d7ab3a1", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1bc3b9a7b7c54a349760b5fecf20019c", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "31a26de69a16468ea16307c6876edada": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12759,7 +13330,7 @@ "text_color": null } }, - "2f46ec3dd30a44c396902bcac10a18b5": { + "32178b86f0774284b5dbc8f31e479242": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12777,7 +13348,56 @@ "text_color": null } }, - "2f521620627248e7a4763ba2fde8b384": { + "326208c18c2748689eca14d506118164": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_07ce408250e744bd89d3fe9ca3d2da11", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3fd78dde37ea4c8ea9c6b9ab3a428711", + "tabbable": null, + "tooltip": null, + "value": 399.0 + } + }, + "328695d425cb424993c5f98bb01264cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6a112e2eae2e4a049d1c7d5c8363d06e", + "placeholder": "​", + "style": "IPY_MODEL_20c91c903fe347b2a9ca629d5ca99183", + "tabbable": null, + "tooltip": null, + "value": " 72/89 [00:00<00:00, 355.80it/s]" + } + }, + "32a71e4cc23c4214b4936dc058f957c4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12830,7 +13450,25 @@ "width": null } }, - "2f7a26e9f83e4eac93525a1577b6d1cd": { + "32aa36340c2241b590dc3693552d1319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "32c2452decb440bc843401b38110ecce": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -12845,16 +13483,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_3a9b70bb24854e7a91dcd87058764675", - "IPY_MODEL_b5d92701d5044ff58eab8aed0910cf31", - "IPY_MODEL_7d46a86b30ac472e819e62c37d28735e" + "IPY_MODEL_54e999fa6aaa45fe91577de2013491ea", + "IPY_MODEL_462d36d49519496a943435368f0a600e", + "IPY_MODEL_0a21bf172fa84989a24711c9887c8560" ], - "layout": "IPY_MODEL_373fe519cbda46eab97207c5ddade7d6", + "layout": "IPY_MODEL_10a5b7dd74c843199aabd953adc53c8a", "tabbable": null, "tooltip": null } }, - "2ffc7c0b499747e4859a41fc0a38a575": { + "32d1aa79e800431591903cdee0b4c3e9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -12872,7 +13510,31 @@ "text_color": null } }, - "3004d918d6194963b440047a854d88db": { + "331052cac0b042958e63dbc99fab3188": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8ef1c6dcee744ad84c94c48775e95f7", + "IPY_MODEL_00c26a01e7784379a19b061b60bd2c74", + "IPY_MODEL_298efbdb99d44d269ef573678898bc84" + ], + "layout": "IPY_MODEL_866a90a0cf0c4e93a1928109d3ab9cde", + "tabbable": null, + "tooltip": null + } + }, + "33192a22bcef471db8f96fe4b26c47bd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12925,25 +13587,7 @@ "width": null } }, - "3050a1864c2b4706a1df4a5acad077cb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "306a8f365de746fb96d9898459d2d185": { + "332a709915b74f3f834b9bb307d429d7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -12996,60 +13640,31 @@ "width": null } }, - "3185d1df4262486583b2cce2550716ef": { - "model_module": "@jupyter-widgets/base", + "33907522e43748b5a2b6b28dfb6748e1": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HBoxModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_60047e8d7d6c45b4a948caff74f56772", + "IPY_MODEL_93205096546342df899e6bd0dd1ae80d", + "IPY_MODEL_ae758b3b9cae474ea6476f2d3d63c5d1" + ], + "layout": "IPY_MODEL_8dcf181c55b7482f8ee16666dc8b8676", + "tabbable": null, + "tooltip": null } }, - "318876949a134d929ae4b8120885c81c": { + "33943fd46bbb4eb89e232842e54cdb49": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -13065,106 +13680,43 @@ "description_width": "" } }, - "318ca864920f49929982f4de537a718e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "31b52ee3bfe24ec5acdbee1e81fdb110": { + "33aeabc350da4651bec79df8ff64562f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_575d06df913048b8813a93292fc7a88b", - "placeholder": "​", - "style": "IPY_MODEL_bbe3b34d52d84712934297054f606fff", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "31c1eb4f79f4459b8125293e0af13fa8": { + "33e136242f184bf288b3b4914f89832b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8c149e832c2344a6a13d48e6ca6fba0c", - "placeholder": "​", - "style": "IPY_MODEL_9c6f49d105f14d058f4d932bcc35b4f7", - "tabbable": null, - "tooltip": null, - "value": " 73/89 [00:00<00:00, 359.10it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "31ef47419b114e8e9cf1e4b2bb499aed": { + "33e8a76effcf4002ab4aa1eed232c291": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -13179,15 +13731,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f52a08b1ab0e4a889394c121bc328c23", + "layout": "IPY_MODEL_d9fac7fca87c4d339e4b3c5a0cfc89cb", "placeholder": "​", - "style": "IPY_MODEL_3d4b0780d431468593ed74d9030b494c", + "style": "IPY_MODEL_e7969cf6d54747829e4ba25c13bdcb47", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "value": "Converting outputs to QuPath JSON.:  61%" } }, - "32703beeb6c245ebac7648b6f48b6b3a": { + "33fb64d45f4346d3b3cc7ffc662f021b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -13205,59 +13757,7 @@ "text_color": null } }, - "33051702a54a44748f00e635574ac265": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_50b5e466f90d42ab9e7757c25c95660c", - "max": 79.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_fbd8b39aab8b4aa197a53ab2f71c37b7", - "tabbable": null, - "tooltip": null, - "value": 79.0 - } - }, - "3340bd63010b4136a2f321d8fa0c528b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_7c00d2df8ba842e7bd57cc122101387e", - "max": 199.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ca5ece859f934bc9a25c0452368699cb", - "tabbable": null, - "tooltip": null, - "value": 199.0 - } - }, - "338e3a49e59d48fbbe5f390aa05d123d": { + "341d2ca9b411414bbd31cb92e5891109": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -13275,33 +13775,23 @@ "text_color": null } }, - "33ae1b4cc09c4b64a69ea6923a1e5cdb": { + "342cf62186f34af0aff6b7b096df814d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_90afbda5a11b422bbb56317ebe3d3079", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_448dcec6565e4adbb4780924bfa54d7b", - "tabbable": null, - "tooltip": null, - "value": 499.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "33fb7da188e444138750822e841e9b94": { + "3476d657b64243438e5c3e4c93524896": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -13316,15 +13806,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ad759a9a72194a3d82076c6601322a6e", + "layout": "IPY_MODEL_6081336c79e240d0b02143376a50c039", "placeholder": "​", - "style": "IPY_MODEL_3d9c5a4d9bff4bc09e5f36ea24a91544", + "style": "IPY_MODEL_37f3983f50bf47139990c036677b17e4", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  76%" + "value": "Converting outputs to QuPath JSON.:  59%" } }, - "3433e75bb0a540d883d4c418b00b7eb4": { + "34bee3d9d0814334a03cf2e76dd54669": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -13340,30 +13830,47 @@ "description_width": "" } }, - "34481362e7574831b275eec75beea53d": { + "3523e2269a9f4e819e0a8aef0f26671b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_39591337b02f45baa78620129d8e1d34", - "placeholder": "​", - "style": "IPY_MODEL_8bbe0e3bc2bc4d59bd35c50e1ad706f0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cec5af9fa80247e98501b47d2c827981", + "IPY_MODEL_5c8567bb647444c5ad7ac0fe3a82f5a1", + "IPY_MODEL_f277a039789f4baa95d14e8bdb1f3cea" + ], + "layout": "IPY_MODEL_faf3df790e944e92a904c6def6017ca5", "tabbable": null, - "tooltip": null, - "value": " 36/59 [00:00<00:00, 351.90it/s]" + "tooltip": null + } + }, + "3547876e9b2443b1870291380914aa94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "347e13716cac4865a6ff64467313aa11": { + "354921b909f34c399e4630cc798e2fea": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13416,7 +13923,25 @@ "width": null } }, - "34a37b01cd294532a190c763be2a9da8": { + "356ac359c0ac45cfafbe202592794b2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "35adcf7acf6d49dea6a705d97859cf37": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13469,7 +13994,23 @@ "width": null } }, - "35490b4a6f6a4f5e847a86296f50a223": { + "3620d2774665429a9fa8a6b510f7c6c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "363d0b757e094298be6c6a40eb0b4c83": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13518,11 +14059,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "355304b3dc444dd3a780d3a03dd83d43": { + "367bf374a704422b969b4918aa1ce3e5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -13540,7 +14081,56 @@ "text_color": null } }, - "35ff4862dad0431192a71f939e407761": { + "368b0548bd9647f28b2f3d5c7399f865": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1b03481b32e143f6b7020925f5c4ff8f", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e5cf868570664eb9aa2051b4e84ce23f", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "369cd22c94c4439db53d36b8b9887e32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8a5f6b005cb1496b95a103356e3dc285", + "placeholder": "​", + "style": "IPY_MODEL_32178b86f0774284b5dbc8f31e479242", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "36bc4c06ad2a41488b65c86f172fd797": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13593,7 +14183,43 @@ "width": null } }, - "361f5bf265d04118866d71ed7620197e": { + "36d162ea214f42e48ca91c237defbfc6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "36d30ce8ff704452936a6febd795ce2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "36d775385a074e3881ef559d1a73b8f9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13642,34 +14268,29 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "3622146964264166862fb39d34a8603c": { + "36e2820acb6c44f0b3fe0578c6b2f4bf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_591910cf345e447196e7e7b5443cc2f3", - "placeholder": "​", - "style": "IPY_MODEL_f8e5e573da5347f0bc4ab60584d96b11", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  96%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "367fc8903c0647f88f4a2d046b19d517": { + "36e9ce0a1e994176b65a71967728d8aa": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -13687,7 +14308,7 @@ "text_color": null } }, - "3702144afb8a47dfb8434f24c2e2fff3": { + "3737209cc1bc46959ba770bc0052752a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -13703,7 +14324,31 @@ "description_width": "" } }, - "370b92e85a114488afa68e2ed2e2eb67": { + "37978aa28d9f40289314991befcdaf25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_81596e2291ac4d60bffed4acc03b4eec", + "IPY_MODEL_4b34f494fe774c2c88127ff1c8e44031", + "IPY_MODEL_fb1628a7e1d54607a7ba57b21361aeb6" + ], + "layout": "IPY_MODEL_f595a18f4bc0439d9227fa120fb7ec8e", + "tabbable": null, + "tooltip": null + } + }, + "37c799e1455849f391c1dbec1e9b9911": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13752,35 +14397,78 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "371b6730e42945b884be6787e8846e12": { + "37e8311759794f6387f91a98050e7b00": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_fb3a17559779408db0db5cf5aaf39908", - "IPY_MODEL_b4eac108d5154f239da0f9bcf1ac232c", - "IPY_MODEL_a18aac23a7124bcfaeeabff25faa246d" - ], - "layout": "IPY_MODEL_3a7a3093b63340e29f3147b3593e4870", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_579c8cae74bc47479051e3450d2e53ee", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e1785606f8534b599f40b8e0e66e210c", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 999.0 + } + }, + "37f3983f50bf47139990c036677b17e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3856e715193944f693e416f05c24d2c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2c9cc2fafd414443a493cc1e79d7fa22", + "placeholder": "​", + "style": "IPY_MODEL_be4bc91059944c03a353dbbf9fe83aeb", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  59%" } }, - "37386a1082ee44b2a296d3b4ecb95a10": { + "386c2cefc93c4946a14038f8ef5e9365": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13829,11 +14517,50 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "373fe519cbda46eab97207c5ddade7d6": { + "38c23be1adc94a149d3d9492d7969f04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "38ca9c8f2c3c4b4e97985bdaaa98446c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_20d78db71ee24fa79cd681ddc67f28c3", + "placeholder": "​", + "style": "IPY_MODEL_ed3eedcbbbd04e33a88bc55959e4e30a", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 351.26it/s]" + } + }, + "38d7231626294235bb8cd302a79227d3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -13886,23 +14613,7 @@ "width": null } }, - "37542e9940544689bb3e60fa786cd796": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "379aee897c594d88abf2047172f5e823": { + "393b20bcedb34a32bd150d6249707bdc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -13917,41 +14628,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_66649f05b065413fa78b45be339edb0b", + "layout": "IPY_MODEL_c524e8e8d009453b82883312c7f6db7a", "placeholder": "​", - "style": "IPY_MODEL_527a44be3b034127b1ca387a06a94d0c", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" - } - }, - "37a6e5822716413888908e9ec0048544": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b24435a8972d41b0b12249bf609467a0", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ec0e4b7f69cd46db845078b2c870c8fc", + "style": "IPY_MODEL_cc9dd0c316dc4fe983eddd4dbef18729", "tabbable": null, "tooltip": null, - "value": 899.0 + "value": " 72/89 [00:00<00:00, 355.52it/s]" } }, - "37aa79bf53a44b3aba45d335e01a52c4": { + "396fde55ae5049598649c8ae2bddc37f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14004,30 +14689,60 @@ "width": null } }, - "37afdd026ed0419e996968bc98086562": { - "model_module": "@jupyter-widgets/controls", + "39997fa549ce462cbf90e4790babef6b": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_574f8d9435724c9993185181b267d024", - "placeholder": "​", - "style": "IPY_MODEL_8913ae8f453543f1b3fbf11078e24087", - "tabbable": null, - "tooltip": null, - "value": " 36/39 [00:00<00:00, 352.60it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "37d7a6888567468bad32bb5eeeb65d68": { + "39a90639d94446d18d9b2080c488c55e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -14043,17 +14758,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_fde3ed00fb8744af93a13077c0fb90ca", - "max": 599.0, + "layout": "IPY_MODEL_75f6bf0cd9b94e139a480b13cdb7629b", + "max": 29.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_e9574faea46b46caac536226111891e3", + "style": "IPY_MODEL_8077bde4ce534c39a5d0b2837d3e44d4", "tabbable": null, "tooltip": null, - "value": 599.0 + "value": 29.0 } }, - "38006af591a445688fbb47c5d6e5922e": { + "39c0b5bf6a7e49eab47960056b854725": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14102,29 +14817,64 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "38083250e39b41a58a7b8e85ca3992f9": { - "model_module": "@jupyter-widgets/controls", + "39fe1afbc84a42879db56c483fe4d8a1": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "3826cf494a024e14aba545a3a1f8a4ff": { + "3a0c5e377d5f455fbbbae00e4d7ab3a1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14177,7 +14927,7 @@ "width": null } }, - "38b3ebd4a29a485f8c3c97a953467b35": { + "3a30ae75d03a42db87db7ea2a98555ef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -14192,107 +14942,118 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ac5149c12508461494509e9c89b33757", + "layout": "IPY_MODEL_6f7286e663514b54bec3b1b538d72338", "placeholder": "​", - "style": "IPY_MODEL_d26745479b864b0d84dff122455f8a28", + "style": "IPY_MODEL_3e70a4d4343f47bdb6656a111507a4da", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": " 72/79 [00:00<00:00, 354.13it/s]" } }, - "38c5fea0d65e4c48aa473f2b762dd8f9": { + "3a37645b000a4c53af10590124714c55": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d1b7b0961a1f485e9e7b06cdcd9e38fb", - "max": 9.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_2c7bfcf515ec40ecadafcd73332df488", - "tabbable": null, - "tooltip": null, - "value": 9.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "38cc4a5c189b4f09bd10c8d6a0371964": { + "3a38659984e64a7abf6716e2c89ffc09": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "393b37c2fb0c4f5dafcc3aea04998786": { + "3a41e9261135449a83c8c44210e1a03f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_211a1375c2a64e3f8c8ce44c3d3896a0", - "IPY_MODEL_0f7a69eb5e3a4dc39b672b48028fa0dc", - "IPY_MODEL_be76a31489ec454aa52489f09467f1b4" - ], - "layout": "IPY_MODEL_c3d0c68500644bae8d230838bc33bc9f", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_21e65a968512456b825ba37edbb11d35", + "placeholder": "​", + "style": "IPY_MODEL_9ea01d0c079a4dbba87e3421b2e9ab4c", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 36/39 [00:00<00:00, 357.26it/s]" } }, - "39493560285a4d9d98d4d7c4ac978c05": { + "3a73a963e2ea4d8182e2bd86827e56e6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_4ad85d1db6f743e5a3fe0e3e48bad247", - "IPY_MODEL_d9ebbe51225a409096250907c4c2dbf5", - "IPY_MODEL_9d4c58a0443e4f488e244a5ef5648f3c" - ], - "layout": "IPY_MODEL_3d0624c20cf142e1bcb2eb75b82c7de0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_eb2a516af8ea4ed590acf13eb1395368", + "placeholder": "​", + "style": "IPY_MODEL_8cd777158a9f4b80ac84da6c3ccd0f93", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 665/699 [00:01<00:00, 354.40it/s]" } }, - "39591337b02f45baa78620129d8e1d34": { + "3aa6ce9d278546aba93e681f40310af2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e10498b5f963419e94298780644cae20", + "placeholder": "​", + "style": "IPY_MODEL_45a6d748e7b241c8be9144fdcbd60aca", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "3af546af79cc471b890ac3d935300b94": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14345,7 +15106,7 @@ "width": null } }, - "397918938ea243d4b59c809271032831": { + "3b0c9b2f34fa46bc8f98a35807f852f3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14398,7 +15159,25 @@ "width": null } }, - "39c042dcb8344985a71093a151c39b1c": { + "3b272a1d7e334f4188d3358c3347ea0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3b9f60b3b1dc4564816deb44b0bffb54": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14447,11 +15226,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "39d947fbc8bc4b239cfdb1a73869ec61": { + "3ba2b12f61484c80b4e340ec57482816": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14504,7 +15283,31 @@ "width": null } }, - "39fa82def7dd426888453f50351c4ebc": { + "3bc7f7abb024459caf0091216f325977": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bd4fa9023e224822b3917bfab3443d16", + "IPY_MODEL_700a163adba84e838c7b256c5bdd96e9", + "IPY_MODEL_290011cbdf5b497ab3ab81d503689bdf" + ], + "layout": "IPY_MODEL_dc83120dbdfd431a98a34c91e0ac4e1f", + "tabbable": null, + "tooltip": null + } + }, + "3bcedaf0d88e430681282dab48bc18c2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14557,7 +15360,43 @@ "width": null } }, - "3a279b0dabba46cbb4a5c98f0ab0dbda": { + "3bd192336448457b84577abb5a13a391": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3bf4dc137f0b47d38f18abda273237c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3c5c0356f3554558ba8674e036be7ea6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14610,56 +15449,83 @@ "width": null } }, - "3a2adba6f0604289a9047d5785051169": { + "3c6a677e69ec4cb59ef9ed18ddb27cbb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_296b41f78d464b6d8a4c161f5cbcb8ce", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_7e6680f705bb41a892ee641163892bb1", + "layout": "IPY_MODEL_169b4846cd464296a25a2352c438bfa1", + "placeholder": "​", + "style": "IPY_MODEL_1008e4d62ad6437589931a2f33acb1b3", "tabbable": null, "tooltip": null, - "value": 299.0 + "value": " 0/19 [00:00<?, ?it/s]" } }, - "3a39e2f5dbab451e95d8290ef656261f": { - "model_module": "@jupyter-widgets/controls", + "3c7d2f074a744b5abed0237d4d1a2a96": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3dfe3f737fe74473994bb89b6894af38", - "placeholder": "​", - "style": "IPY_MODEL_6b081fd7b0d04dbd9a04c9d4ab595589", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "3a6c6ab14c9948da847a706bc8b1d7cb": { + "3ca7bc0a6a654d979b4531e9e7054a9b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -14677,7 +15543,7 @@ "text_color": null } }, - "3a7667e3dcbc46f1aa9b38ad16250142": { + "3ccc5911d21d413cbc20897f0c8c1620": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14730,7 +15596,7 @@ "width": null } }, - "3a7a3093b63340e29f3147b3593e4870": { + "3cdeacc78c024e93b82b64fade202e8e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14779,34 +15645,29 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3a9b70bb24854e7a91dcd87058764675": { + "3ce0c2d6634e45dba31093ccdfba7606": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a7c73efd6e9e416c85de8edd3c3a1b3d", - "placeholder": "​", - "style": "IPY_MODEL_2350789de04c456dac05fa481491a01c", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  74%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "3aa0235ce0ab439fa30d148062415ea2": { + "3ced3acac8dc465d96dcef2331bc1229": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -14822,17 +15683,99 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9f38f2848c3f4144a8f520ed3fe3313b", - "max": 699.0, + "layout": "IPY_MODEL_9729768eb1444460bec18b68f8f70ff0", + "max": 899.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_97b8cfee6364472aa65403ca8a153f9f", + "style": "IPY_MODEL_74ebc23a78ac49869b504d3ce0f319b5", "tabbable": null, "tooltip": null, - "value": 699.0 + "value": 899.0 + } + }, + "3d183ba506914a43a5251340be95b25a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5ca3b37a9c15400487bdc13af71fa28d", + "IPY_MODEL_8f0f556f01794e1eb87769c2fd1213e6", + "IPY_MODEL_b9b500b1c03b4c2b95f03273d5a64287" + ], + "layout": "IPY_MODEL_2af39222078242b4b6f1f65b0fd6dd38", + "tabbable": null, + "tooltip": null + } + }, + "3d268026f4a44750a9fe0750aa5b9354": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3d49d623fdf94fb59e5779765eeb932a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3dc07c6aa8094e5b8a7d6ebbcbbbab16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3856e715193944f693e416f05c24d2c8", + "IPY_MODEL_aeada5ef1208471980d98b1c7608fcd7", + "IPY_MODEL_23cb62817a984f6bbecbbb6157871411" + ], + "layout": "IPY_MODEL_e7b42f30113e493e8d7209a7ac32fbdd", + "tabbable": null, + "tooltip": null } }, - "3ae9adb1174549d4ba0765594c21ef94": { + "3e4cb3b7815d4ff5a31c91d9b895e667": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14885,7 +15828,83 @@ "width": null } }, - "3aecb2a4a5404d4c838f0c826c3e76ba": { + "3e70a4d4343f47bdb6656a111507a4da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3e74d3ad3edb458e95f869031ef2ec71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3fb2c062063e4cb18da5f89bcaa89764", + "IPY_MODEL_8cc3d6685a8a4516b8bf1773001baae0", + "IPY_MODEL_ac31071afd7a4490b17598491302bc19" + ], + "layout": "IPY_MODEL_d50e3513bd4747178debc94d4cf7541f", + "tabbable": null, + "tooltip": null + } + }, + "3ed4f845edd04920a97d7dfee473c46f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3edb1763c62046b581289258d59fc1f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3f15d96b41f544c483655ee1e4a3220c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -14900,15 +15919,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_21731e6282aa41e49caa3e7262fc9eac", + "layout": "IPY_MODEL_9411cd45d672462f9e65c3c6316c61ab", "placeholder": "​", - "style": "IPY_MODEL_d6d68e4b062d48e596a0c483fd5fda07", + "style": "IPY_MODEL_36e9ce0a1e994176b65a71967728d8aa", "tabbable": null, "tooltip": null, - "value": " 184/199 [00:00<00:00, 362.60it/s]" + "value": " 0/29 [00:00<?, ?it/s]" } }, - "3afa6238e67243a99483f24042547e9b": { + "3f44772075a84396b50d6f348e95da0f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -14926,7 +15945,7 @@ "text_color": null } }, - "3b0331d33a3646329714a68beaf02f9c": { + "3f936240f6204290b5439eabc4309d1b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -14944,7 +15963,7 @@ "text_color": null } }, - "3b4e76ff1f324cffbb30398aa59e8039": { + "3fa0aa3d2e9045d49bd56fd7a68fd3ab": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -14993,11 +16012,58 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3be06b1781ea4ae891c8f28bc5252120": { + "3fb2c062063e4cb18da5f89bcaa89764": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_19106aef732d420bad5cb5905590fd70", + "placeholder": "​", + "style": "IPY_MODEL_b8ec6ce75bd64634b84709a7aad28a6c", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  98%" + } + }, + "3fbaec84487441158fbb5aae8c259403": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7347e2d2b17342ef84da80cc00a6b36d", + "IPY_MODEL_e0e97cf252534880ac8984e3e97deb16", + "IPY_MODEL_5ab321996f164198950cc5e6c1cd7d5c" + ], + "layout": "IPY_MODEL_e1ce9b0a0e714b80aedbdd4895c22503", + "tabbable": null, + "tooltip": null + } + }, + "3fbcc97d7f8e41209df81fd5feed8fcc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -15015,83 +16081,41 @@ "text_color": null } }, - "3c29b17a7070414e8ddec58e9700afad": { - "model_module": "@jupyter-widgets/base", + "3fc42343701e4e0eae1c80b9f981ded0": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "3c45a4aa8ecf448591a298ab54ec7e85": { + "3fd78dde37ea4c8ea9c6b9ab3a428711": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c332cb2d0fd54601a8b7a7da97c30057", - "placeholder": "​", - "style": "IPY_MODEL_f88dc163254c4eb5a3a1a351ce5c07bd", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "3c46f81cd95a46348b7f8ee31dc6c6bf": { + "3fd7b789706d482c8684f49b74e26645": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -15109,7 +16133,31 @@ "text_color": null } }, - "3c5184bc80de492e9758c899b7600bc2": { + "3fdbc5a11b1245979b23f1f3aa56f5c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3095c57304ab4f2f9d96c2870893365b", + "IPY_MODEL_5e0a8b6ef9884cbcbfbe1aa47e7e5ff7", + "IPY_MODEL_665f34d6313244cb924a3be99f22e9f3" + ], + "layout": "IPY_MODEL_12f1a26e3cd74367809e13eb5c659826", + "tabbable": null, + "tooltip": null + } + }, + "4012b26debef4b6fbf72c4f6b5efb406": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15162,33 +16210,23 @@ "width": null } }, - "3cc5eaf75896480f8dff11ae8a727ed9": { + "405147a851c74bbfba69eaa3877c64c6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4ba4ec5563c04079871c7596c9085182", - "max": 9.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_a5fbfbb96bd940b6910b8461c35a803a", - "tabbable": null, - "tooltip": null, - "value": 9.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "3d016971de9c440299b7164211015a44": { + "40622752c6ce4805b010ef38c70ac776": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15237,11 +16275,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3d0624c20cf142e1bcb2eb75b82c7de0": { + "406927b85b3048159b0df61910f254b3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15290,47 +16328,27 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3d4b0780d431468593ed74d9030b494c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "3d7e9659a6924121a9f24c8517430a0b": { + "4093bcd4c7dd4e1a9e0bc440a932014e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "3d9c5a4d9bff4bc09e5f36ea24a91544": { + "40a8d9c0248b4e449b75f4a8b63bd10e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -15348,7 +16366,7 @@ "text_color": null } }, - "3dba60b55ea44aa0bea85513c47993fb": { + "40ba86d0e11a4a32b5fb7b68ce0815ad": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -15363,16 +16381,32 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_4d0966075a484a5d9e5bc9edae8a303c", - "IPY_MODEL_c830aa04c7bc42c6acc672400ef68a90", - "IPY_MODEL_5957ab1f8c284af1ba39c954d66a50b1" + "IPY_MODEL_4df55e80a64e4910bada161c2819b348", + "IPY_MODEL_6646dde21238489783319a5484ca093b", + "IPY_MODEL_5082541b756a432bae71f948f35cfa20" ], - "layout": "IPY_MODEL_6489ac4263e54beb93bcb3b7d91f786d", + "layout": "IPY_MODEL_6c0e6203ee3d4ff5aad83f5faa85a1ce", "tabbable": null, "tooltip": null } }, - "3dfe3f737fe74473994bb89b6894af38": { + "416d33f49b174a6897d564b364dfaf41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "41a22da4a8194952909f11f93c0e4ca2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15425,7 +16459,7 @@ "width": null } }, - "3e6cd27620f240f5a353061313b8b2bc": { + "41a366de5d25442993f37793a3ebd386": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15478,7 +16512,7 @@ "width": null } }, - "3e977a3b67614cfca6d57b2f08f7f3c2": { + "4202fdad659042e0a289d7772f42140d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -15494,7 +16528,83 @@ "description_width": "" } }, - "3e9ce915539a4db4a50e9139155833ef": { + "420b82723a9f4f2f8cafcb441f856a20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_df54fd77f4194ba988ce5fc11d25d071", + "IPY_MODEL_37e8311759794f6387f91a98050e7b00", + "IPY_MODEL_fa6c21d777f942f7b55058e3fbeb23dd" + ], + "layout": "IPY_MODEL_dfd5a036491646359ec43a7b5530eec9", + "tabbable": null, + "tooltip": null + } + }, + "42413899df1b4546a738aadc58d3e98e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6b5b2b4eb097432e996ebccfbc269567", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_dac229b9174046319fd89cce825d168e", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "4281e037c1be4a04a5c0586fbe23d27a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_618df38eafab424fb4e0c1c1910e9d72", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e418c289c55d4e5682b19f61757f4965", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "42a07055564948abacbcff5422ccc5c1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15543,46 +16653,20 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "3e9ee89d96554b6fb66cf469af778350": { - "model_module": "@jupyter-widgets/controls", + "42ca03e38d9c4653b1454dcfa8bc6188": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_632ee97aff484e7e98a12b6192ff4a2d", - "max": 699.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_87c85f7b73e34cb2bdc10b8417ceba0e", - "tabbable": null, - "tooltip": null, - "value": 699.0 - } - }, - "3ee76f44e6c4434cb060a79c2b7db9bf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, @@ -15622,11 +16706,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "3ef923e128e74249a7d86472b4cd4f04": { + "42ccc5e639b546b9bb7299dadb9ae7ad": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15679,7 +16763,30 @@ "width": null } }, - "3f037bc37ae64ff685d559b9f354f945": { + "42eba7a883954c9398f6234bd2c34728": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c3016b73acfa47978d29e3a91615efac", + "placeholder": "​", + "style": "IPY_MODEL_9696fb40fe7c4862b76e8a98998984b1", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 353.71it/s]" + } + }, + "42f6bd9a8f63422d885de865327c8519": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -15694,16 +16801,122 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_d8fcc39f231c4f45a0dae262217c173c", - "IPY_MODEL_3f8b3789c7e14edfb77ff1542051b71c", - "IPY_MODEL_2cfead4a1407452fb847f9fafea1cc18" + "IPY_MODEL_66ec50bb59e949e7adc908a4c6fd593a", + "IPY_MODEL_d0053b1b867b45e7bf082a6805e26b93", + "IPY_MODEL_c4739e4f68a64bed90b7aa8b4a7295c8" ], - "layout": "IPY_MODEL_35490b4a6f6a4f5e847a86296f50a223", + "layout": "IPY_MODEL_c65a35fa56134366aa5d0222a2cb839c", "tabbable": null, "tooltip": null } }, - "3f0db553b10748598540cde60822e4f1": { + "43338b6762d44123a270dc7e672607e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_41a22da4a8194952909f11f93c0e4ca2", + "placeholder": "​", + "style": "IPY_MODEL_52851c4e14e14547bb6fefef318778b9", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  51%" + } + }, + "4385eac2a71c42dd89450f825481c940": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cc00eab9c91e4f519f399f6444bc3813", + "placeholder": "​", + "style": "IPY_MODEL_356ac359c0ac45cfafbe202592794b2b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "43ce248145864a488a9da7e7eae10de5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "43e142d27a804525ac6025af8eb4167b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "444db4142ebe469f97542f252451bd1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5323436a5d484722abe36b4592c465a5", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_07fb3573ab054b70832e2fc617b70e32", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "450dde43f144464abaa0338b90ed6286": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15752,11 +16965,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3f36bab9c92040eb997e99f0ca05adaf": { + "451a5849551e42be8209cdfa1cfc72bd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15805,35 +17018,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3f72018e6e5a46fbbebb5f8d402f7757": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5cb0afb8c6ad4f1c903c3d9c1fd112aa", - "IPY_MODEL_4185729cced148158d9ee7022e9c24da", - "IPY_MODEL_508495eeadbb49a69adb53cb186ab47e" - ], - "layout": "IPY_MODEL_3d016971de9c440299b7164211015a44", - "tabbable": null, - "tooltip": null - } - }, - "3f77a1911c514851a307fd95121fa807": { + "452cb84b26dd4ba3a19725711abbc353": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -15848,15 +17037,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7dc6b4f355e1474799ad5666985523ca", + "layout": "IPY_MODEL_27632bd107564e7d9ed4a16a3855b61c", "placeholder": "​", - "style": "IPY_MODEL_b7e0716341f74ce181718c62e6d6c208", + "style": "IPY_MODEL_d01b9c6e22564874b055dcf22995909b", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  61%" + "value": " 73/79 [00:00<00:00, 358.74it/s]" } }, - "3f8945f19eb24ecaadcd3b7a33cafd0f": { + "453120223be94b3ca1d08fcfcce7a595": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -15872,43 +17061,35 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_465adb28d55e46cb9ff8ae1fff0d1bbf", - "max": 29.0, + "layout": "IPY_MODEL_ba5c0aeadc0b49cb983b3c91613db4cf", + "max": 89.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_5f12d6bf83394268a8915c4cee34a86d", + "style": "IPY_MODEL_405147a851c74bbfba69eaa3877c64c6", "tabbable": null, "tooltip": null, - "value": 29.0 + "value": 89.0 } }, - "3f8b3789c7e14edfb77ff1542051b71c": { + "45575c5868ea4ed2955c02f24b57dceb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6c48de32f8348ff8b82a4c271e979c3", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_3702144afb8a47dfb8434f24c2e2fff3", - "tabbable": null, - "tooltip": null, - "value": 99.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "3fd50bcca0f145c4b6c8bb0ce641de02": { + "4561344306f743fa84bfcd4ca3faad81": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -15957,27 +17138,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "3ffeb5b78979448caab584c031387936": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "401bfe59ea1b43f081fb0fb8a0d2b5ff": { + "458130e0e4ce453380f6671d58cb0610": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -15993,66 +17158,79 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0b9d5860db89472eafcd3106dc31cdeb", - "max": 9.0, + "layout": "IPY_MODEL_10599ad6cce34f23abe77b6a4d3056d9", + "max": 599.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_9aa3085b168c4a199a60a78c0d67dda4", + "style": "IPY_MODEL_0887380ca11d47c5bd346ff600ae5ba9", "tabbable": null, "tooltip": null, - "value": 9.0 + "value": 599.0 } }, - "40416f56012a46ed9ed4caa07e74d73d": { + "45a6d748e7b241c8be9144fdcbd60aca": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f382db9ffd234b6f92338797a6a935da", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_74dd164326ee4953a184018186b6d9ea", - "tabbable": null, - "tooltip": null, - "value": 499.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "40a68014923346b596b67ac0a4a193f4": { + "45cef1a785544e2aaa16bc70ad5a2c11": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "462d36d49519496a943435368f0a600e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ddc6cfa799264926b85f97ad463641ce", - "placeholder": "​", - "style": "IPY_MODEL_4d8bbaa3db164dbaae4f3bddb386a035", + "layout": "IPY_MODEL_8450550fc6024610a6bc525fad7664d0", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec2ac49e2bf84fceace13542de95a3a9", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" + "value": 69.0 } }, - "40b2e835983b41fb9019401c0cbfe733": { + "4693bb0c040b4ec58d73e51b0b12a377": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16101,11 +17279,29 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "40bcea7843324063a66654235af0b041": { + "46ab2b12d12c47cb91ee6f885560206a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "46bf5dbb99ea494d8501a099615ef7a2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16154,150 +17350,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "40e2610cd39e4eeaa107c8784ab9323a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_bdedb6a47a414802bd6698cd66f68ffe", - "placeholder": "​", - "style": "IPY_MODEL_efa9f0a8274b4fcf9b5370fda250fa30", - "tabbable": null, - "tooltip": null, - "value": " 37/49 [00:00<00:00, 362.56it/s]" - } - }, - "40e83a61461e46c3b706ba28f53ae68d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_089482d21d104b2091c8783589513134", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ee9292d2cf6246b482f4477a43083366", - "tabbable": null, - "tooltip": null, - "value": 799.0 - } - }, - "411e610baad644b98be37857503e8deb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_21501175081b4658b0822f3de54dba62", - "placeholder": "​", - "style": "IPY_MODEL_28dde8a12e6f41848497e696498220fb", - "tabbable": null, - "tooltip": null, - "value": " 663/699 [00:01<00:00, 365.20it/s]" - } - }, - "41799e8ed28f4b68a731b96a18ac2380": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_08925efaf2434c049defe77e47ce5277", - "placeholder": "​", - "style": "IPY_MODEL_78a732d26aa746149241725cfeeb95a0", - "tabbable": null, - "tooltip": null, - "value": " 985/999 [00:02<00:00, 364.36it/s]" - } - }, - "4185729cced148158d9ee7022e9c24da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_397918938ea243d4b59c809271032831", - "max": 399.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_b1587905de344c799dae783551080f27", - "tabbable": null, - "tooltip": null, - "value": 399.0 - } - }, - "41910242eca542acb39fbd32dd5dec5e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "41a7596b7e514adea09b0dc106ab5e41": { + "46f21dd1f9c244bf95057e462ce3acd0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16350,46 +17407,7 @@ "width": null } }, - "41c64b0d1781437499a7bfce03cd5ff9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "41e3306dc3e1434383b09f4837ad3d87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_af0e038f4de74c778a7304432a8ae7af", - "placeholder": "​", - "style": "IPY_MODEL_0b5a2fd13fcf4d4b8845daec25f835c2", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" - } - }, - "420ca366d3f84b8da696529b09e0fb7f": { + "47192803c7964534a1f1018460fbd86a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -16405,30 +17423,7 @@ "description_width": "" } }, - "42311ad84af442b3ac790c5ba3599136": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_bc851c576c0b4acca0cebbf5bd59eab2", - "placeholder": "​", - "style": "IPY_MODEL_2a2b49e661b84e3da9663b9390f47aee", - "tabbable": null, - "tooltip": null, - "value": " 36/49 [00:00<00:00, 355.69it/s]" - } - }, - "424ad561ee3b419db0c62ec97a88d8f7": { + "4763448e0e8b498fa37cb1bedd8b6b39": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16477,37 +17472,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "42a2de20706e40bb8b771300802429da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ee4ec24bdf0946429e1c92a8855fbf3d", - "max": 89.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_2429619dc67346888ea2f4cc9564a4df", - "tabbable": null, - "tooltip": null, - "value": 89.0 - } - }, - "42beb3b6bf184a8b9efc062bb0900394": { + "4785898402dd496ab26e7bf263668dc8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -16523,7 +17492,7 @@ "description_width": "" } }, - "4307e9357abb49408c2ed54e1ba18eed": { + "47966c62f9a0427ead6a81d32aef4ffb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16576,7 +17545,7 @@ "width": null } }, - "433a22b03c454b08ae34cd8d5ead62fe": { + "47d9d90e096b4c29b6a037e99b439f1f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -16594,7 +17563,23 @@ "text_color": null } }, - "438825657f4449708138c78415a3e239": { + "47ecda5260d64c2db5b6eb2e88d3d5cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "47fdcd00aca04f539b5744cfbceafde6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -16609,33 +17594,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b5fdda2c579a4cb4b17d2640ee0438f4", + "layout": "IPY_MODEL_e4fe52a54a7243a7b6ba9ae5cba42f83", "placeholder": "​", - "style": "IPY_MODEL_efd51c0a5a68438fa2197e5bafdbee2b", + "style": "IPY_MODEL_0370bd03504c4ceb855170abe09521a3", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" + "value": " 480/499 [00:01<00:00, 365.08it/s]" } }, - "4397aa33d8d94a79950ff8577dde46bf": { + "480285c93775454b81ffb69463b191f3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c495d0dedb764061a90da24cc6f0c550", + "IPY_MODEL_1a9864ef79c246aab32ef7d3d2fe38ef", + "IPY_MODEL_a874714e44a64c869a3ef23395cf3e4c" + ], + "layout": "IPY_MODEL_9759a4eac7dc4873ac30d755c457544a", + "tabbable": null, + "tooltip": null } }, - "43a7fa9e28d74fe6984d4bc3504f6d0f": { + "48a1923f3c7c4e8b802d136a551598fc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16688,56 +17679,78 @@ "width": null } }, - "43b0d4154a0f427199b58b18edc1e713": { + "48a25f680c724bb7826a6721f61a118b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ead4f63dba604c7d921e0673959a38b3", - "max": 29.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_3ffeb5b78979448caab584c031387936", - "tabbable": null, - "tooltip": null, - "value": 29.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "43b744746ec840cabe8da606987564e2": { - "model_module": "@jupyter-widgets/controls", + "48c392144bb8446eb9ae1cb4a34fef3f": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_73f0c77a4a99477583c0f2e43d41cf7a", - "placeholder": "​", - "style": "IPY_MODEL_7957afe16ff442eb94130d2c2c2b52ce", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  94%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "4408ec1204eb40538263096ca57b566e": { + "48eefbd8bed542dc8d598b294fb4e40b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -16753,7 +17766,7 @@ "description_width": "" } }, - "4465fe99e1114f66a001c2770fc06b22": { + "48fa604014a34a80a66f1f961d5956e8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -16769,33 +17782,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c3d1a25262e345c784d032f453a9354d", - "max": 69.0, + "layout": "IPY_MODEL_1b4ec66b20774352bdff7b2005092546", + "max": 49.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_c93a404c543d45a3b916e20eb761958a", + "style": "IPY_MODEL_5651796cf880443586257ab54603009d", "tabbable": null, "tooltip": null, - "value": 69.0 - } - }, - "448dcec6565e4adbb4780924bfa54d7b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 49.0 } }, - "449499c388ca4b0f8d1d58604791529b": { + "490d5179c19b4e558ab83a345562cc26": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16848,7 +17845,7 @@ "width": null } }, - "449b77da8cb04157b3a1da8bd069de3f": { + "4944d3da1b524f949fe4e557659629e5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16901,7 +17898,23 @@ "width": null } }, - "456fd90eaeb140628da39c6a96f6a7f5": { + "49d208dff05741d0a68402663c5aa060": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "49ddcabcc7e74ea183ef91cdd04f4930": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -16917,17 +17930,40 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_39fa82def7dd426888453f50351c4ebc", - "max": 79.0, + "layout": "IPY_MODEL_d18f6ac289ef4feaa12e9a15b078f60c", + "max": 59.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_e9b55a0769c74814a9026ecbe81be643", + "style": "IPY_MODEL_c98457e46a5d4643b0a8452123210f52", "tabbable": null, "tooltip": null, - "value": 79.0 + "value": 59.0 } }, - "45ad0a69cdac48eebb2fe1b7fb7e0b71": { + "49e60d33553b4869bf8c77565aff4acc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4f56ae1a73f740459b03e4e6bc403452", + "placeholder": "​", + "style": "IPY_MODEL_b3f67d994be040b582ce06c5fd29f403", + "tabbable": null, + "tooltip": null, + "value": " 480/499 [00:01<00:00, 327.79it/s]" + } + }, + "4a23ccd933d34b8ba087596923059706": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -16976,11 +18012,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "45b0e4c66bc1441bb94932e73f7efb79": { + "4a3426a7691b4e89ad7d104a9614e345": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_451a5849551e42be8209cdfa1cfc72bd", + "placeholder": "​", + "style": "IPY_MODEL_74a381d409c04c7d9feaf6039f551c18", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  95%" + } + }, + "4a38d27a221040da80dc660607276854": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17033,7 +18092,131 @@ "width": null } }, - "4604ef25e8484ff194b66b76c120ce9e": { + "4a6371bc526b41a78fb0f2e045a8b04a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ad4b6513b15b41039ea448b804082eb6", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_80c480500d96438c87e22ff10b5b16e0", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "4a79545a2a81460ca04491a89f125f60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fc641f37c79947199726203ca5d8c7f6", + "placeholder": "​", + "style": "IPY_MODEL_0b80afcbf3674e3a9ea902a7c2d8f1c9", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 352.85it/s]" + } + }, + "4af96f228e5042ef944d84ba3749afc1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7687b4c8364a4963abe985780792c7c2", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_86801af0b1724e8a99011d85936dd519", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "4afe69415fce46a08b67c509d8c9bf79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7e26015500fe4f5a82b07bcf92f328d1", + "placeholder": "​", + "style": "IPY_MODEL_e3ae51175f9a49e2ba0985a8ee8d19b4", + "tabbable": null, + "tooltip": null, + "value": " 294/299 [00:00<00:00, 361.71it/s]" + } + }, + "4b34f494fe774c2c88127ff1c8e44031": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_67f87618a5944bae9c3875356563f61b", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1617bbb5fdc14bd1ab4eaaeb4484e623", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "4b7a7a6080cd4f03a858101abd7c712e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17086,32 +18269,14 @@ "width": null } }, - "4642f5293b54495da8257c656cffc423": { - "model_module": "@jupyter-widgets/controls", + "4c26738c84a245a8ab72b75d5a5782c0": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "465adb28d55e46cb9ff8ae1fff0d1bbf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", @@ -17157,7 +18322,7 @@ "width": null } }, - "4674e0570d2240518bca3a5d9727bcee": { + "4c39db267de8446ba596c8f802013a4c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -17175,76 +18340,54 @@ "text_color": null } }, - "467f22de5d254df5b5f472b9189b246f": { - "model_module": "@jupyter-widgets/base", + "4c4dc3c884884a8fa3719a3cb160b6ea": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HBoxModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52f9cdf2eca14e60ac1bb8dbc7fa9406", + "IPY_MODEL_c27ca95f366d4cea8bf408874a5d711b", + "IPY_MODEL_a87e0af40efd46fa832b40f3621a26b7" + ], + "layout": "IPY_MODEL_fdfa0c935dd643df84b958d6dfd75629", + "tabbable": null, + "tooltip": null } }, - "4688f773988748efb9a575ca2855de8f": { + "4c566f260cd74358803899641e909308": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_50d109b7a6e34e758fbadc3fc68953a3", + "placeholder": "​", + "style": "IPY_MODEL_c10acf6386a34a8e8e75772d75686113", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 359.38it/s]" } }, - "46aedaa7a7d34779837b93dcf3916e32": { + "4c996d7d8ef547c6af0c85f1ad392170": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17293,60 +18436,47 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "46f4561da5f44b15a2f2ccd81e22474b": { + "4d2ac87224c845d2b404995d80615a9c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_16d5f1a63c72466f99b07550fa43ccda", - "placeholder": "​", - "style": "IPY_MODEL_12a1fd63340146cfaf0b672ecdbde2a2", - "tabbable": null, - "tooltip": null, - "value": " 996/999 [00:02<00:00, 361.46it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "471fd00c254048959ba917062300abe4": { + "4d37f011910d469a913ee85b040efbae": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fef876ee507e47a9839acc282b271da3", - "max": 199.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e8ad29bc62e24720a81201de0fedd77c", - "tabbable": null, - "tooltip": null, - "value": 199.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "47a7344563b841ca96d81b0baa41eff3": { + "4dab31ace5474d6795dcabf8775e6dc7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17395,11 +18525,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "47c365b75b674b73aa3e5ec64a4dcaaa": { + "4df55e80a64e4910bada161c2819b348": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -17414,68 +18544,57 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_65c751148d5942eeb004930ef5dcd52c", + "layout": "IPY_MODEL_8a8e180fa3b34b89891ca51d5695aea6", "placeholder": "​", - "style": "IPY_MODEL_fb8ce4e9e22a475eb46cd0bd06bef548", + "style": "IPY_MODEL_99016dbb40fd40a89cb69604e5c18987", "tabbable": null, "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  97%" } }, - "47e2f57dad3c43518d3178fbc20e8bf1": { - "model_module": "@jupyter-widgets/base", + "4e09c6f855624f92a7b49369ae31bbf8": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "47e3ac7c1d894d88a6fcc3d8806f5163": { + "4e2da43f92c34074851aa86f5cb9f44c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9229831101224676a7dbea9ee203b3ef", + "IPY_MODEL_ee6398d3aa9746cd81bf9b1b8cd48dad", + "IPY_MODEL_67f42ad129054bf18b1b3bfafc1b8dab" + ], + "layout": "IPY_MODEL_6fbe79bc11584675902b3edc7cc44782", + "tabbable": null, + "tooltip": null + } + }, + "4e83d49d219c43a79128cc2fba1ac885": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17524,45 +18643,61 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "47ea17bfc0014d8796cce6ce9acde73b": { + "4ea6e90d0e034f8fbbeec3ae469195d8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8127c0f2b5a5487a95ab2e81eadb18d2", + "IPY_MODEL_3ced3acac8dc465d96dcef2331bc1229", + "IPY_MODEL_ea4aaf1ab21d49d6903a112e51e8c606" + ], + "layout": "IPY_MODEL_28890c573bec4fe0b2c62b7144211780", + "tabbable": null, + "tooltip": null } }, - "480053998b7148deafbc6d956a9bb88a": { + "4f06e14bc60d4262b4cd806c6a30ef5c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9b3145839b5740b9b6c3805c2e1f588f", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3737209cc1bc46959ba770bc0052752a", + "tabbable": null, + "tooltip": null, + "value": 29.0 } }, - "484eb3d61373421481e5e7cc01b38b03": { + "4f30ef2766674efabca40e7456344b11": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17615,23 +18750,7 @@ "width": null } }, - "4864c39e3a4847a6a2188ded9f10cbf1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "486681b56e12490180a20aaf942c89aa": { + "4f519f6a766540369cfe7213bb71f585": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -17646,16 +18765,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_3c45a4aa8ecf448591a298ab54ec7e85", - "IPY_MODEL_d5ec943cb5124a8aaa8424a839224d71", - "IPY_MODEL_e3d3e60602cd4b009782826748f9bdf7" + "IPY_MODEL_17b7aae4d6944625be91605250dc7176", + "IPY_MODEL_0d753255846948a2bb93aec74c8bc444", + "IPY_MODEL_e575291ad7e9474db23155ec302dc218" ], - "layout": "IPY_MODEL_6f832ffb2e7b482385c6de4ed139a7ae", + "layout": "IPY_MODEL_4693bb0c040b4ec58d73e51b0b12a377", "tabbable": null, "tooltip": null } }, - "48924959c23d4d958c4403bd38a9021a": { + "4f56ae1a73f740459b03e4e6bc403452": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17708,7 +18827,7 @@ "width": null } }, - "48ec6902fd1643c6a101327124719189": { + "4f6c16aa09404df492a21cf05e3bc7fb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17761,7 +18880,7 @@ "width": null } }, - "48fc3741271344b695c79656379a6962": { + "4f6c9974b1bc4cc0b386aace834b9fbc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -17814,89 +18933,86 @@ "width": null } }, - "48fdae60bb784400a806e96dd5cb1294": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "493405a5fdc64ee7a63e698014ade54a": { - "model_module": "@jupyter-widgets/controls", + "4fa0161d047048f7b95ed7972a2892af": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "495733dc2b184e1c8314e2a1d1f93d9e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_15469e8d34ba4a6f80813b8992edbd61", - "IPY_MODEL_120ef5fdd51e4140bb835b9f80ae8b23", - "IPY_MODEL_1498e2383e4b4f8d862f6580681818e8" - ], - "layout": "IPY_MODEL_7d969ae053bd4f6f941d7b78b6429da8", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "49588eb8c2ab4615b4ca1692512c2a4f": { + "4fc6fbe0a5764a91bba7fa27bedd1bc6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_31b52ee3bfe24ec5acdbee1e81fdb110", - "IPY_MODEL_a6c41bd3946a46eb9f60e521964bde62", - "IPY_MODEL_21df0c639e8440a1a27f799e8e2ab808" - ], - "layout": "IPY_MODEL_c738d79f3d734fe6ba01ac5d9e67d82e", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_bd5616ad3f014c9cb608018b80a98502", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e72b9468b28f453abe0184fb63e223b2", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 999.0 } }, - "495cb904c28440eaae52abb0f40840f7": { + "4fce76ee3b3e4d64bde923d782c9263e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -17911,16 +19027,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_9c17bfe97cc9428d86e3d378eee8b5d3", - "IPY_MODEL_d8b9fcda56134502b34c74e949c6d3e2", - "IPY_MODEL_586447328c1e47e4834ed69947125932" + "IPY_MODEL_a8518783677c4086bb0208a8fa09cc4b", + "IPY_MODEL_89cc589a882048f7bfdeae7711ded275", + "IPY_MODEL_7b7d3016f75342c280b55daaa55796a2" ], - "layout": "IPY_MODEL_0c35d03637944273aea93bb69924aabc", + "layout": "IPY_MODEL_e6a774658f844c45bac440678d5c11a7", "tabbable": null, "tooltip": null } }, - "496f2d2db8cd4d6c80a59944837c14e3": { + "4fd9a0546547485c9d1da2d4db011130": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -17935,41 +19051,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_a904c112f7594f0991e7b6c55bde148d", + "layout": "IPY_MODEL_62c3cc61ede94dcaa49ec6e974997504", "placeholder": "​", - "style": "IPY_MODEL_732c72fbd0ac4b9cb68bb1f77d88d4ba", - "tabbable": null, - "tooltip": null, - "value": " 666/699 [00:01<00:00, 307.96it/s]" - } - }, - "4981ad09da8f480e931bddd371b58d83": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e24818dc9a7146d99f8348d040d3bb48", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e475f0eabf8d4677a3962363685f4b4d", + "style": "IPY_MODEL_89d7a96904334316b82982840d76a401", "tabbable": null, "tooltip": null, - "value": 899.0 + "value": " 72/89 [00:00<00:00, 357.10it/s]" } }, - "49abcf503bcd43af9c7aa11f4e5a4220": { + "4ff9e589864a422189a7f4852d707302": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -17984,16 +19074,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_63d2a279689449a8a22c76721f8634cd", - "IPY_MODEL_90bd6562f6b74386ac396b89f73f4429", - "IPY_MODEL_52bca6c6fec249689a35c66fdc986472" + "IPY_MODEL_58bcfddd8209409eb30369b138eddd88", + "IPY_MODEL_8d8a81ffd06a4e26a6526391c8e75466", + "IPY_MODEL_174dffa815ff4073a25e33329bc66d36" ], - "layout": "IPY_MODEL_3b4e76ff1f324cffbb30398aa59e8039", + "layout": "IPY_MODEL_ca93f86926934301974942581dc5a8f7", "tabbable": null, "tooltip": null } }, - "49f8c028aac745818f39efa25ae920b2": { + "5011809e608743cdae38ec46ae1007ae": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18046,103 +19136,87 @@ "width": null } }, - "4a306080bd6543b786e5313f8b89fd6d": { + "5023d09e48bd4a68aca352e9900ccfcc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d7d7efe850c24bb0905c4466d5a21ea3", - "IPY_MODEL_7190e2d5f06b494191fac51ea03d3013", - "IPY_MODEL_bf456be96f914092b288ed4e48c561cc" - ], - "layout": "IPY_MODEL_b1bcd5ba576748079cbe5e5af0a7c26a", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7c193ad6cd9c42d9befc3e39bb4745f9", + "placeholder": "​", + "style": "IPY_MODEL_31a26de69a16468ea16307c6876edada", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" } }, - "4a463b8084ad4227bdc5c39992a54d14": { + "5082541b756a432bae71f948f35cfa20": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_eaa4d7ec8a9e49c7bc4bff6253aa5620", - "max": 699.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_a2a91473024c4d33913e49a2f8553979", + "layout": "IPY_MODEL_e9729f9de3d0485a9f428bdecac3e89d", + "placeholder": "​", + "style": "IPY_MODEL_70b54da7dd874fe5ae6f400a47b0f781", "tabbable": null, "tooltip": null, - "value": 699.0 + "value": " 775/799 [00:02<00:00, 368.21it/s]" } }, - "4a58cf4738604b3fa8de0aa2929bab25": { + "50a8d7b46f2e4a4fa0312c24edd5b9b6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_92dde195120c458e9d2c1aa2049fdaad", - "placeholder": "​", - "style": "IPY_MODEL_5798190604ad47c5afe697b56f9ca3e9", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "4a599f2d385c4050a97f3d3226bd9823": { + "50aecebdcb3a4071850937a19d4d5f4e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3e9ce915539a4db4a50e9139155833ef", - "placeholder": "​", - "style": "IPY_MODEL_e87e5e1f902f41dcb9337631b9dd253a", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "4a927ddb4ad34b4d8d266a9e01e26162": { + "50d109b7a6e34e758fbadc3fc68953a3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18195,56 +19269,31 @@ "width": null } }, - "4a9b2f8743c545ffb56f3cd00d26b3d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6bdd84f7701b4c47ae60dcfc0bf5b276", - "placeholder": "​", - "style": "IPY_MODEL_030a6f3fea224c8a82f8cdce0b082606", - "tabbable": null, - "tooltip": null, - "value": " 882/899 [00:02<00:00, 365.39it/s]" - } - }, - "4aadf2868d614294b42a068cbc3fb588": { + "50d72866770d4e48819b115a032d3f72": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c827f36c27a748fb81618a1d472d47ad", - "max": 59.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_12a69feb639a449da46fcb07f90a585c", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e1196b89ce0443179a86528ce26e7798", + "IPY_MODEL_23a2aff8404b494d91b1de589f488d3d", + "IPY_MODEL_800ad6baefba4d41a5d29048d1d3d9b9" + ], + "layout": "IPY_MODEL_6bcaabafd9ed43cabf6de9ab858a73fd", "tabbable": null, - "tooltip": null, - "value": 59.0 + "tooltip": null } }, - "4acc29a2907645d7a33c08f06a804407": { + "50d86d5c91b340d49cbc965b0f34f11d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18297,30 +19346,7 @@ "width": null } }, - "4ad85d1db6f743e5a3fe0e3e48bad247": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4e81b6befe5c45ee9836dcb4b35f5203", - "placeholder": "​", - "style": "IPY_MODEL_a71616c00a964b458de213c82e775098", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  82%" - } - }, - "4af90e24693b48a2b1887129dd8a5444": { + "50df0e34fdf74026ad91c9fbd72a01f2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18373,7 +19399,108 @@ "width": null } }, - "4b299d4ab0424a17821e153a9bf463ee": { + "51026c4262f44fe8ac18df399729f0f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "513cb9319a4f41d9a5feb1fc5fde6479": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2647cebcc2fb41369c60271f6d492e2b", + "placeholder": "​", + "style": "IPY_MODEL_6fd5746a6d5e4c7f8e026fbe22333b3e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "513d7d38f80149eb9b668d4dca8b9d40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "51a794dba05346298151e9c08b769765": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6af1b8be0fae4ea8b49862a4698469ab", + "placeholder": "​", + "style": "IPY_MODEL_36e2820acb6c44f0b3fe0578c6b2f4bf", + "tabbable": null, + "tooltip": null, + "value": " 182/199 [00:00<00:00, 361.08it/s]" + } + }, + "523ddd1d3ad643ff95bcc2ccc43addfb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e56ce3624ce042a2a5b44218a8b7e609", + "placeholder": "​", + "style": "IPY_MODEL_238223f9e57145a8bf37fb06676869b8", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  61%" + } + }, + "52851c4e14e14547bb6fefef318778b9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -18391,7 +19518,7 @@ "text_color": null } }, - "4b5d39cb4bf24420a3590ed904673d3d": { + "529b1ec4105944cc99989d87eb5a16d2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18444,7 +19571,7 @@ "width": null } }, - "4b66b8c24ea04799aea8281d6bc5a43a": { + "52c897b0db6d425a8857f14deb51c249": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18493,64 +19620,52 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "4b7de920b2f34f3e908182afe2e48467": { - "model_module": "@jupyter-widgets/base", + "52d74280b7ee46a0ac2a92833aa91683": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "52f9cdf2eca14e60ac1bb8dbc7fa9406": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a83320d78dba4e00bb9066a779653553", + "placeholder": "​", + "style": "IPY_MODEL_3fbcc97d7f8e41209df81fd5feed8fcc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  52%" } }, - "4b8f164f462e4a92ba374195a9317657": { + "53193d5f8669482bafe580800acfad9d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -18566,7 +19681,7 @@ "description_width": "" } }, - "4ba4ec5563c04079871c7596c9085182": { + "5323436a5d484722abe36b4592c465a5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18619,7 +19734,23 @@ "width": null } }, - "4bb794dfe1744d55aa533efe8522ebdb": { + "5379c9731539432eac2f83387c106c4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "53973fb0e574496bb0e7dd9cf87732bd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18668,37 +19799,35 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "4c440dd136144f749019ea43419ed99b": { + "53cb05b20b374b00a98c1755ba735806": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_af9caec5dc16457491cb6a0d858c965d", - "max": 39.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_194308c29a03407fb4ce79fee27689aa", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ad98fcd3b45848088325663f3bac9d6e", + "IPY_MODEL_ce6542c58d6443049406b95884863a2a", + "IPY_MODEL_d7760ab9078e42f0b6da1798ac958216" + ], + "layout": "IPY_MODEL_95eeaf0ccae44001b3c0d3fd04e753d3", "tabbable": null, - "tooltip": null, - "value": 39.0 + "tooltip": null } }, - "4c6c3a4c1b494ba0b5fe71c4c54f4100": { + "53daf9a1d1064e99a505f18a271746e4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -18714,7 +19843,7 @@ "description_width": "" } }, - "4c777c780ba240c7b58fd16d8b93b89c": { + "543e8a4b06ec47a199fe311302e6fdba": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18767,7 +19896,25 @@ "width": null } }, - "4c80b515bdb44d03958857081b7ff066": { + "54548d8157b042bfa61ad88de710ee77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "54890dcac06444998ce00fd1824c5b35": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18820,60 +19967,23 @@ "width": null } }, - "4ce4d1cb1d5040458b65d731b611043a": { - "model_module": "@jupyter-widgets/base", + "54cb0d0cf7664fdcbc4fa0bf2525e342": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "ProgressStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "4d0966075a484a5d9e5bc9edae8a303c": { + "54e999fa6aaa45fe91577de2013491ea": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -18888,67 +19998,38 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_37386a1082ee44b2a296d3b4ecb95a10", + "layout": "IPY_MODEL_14d42043c88d4a739d89132f9e39200e", "placeholder": "​", - "style": "IPY_MODEL_0060847d73ee4413b4770132aad88aa5", + "style": "IPY_MODEL_57f34b0020e14b6cbe4da252dc53c001", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" - } - }, - "4d188c46b28a445889c00508e232c54c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "4d883c2504904f56a0248e68d05cce92": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": "Converting outputs to AnnotationStore.:  51%" } }, - "4d8bbaa3db164dbaae4f3bddb386a035": { + "550dfcb586d24a81937f730e4e75a39a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6441223389b5498caa51016546e2553e", + "placeholder": "​", + "style": "IPY_MODEL_2fec5a0c7de7499b96b252c7429cce70", + "tabbable": null, + "tooltip": null, + "value": " 570/599 [00:01<00:00, 367.13it/s]" } }, - "4dd9dc50534c410cb648a6a74fd3a74b": { + "552e637432da49fe91cfc854e17dfe05": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -18997,11 +20078,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "4e3fbb7d5cdb4fb6afbc384b86e3a3c6": { + "5570957f2a6c497fbd40283a3c0f5496": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19054,31 +20135,23 @@ "width": null } }, - "4e5cdd3c399d4f3aafc93bef4b165447": { + "55aa4fa946134f3ebb81e891214006f2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b90d8c5687c54433bad6171f9de544db", - "IPY_MODEL_6c1d48561201444f93ca459429f43c09", - "IPY_MODEL_34481362e7574831b275eec75beea53d" - ], - "layout": "IPY_MODEL_1f2c2c11ebe2411582678f05e8b84732", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "4e6ecc950a50421991cb48d9159de4c8": { + "55fcb49df3464631beee1d02c538bf09": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19131,7 +20204,25 @@ "width": null } }, - "4e704ee25e654584b271ff9b52b07d3f": { + "562b45528e364dcdbfa0e4c4219c4ede": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5645cdf3b34b4392a1d35079df931019": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -19146,15 +20237,31 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0328cc2d5ff04b8498744959cf91e87d", + "layout": "IPY_MODEL_6a5a422ef8714d379be8c6c8d2fef118", "placeholder": "​", - "style": "IPY_MODEL_f724380a346142a29ed9d12e57b047af", + "style": "IPY_MODEL_ce327262338e4a7aa9c1ccd0ff047916", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": " 72/99 [00:00<00:00, 357.18it/s]" + } + }, + "5651796cf880443586257ab54603009d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "4e81b6befe5c45ee9836dcb4b35f5203": { + "566158b97fb646ba95f4b92c174c8e36": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19207,46 +20314,102 @@ "width": null } }, - "4f210a78887a49fdb4e21d136094f12b": { + "56b164d2c3c441f4ab03fb13397543cc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "56c21fff30bd4f40bb1c8364cc8dc203": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "4f2d86db11d94eb3892d396d95488b2c": { + "56c4b383adf44a5198e04adf9a4c072c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_83c133914ba64a9d8b30afbf629912b9", - "placeholder": "​", - "style": "IPY_MODEL_a255af21947f4e9da8d97d58890a1e1c", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0f7eb2d470e9485da4f1115acc2f2fab", + "IPY_MODEL_a3ae402e09d546b1a0aceabf5baa7ba9", + "IPY_MODEL_b4015293f3ac4a16ac4ba21218c0f70d" + ], + "layout": "IPY_MODEL_b6da4af56e5d4d82ac18a5ab30ceba0e", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" + "tooltip": null } }, - "4f50e952c8ee4dfb8727e51c61e0c095": { + "5750ede9a4e24865b3dcbbb56dec8c5a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -19262,17 +20425,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_50adec0592e042138b9b1b30af560d5c", - "max": 99.0, + "layout": "IPY_MODEL_e7e85c069ce349e3828dd145557a811d", + "max": 89.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_4b8f164f462e4a92ba374195a9317657", + "style": "IPY_MODEL_e901e93125bb4f24b4df6099a964dabb", "tabbable": null, "tooltip": null, - "value": 99.0 + "value": 89.0 } }, - "4f8324d810b84b8e8d1368fe8de84d8e": { + "576848cb3f21455ca2101929d6aa2d78": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -19287,16 +20450,34 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_ab980fad443a46288c7c9020ebcb0454", - "IPY_MODEL_3e9ee89d96554b6fb66cf469af778350", - "IPY_MODEL_5f9e7af82521495394001a5420e06252" + "IPY_MODEL_77f4031b11cf4221a822f828ae77486e", + "IPY_MODEL_5750ede9a4e24865b3dcbbb56dec8c5a", + "IPY_MODEL_a25ef53382594eab84ce4066db6e1acb" ], - "layout": "IPY_MODEL_fdd0aa39b9ae426093657e1aa7180e8a", + "layout": "IPY_MODEL_0d5f5140a82642bda3459bcff9480776", "tabbable": null, "tooltip": null } }, - "502b1a5c327e4b7988044c6fa14c9856": { + "576f97c76d8d4f20af179e45c8ac60c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "577cf572db044d8ab80fa0852365222f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -19314,7 +20495,7 @@ "text_color": null } }, - "5068dbbfa0de4c3ba0e259cd8333dc2b": { + "579c8cae74bc47479051e3450d2e53ee": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19367,109 +20548,67 @@ "width": null } }, - "508495eeadbb49a69adb53cb186ab47e": { + "57f34b0020e14b6cbe4da252dc53c001": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ade3073776f24e57aa8d4acd8b874822", - "placeholder": "​", - "style": "IPY_MODEL_7d917ed562794cc8ab9c188afa2a67cb", - "tabbable": null, - "tooltip": null, - "value": " 368/399 [00:01<00:00, 363.75it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "509d9a27430844dea588744428b1d13d": { + "58044bf7b14f4d168f1a061775f28157": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4c777c780ba240c7b58fd16d8b93b89c", - "max": 29.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_65a04c10d10640c79e62e4753df0f393", - "tabbable": null, - "tooltip": null, - "value": 29.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "50adec0592e042138b9b1b30af560d5c": { - "model_module": "@jupyter-widgets/base", + "58175a1777af4c3086919ae6c696130e": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HBoxModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_083d597e30d34df1ad26947634d26f64", + "IPY_MODEL_a2e7cfaf2a544c5a81e82c7745dbf1a2", + "IPY_MODEL_028d57ef98eb42179a81de20d24fd468" + ], + "layout": "IPY_MODEL_52c897b0db6d425a8857f14deb51c249", + "tabbable": null, + "tooltip": null } }, - "50b5e466f90d42ab9e7757c25c95660c": { + "583ae5fa865e44e58095f6d1e0653cda": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19518,147 +20657,73 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "510d7d38baa440afafb811da674ea47f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a6ec65736570464d8e2b338dba9e0d16", - "IPY_MODEL_cac9c307cd2049a5924027fdbeec1a59", - "IPY_MODEL_846975ec6484423a83c9a2e462d7d933" - ], - "layout": "IPY_MODEL_861fda405f12450ba53a25bfa6a8c240", - "tabbable": null, - "tooltip": null - } - }, - "5189b615168f4e809030de24721404dd": { + "584e89b065ce458fa98822891356173f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_4e3fbb7d5cdb4fb6afbc384b86e3a3c6", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_a86ef9e81e8d447b96fe630b03dc3170", + "layout": "IPY_MODEL_b069858f0a4b46258f3fa506dad56313", + "placeholder": "​", + "style": "IPY_MODEL_36d30ce8ff704452936a6febd795ce2f", "tabbable": null, "tooltip": null, - "value": 49.0 - } - }, - "51c47b104e7a40a1a949ecdf24c4b360": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_4a599f2d385c4050a97f3d3226bd9823", - "IPY_MODEL_9c4a8b5471fb4b2baedb1b273d9434d1", - "IPY_MODEL_b0a58eae94e746e6b407403b1f19364e" - ], - "layout": "IPY_MODEL_a3359f583de74b66847fd6e657baa90c", - "tabbable": null, - "tooltip": null + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "51f50733a19b4ae6bbbd4420a8a08340": { + "5854d51b6471462c86ee1f2546501e4a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "524fc73795d24111b5aa33045f0451dd": { + "586d1116b5504762aae83152ed41c17d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_47e3ac7c1d894d88a6fcc3d8806f5163", - "max": 29.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_df0b97971d1b4da784d13950b890ade1", + "layout": "IPY_MODEL_13bd90422b144d9bb98ecbb8629e43eb", + "placeholder": "​", + "style": "IPY_MODEL_100854f2e558489b8c0777e930f1aa82", "tabbable": null, "tooltip": null, - "value": 29.0 - } - }, - "527a44be3b034127b1ca387a06a94d0c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 0/29 [00:00<?, ?it/s]" } }, - "52a1c2c1ea774909bcde9522ae401efb": { + "587990fb11284746920ea8fe9badca6b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19707,11 +20772,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "52b006d485404abb9fc87e2998bea48f": { + "589d9bbe63864dc2842500b779ddccda": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19760,11 +20825,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "52bca6c6fec249689a35c66fdc986472": { + "58bcfddd8209409eb30369b138eddd88": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -19779,38 +20844,69 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_e86ec14407794006a23d0ee3c05432dc", + "layout": "IPY_MODEL_1fbf5a76528d4ab5b928e74966a5da23", "placeholder": "​", - "style": "IPY_MODEL_2ae5a381bb6546309986b04b77fa66d5", + "style": "IPY_MODEL_1755084894eb4a85aff831213eda8f12", "tabbable": null, "tooltip": null, - "value": " 36/69 [00:00<00:00, 354.80it/s]" + "value": "Converting outputs to QuPath JSON.:  91%" } }, - "52ca007a9acd4e478ae895caf88e50ef": { + "58e56b80b55a47dfa5df724a1b285c99": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_876169a19ac84d64b4eaf6b05a42c538", - "placeholder": "​", - "style": "IPY_MODEL_b3a6f71884f8468687c7b586e2cc4d5c", - "tabbable": null, - "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5942ac1fd4c34a7c8af80120b7e098bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5995d5053ad542c8ae8563a31bf0f18b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "530a0ee2ccf1401086c4cc131935356c": { + "59fc372b0c7d47c6a1ad2bb5aafda9e5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19863,25 +20959,23 @@ "width": null } }, - "5343a2a9a0d145e9b772c8a2bd7f9c3e": { + "5a3e51c824244c7badf019718c49e776": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "5349dd59be974d739ca43d2befd9aa1b": { + "5a434a2eae7641ed849fa331173444e6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -19899,23 +20993,31 @@ "text_color": null } }, - "534afcd9dbed4095bfed7c1a8d2188ab": { + "5a9efa63bd7744b4a8933e5127d207ec": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_08d49b42f5ad4d9591b07f2edfbc7609", + "IPY_MODEL_1247e21db9ee46fe8068f9480678cf77", + "IPY_MODEL_8058a1b3d13a4daeaee5357c6551e564" + ], + "layout": "IPY_MODEL_f9d47283878e43719a8a3c6404e8a2a9", + "tabbable": null, + "tooltip": null } }, - "5365c82a72284806b762b8b39f871c43": { + "5ab321996f164198950cc5e6c1cd7d5c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -19930,15 +21032,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_47a7344563b841ca96d81b0baa41eff3", + "layout": "IPY_MODEL_828fae556e4a4ed1b464a3195cba6806", "placeholder": "​", - "style": "IPY_MODEL_55ec04c16d644ac7be619b0e196f94fc", + "style": "IPY_MODEL_c38b8462ba7b443ea92227e7328df0fd", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": " 891/899 [00:02<00:00, 364.72it/s]" } }, - "53667d101b214cc3b3e40eb7a83c99a6": { + "5ab60d8ad9ad4f6d91faddabce829f0f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -19991,25 +21093,60 @@ "width": null } }, - "53f6cf534d854995b66a138d82f38f05": { - "model_module": "@jupyter-widgets/controls", + "5c01fc665d164c62ab8450dcfbd10bb9": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "54531304ad2846d09aba8946da77c4a8": { + "5c1e982f72074c59953900c818a5a2d9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -20027,7 +21164,7 @@ "text_color": null } }, - "54a23534e2fa4254af596b2dd7122cd3": { + "5c8567bb647444c5ad7ac0fe3a82f5a1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -20043,51 +21180,40 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_255c3cb7d7114ad2a8162710a4c06ccb", - "max": 299.0, + "layout": "IPY_MODEL_566158b97fb646ba95f4b92c174c8e36", + "max": 399.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_5e81a949fcf042fb998f8b7574d18beb", + "style": "IPY_MODEL_868a9a012091425bb57ca05d007774fb", "tabbable": null, "tooltip": null, - "value": 299.0 - } - }, - "551aca7081014f0181381105695a83d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 399.0 } }, - "552d3ff7b22248b29a022782a04a8d6d": { + "5ca3b37a9c15400487bdc13af71fa28d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_06066fd514d846019d9646ede8235db6", + "placeholder": "​", + "style": "IPY_MODEL_01b7401a95654327b9d2d49a0586cbda", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" } }, - "55cfa4f5cb9f47e5baa83d7a7be485d2": { + "5ce50900ba6b4afe819c98739d371acd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -20102,60 +21228,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_794a33346ea242d7a5d23a41ad6f1741", - "IPY_MODEL_c77982866f444d27a8a2ea4f78e7e52d", - "IPY_MODEL_847dea10a3b24e3fb69fb7bc20600e97" + "IPY_MODEL_801ae2f2aeff464485df714ee32b091b", + "IPY_MODEL_b58c3219b8da4565bd0396e7253468f4", + "IPY_MODEL_99a080898a97498e97dae48489894b53" ], - "layout": "IPY_MODEL_a08e0f412404497a86f103832e131a4b", + "layout": "IPY_MODEL_4e83d49d219c43a79128cc2fba1ac885", "tabbable": null, "tooltip": null } }, - "55ec04c16d644ac7be619b0e196f94fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5609fd0412844df48ad4d91d90137947": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_cedce37f6c804bc587aacc4247b7172e", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_f8c2d3e5712d4833b35ff936ee65278f", - "tabbable": null, - "tooltip": null, - "value": 499.0 - } - }, - "568c091a7401479aba1cb5f80507730c": { + "5ce7b8aa000543458fa61abbcb29ff3f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20208,7 +21290,7 @@ "width": null } }, - "56d7f018ddae496abe2b614de1d71831": { + "5cf654eb85634875b8929bac771308ee": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -20223,15 +21305,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_642aeba1abc24ad1875c6af58fc36115", + "layout": "IPY_MODEL_5ab60d8ad9ad4f6d91faddabce829f0f", "placeholder": "​", - "style": "IPY_MODEL_1c58af823dc347839514e268e13910ee", + "style": "IPY_MODEL_0210fd179f4447ebaec52a81b5edbe1a", "tabbable": null, "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "57116be0cb5142c59d6bf15babd666c9": { + "5d31df8b004f4055b0788dfaecc2f094": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20284,25 +21366,7 @@ "width": null } }, - "57207c637ae4438c8db164c201510156": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5723301a17ea4558bbfca3fc8238d906": { + "5da1cbae882749029baaa4c0b450234f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -20317,54 +21381,41 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ef77acf3363d4105934d4c294dd6e405", + "layout": "IPY_MODEL_e5997fd3333440b7a99fbce974f2da06", "placeholder": "​", - "style": "IPY_MODEL_ae89dd9343ed4eb8814e10c101143c05", + "style": "IPY_MODEL_875174c479bb47f79e5cf2c7d6cc0835", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" - } - }, - "57305e3d08fa4b88b8002663ec22ce03": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": " 0/19 [00:00<?, ?it/s]" } }, - "5741df7837e041efb9c3f5272a447263": { + "5e0a8b6ef9884cbcbfbe1aa47e7e5ff7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_64c00cf3334d4406bbe84b27a6213689", - "placeholder": "​", - "style": "IPY_MODEL_aa68cbb92bf6492a818c9be528955058", + "layout": "IPY_MODEL_c657a9b6ef2143e88e2882cfa7cfcd8c", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_0308c1dd813b47ddb96246a6136efaec", "tabbable": null, "tooltip": null, - "value": " 18/29 [00:00<00:00, 177.11it/s]" + "value": 299.0 } }, - "574f8d9435724c9993185181b267d024": { + "5e2bad298cf94edebfcee17f9ae175b5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20413,11 +21464,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "5750eea408884bc29ffd6453c8f0d628": { + "5e6bc7eea5794a1885339cc12a01bb4d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -20432,69 +21483,40 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_c809df67f0f34d61932887bce3873785", - "IPY_MODEL_37a6e5822716413888908e9ec0048544", - "IPY_MODEL_71d61ef4180b4c498e69fdaf5deccb96" + "IPY_MODEL_c7ea9135f6c843089e877d5afb5cccc8", + "IPY_MODEL_2959fc1bb680465ea20c81966066de34", + "IPY_MODEL_ba9bf089f6844a3bb304e0dfa291ecc7" ], - "layout": "IPY_MODEL_ea47ff2930e148d3b73975bbc39c56ed", + "layout": "IPY_MODEL_b08c46c588e34e3a83348c4cdaa29caa", "tabbable": null, "tooltip": null } }, - "575d06df913048b8813a93292fc7a88b": { - "model_module": "@jupyter-widgets/base", + "5e9ce21abde14e9ea85ae05639813bee": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HBoxModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_00face300426462b818c3096297f250e", + "IPY_MODEL_2e9c800b2f9a45bcbf61734fea27fc71", + "IPY_MODEL_70c60ea1aa114e7584609188edf06256" + ], + "layout": "IPY_MODEL_11448f49a2b14f7fad4a569ab23b2225", + "tabbable": null, + "tooltip": null } }, - "5798190604ad47c5afe697b56f9ca3e9": { + "5eacec1c81b5411e8bb2a18375a08d6e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -20512,7 +21534,7 @@ "text_color": null } }, - "57ad35adfd6d41b49b52590309c70bbe": { + "5f10baf4878c4921b828d169f62a07a9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20565,25 +21587,30 @@ "width": null } }, - "57ef49ed4bb342de9c269a7b1ee5b8e5": { + "5f626046347e4560bd0b2c7d2b12b80d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_70c55b604a37448cac0043695794e1d1", + "placeholder": "​", + "style": "IPY_MODEL_9651d16bc4d94fe3b691d21de516b98a", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" } }, - "584bc0ae47744194895f073406ef9ae1": { + "5f7100c8becf41f7ba530467ce4dbd5d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20636,30 +21663,25 @@ "width": null } }, - "586447328c1e47e4834ed69947125932": { + "5fbbefe59a684a8f9bf4da79f03fdb37": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_0252dffdfd354d2a8150275e552ebee0", - "placeholder": "​", - "style": "IPY_MODEL_4d188c46b28a445889c00508e232c54c", - "tabbable": null, - "tooltip": null, - "value": " 883/899 [00:02<00:00, 361.83it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "58a2d0ed21224b8b8f9e43a4e6a8296a": { + "5fd81d37c8c148f4a1b85b04c508a3e3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20708,11 +21730,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "58a917f7215c4506b3c7e138ce9ebe16": { + "5ff96f4a3a5444bb9b543597d2b7519c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -20728,17 +21750,40 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7c4ab050194a4c5388ddac084f35b483", - "max": 699.0, + "layout": "IPY_MODEL_4012b26debef4b6fbf72c4f6b5efb406", + "max": 99.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_8c837adf34524549b4fd3ec0c3a4d530", + "style": "IPY_MODEL_1b2a4aeb9f9a427a800dbdcfde9d35f2", "tabbable": null, "tooltip": null, - "value": 699.0 + "value": 99.0 } }, - "58c83d49675b46db82266c261c036f86": { + "60047e8d7d6c45b4a948caff74f56772": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f140bb901d594523a9a19f0d44efbe63", + "placeholder": "​", + "style": "IPY_MODEL_e03f4b993d48472d96009e70eabd38cd", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "601a678eabc2447a810126d2ff6af171": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20791,7 +21836,30 @@ "width": null } }, - "591910cf345e447196e7e7b5443cc2f3": { + "6022557a45bb432aa79b3767d6cd46d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c72775ada44b461ab7fa9565fdc6df95", + "placeholder": "​", + "style": "IPY_MODEL_23bcddffb1a64b519dcf42fde50772fa", + "tabbable": null, + "tooltip": null, + "value": " 776/799 [00:02<00:00, 361.31it/s]" + } + }, + "603a889473154bf0be31c2f6252c5ad3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20844,7 +21912,30 @@ "width": null } }, - "591c8fa5dd8740c4880a1fc9d020d148": { + "6047b24816e74fe68f408dd740ee8bb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d8d70da08bd74e428dadb0f8336edf87", + "placeholder": "​", + "style": "IPY_MODEL_367bf374a704422b969b4918aa1ce3e5", + "tabbable": null, + "tooltip": null, + "value": " 588/599 [00:01<00:00, 363.41it/s]" + } + }, + "6081336c79e240d0b02143376a50c039": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20893,34 +21984,51 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "5957ab1f8c284af1ba39c954d66a50b1": { + "609e0079f5de4169bb61f0ddd99c843a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4e6ecc950a50421991cb48d9159de4c8", - "placeholder": "​", - "style": "IPY_MODEL_cfa71870608b4ee39b049c352412631e", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7b6f284007e347749f3254cc1cd352e2", + "IPY_MODEL_8bb8d988e8734e4c8d6b65a113db005e", + "IPY_MODEL_70aeb88f2d7c4c068ea3d2b725c4f753" + ], + "layout": "IPY_MODEL_e8a497971a7e4b718250060bfd7b4ed9", "tabbable": null, - "tooltip": null, - "value": " 968/999 [00:02<00:00, 353.95it/s]" + "tooltip": null + } + }, + "60b4ef84a55249f78ea86d1b61171fff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "598b6ac16039453495eae42adabdfc72": { + "611a93bc2af04c36b77c8f99abdba83f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -20973,7 +22081,7 @@ "width": null } }, - "59ffdeae8b104c3fad63490531b041ea": { + "6127ce0fc57c466990db3e1e0c0b7b4c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -20991,33 +22099,129 @@ "text_color": null } }, - "5a1ab7f2b2ea45bfb9e035d3099cec85": { + "618df38eafab424fb4e0c1c1910e9d72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61c54d536b7e4141a7ae00384cec20e0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3e6cd27620f240f5a353061313b8b2bc", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_37542e9940544689bb3e60fa786cd796", - "tabbable": null, - "tooltip": null, - "value": 99.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "5a2877cdbaf34cfdad1e409dc8f388e7": { + "620730f846fe450790fc483ceded86b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6231e3194f02432ca94921954887e9d2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -21033,30 +22237,25 @@ "description_width": "" } }, - "5a378788140448aa8817ca9f5373d77c": { + "626995cf5ec54c99bb689141ce31dc21": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a83d2632ae0e490fac1363f9af87a06c", - "placeholder": "​", - "style": "IPY_MODEL_a5407b0a1fa74f35b775c39905a804ae", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "5a8b523400a34072b4ae0e9563294207": { + "629f25a30f104f4eadc2694bcd5fd9c2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21109,7 +22308,7 @@ "width": null } }, - "5aad76ecfafd4c83b448e4354f7c6f42": { + "62b49871b3f344e09b874af7c381742e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21158,11 +22357,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "5ace9e3cea30467786e4bdb4f124bdb9": { + "62c3cc61ede94dcaa49ec6e974997504": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21215,7 +22414,7 @@ "width": null } }, - "5ad8c3961cae45b79690253e0124bae9": { + "62d9f795efd74b41a79a9ea08c8d6127": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -21233,7 +22432,71 @@ "text_color": null } }, - "5b100a208c634c92acf8aa66b5c26f24": { + "6368753371f24353b2c70e7c3b70f350": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6384b8016185409587f1011522ed5683": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3aa6ce9d278546aba93e681f40310af2", + "IPY_MODEL_08b73cfbb8b243a9aee3c9543daa634d", + "IPY_MODEL_69ba337a363f43a8a48c0388e954c14b" + ], + "layout": "IPY_MODEL_96d772ab6af6456cafc8478adbb51fc5", + "tabbable": null, + "tooltip": null + } + }, + "63a39158402f47afb50aceaa9c4599f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e3b07a7b99774f01a19bc7a3b8af11ac", + "IPY_MODEL_0b115d600d7f42c3ad2ceb02cfa2ab0d", + "IPY_MODEL_ddbe56278c5149c0b22a3a7ab874ece7" + ], + "layout": "IPY_MODEL_e2d52439f8e74571bfdb9117a6deaeb8", + "tabbable": null, + "tooltip": null + } + }, + "63b460c9ff13425db7615334360dd916": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -21248,15 +22511,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ec34fa7c1738470ca8918e8677230b63", + "layout": "IPY_MODEL_dc2609d48bbd4286a3bddb732b5e7b5b", "placeholder": "​", - "style": "IPY_MODEL_f7179f3dd1ca4bfa88f3e5f07e45a1dd", + "style": "IPY_MODEL_01256c047da4493da14ae32a9a0fafb4", "tabbable": null, "tooltip": null, - "value": " 72/79 [00:00<00:00, 358.08it/s]" + "value": "Converting outputs to AnnotationStore.: 100%" } }, - "5b1d8dbe3381429bb94ef4b4290349bd": { + "63cf240a664144609b570f6bac45f597": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -21271,16 +22534,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_4a58cf4738604b3fa8de0aa2929bab25", - "IPY_MODEL_63fff5f4ee614f37a6c514bd9092531a", - "IPY_MODEL_6415484c7f904f95a97273ca8d4e6249" + "IPY_MODEL_01fecabcf5764c239f2c1da85d1352a2", + "IPY_MODEL_83eca6f29d034bc0ba02a5efeaa0a0a9", + "IPY_MODEL_6c24396932714be29a4bb20c321da514" ], - "layout": "IPY_MODEL_23cbdff2e40843549fb4ecbf3eaccf86", + "layout": "IPY_MODEL_2e70285b0b414daea22e70b78302017d", "tabbable": null, "tooltip": null } }, - "5b98aa6d7b56442db773d661d1569276": { + "63e0cc98313a4238a7b905ab4956df34": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -21296,30 +22559,25 @@ "description_width": "" } }, - "5bbb8ff7901d448eb0f10c47b06f2aa7": { + "63e1db7c3ccd40638c87013ae59c31ed": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8559cc625eef4b61b67169eb8b23cdbf", - "placeholder": "​", - "style": "IPY_MODEL_41910242eca542acb39fbd32dd5dec5e", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  91%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "5bc1d89e46b14893a48308eda7ca8327": { + "6441223389b5498caa51016546e2553e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21372,7 +22630,23 @@ "width": null } }, - "5be3715daf394859a1394ae797100c33": { + "646d6c110e8a4247bc42de6c14671658": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64914986996b4154912c4369fe1f56c5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21425,7 +22699,23 @@ "width": null } }, - "5c32c6d8cf9042eda7fc17cdb3ef62a3": { + "6495b65e6e714f148a39632ce70a5b36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "649ab3fedc924c3fa7f20fbf096d82b7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21478,33 +22768,41 @@ "width": null } }, - "5c735f833cca42faa4e621addb0cbe62": { + "64ca28fa8b57488d87517b5275f838ff": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f31493e347064f87a4c9af4d899c8338", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_d306a770b70d48ffb43ea52e248b885f", - "tabbable": null, - "tooltip": null, - "value": 999.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "5c79d618639c487aadb061349b282f0b": { + "64fb14e7d9c44b9d94db8a1b6fa88f36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "650c7e7e1b4749e983db4e2c41231969": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21557,7 +22855,7 @@ "width": null } }, - "5cb086b732d34ff49205154cd69967d6": { + "655e863c62474a34aa8dea4c37157b37": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21610,30 +22908,25 @@ "width": null } }, - "5cb0afb8c6ad4f1c903c3d9c1fd112aa": { + "65bb7e5fc4844c28a454f6e5c5abffa3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3a7667e3dcbc46f1aa9b38ad16250142", - "placeholder": "​", - "style": "IPY_MODEL_034be21e4dd04b29b643eaa1a9df3b11", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "5dc8a57043634ef88b6a71d614a0e786": { + "65d49a6340524bed856032b498447954": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -21648,126 +22941,80 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_8ae5a42f72d9481d9e484419eaf858df", + "layout": "IPY_MODEL_c52f5fd51c52437ba271b3c4a7c66eef", "placeholder": "​", - "style": "IPY_MODEL_0ff2fe8894674c18a3cb96ccb71fdf21", + "style": "IPY_MODEL_3ed4f845edd04920a97d7dfee473c46f", "tabbable": null, "tooltip": null, - "value": " 73/89 [00:00<00:00, 364.84it/s]" + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "5e13bb5c391c4e04a8ac6c0836bb1d8f": { + "6603f689299e476cb632d4be04ef0141": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_08cf7d4ce5764be7a8d1a0d02365cd19", - "IPY_MODEL_8c3bc90181324aae887c0903fe049539", - "IPY_MODEL_73e7969992bc47719d5806d90e79fde6" - ], - "layout": "IPY_MODEL_1e1926b7480247a28fd62e30ee03d627", - "tabbable": null, - "tooltip": null - } - }, - "5e1de8a0d9a44b9a9e4289d02fd4b22c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "5e81a949fcf042fb998f8b7574d18beb": { + "6646dde21238489783319a5484ca093b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d33a4ea743e547aaa576bc4042d73bd2", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a2a9e9125f0428b93fbd2b8de7774a3", + "tabbable": null, + "tooltip": null, + "value": 799.0 } }, - "5e85fe84118c4f54a26cf2500c6af9a1": { + "665f34d6313244cb924a3be99f22e9f3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_caf0796924964acb90582ae00f5c08a5", + "placeholder": "​", + "style": "IPY_MODEL_146dde9d95b847e68de4240f3d95b4f2", + "tabbable": null, + "tooltip": null, + "value": " 293/299 [00:00<00:00, 359.97it/s]" } }, - "5ea60f460a0e482182651d158dcb90f1": { + "66c2958f021542c4a54053e022d2d173": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -21782,15 +23029,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_d4c01029140741b78012d16261101438", + "layout": "IPY_MODEL_27a5f87081fb426db2eabef1c274afad", "placeholder": "​", - "style": "IPY_MODEL_338e3a49e59d48fbbe5f390aa05d123d", + "style": "IPY_MODEL_576f97c76d8d4f20af179e45c8ac60c7", "tabbable": null, "tooltip": null, - "value": " 73/89 [00:00<00:00, 358.69it/s]" + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "5ec6217bd4bd4cd99aed4ef8f31f1cea": { + "66ebc0ee6f6f4facad2e53077e32c199": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -21843,130 +23090,83 @@ "width": null } }, - "5ef16409e8e043c7858b926c93f14394": { + "66ec50bb59e949e7adc908a4c6fd593a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5f12d6bf83394268a8915c4cee34a86d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "5f3946b11d7d4208add0431c3b69b31c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a9256530ab154816ab380145906b2153", - "IPY_MODEL_1190eeb17c3f46cbbf57fa9f36f7eca4", - "IPY_MODEL_c3c065a140994fc6ba7159dd86bc86a1" - ], - "layout": "IPY_MODEL_1af75f6281d645f2a31d3370ba5191f0", - "tabbable": null, - "tooltip": null - } - }, - "5f40d946a8204222abcaded839a22705": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_dbfee872796e4aaaae3ad4b8394fc5c8", - "IPY_MODEL_5a1ab7f2b2ea45bfb9e035d3099cec85", - "IPY_MODEL_07847480e58a43e9ae3aa39669ceb5a2" - ], - "layout": "IPY_MODEL_fe3eb75225554eeba1353933ba8056c3", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6704c7d23b214cbd92ac6886cb59116a", + "placeholder": "​", + "style": "IPY_MODEL_3128c3ace7154a1e82478caee8ed4ec1", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "5f431b448ddf4717bf79b3af34395635": { - "model_module": "@jupyter-widgets/controls", + "6704c7d23b214cbd92ac6886cb59116a": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5f9e7af82521495394001a5420e06252": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_248ae7c615c14b5692b719abb04d9f44", - "placeholder": "​", - "style": "IPY_MODEL_38083250e39b41a58a7b8e85ca3992f9", - "tabbable": null, - "tooltip": null, - "value": " 663/699 [00:01<00:00, 337.58it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "5fdee5efd1e149aca7df20d34599cfb4": { + "6715d57bc74a413a8b3eaa2ef2b87dba": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22019,7 +23219,23 @@ "width": null } }, - "60238fd9fe024b299ca30723f24441f2": { + "673588c2b2b648c29c0166c3b671cbbb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "674a2712d76f44bb94bd695d018caa0c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -22034,34 +23250,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_9a093f90a30e409cbe3152a63c84fc3b", - "IPY_MODEL_ce629a218e934721a444d3b9775ad415", - "IPY_MODEL_757021aeb7cc4645856216561db002f6" + "IPY_MODEL_c1bf003b98ea4ee8ada5e5f4a348ebda", + "IPY_MODEL_ff067a33c7cd419783bba777c39763d1", + "IPY_MODEL_aca3140cd99140feb31535c0ad1e63f0" ], - "layout": "IPY_MODEL_85b94dcab7e342e1bae99ed7893d2f09", + "layout": "IPY_MODEL_2165df5337e048db8b0324b7733fa418", "tabbable": null, "tooltip": null } }, - "606fb842ff3c4ffc8dddc6b281d2c021": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "60764445686346e4bdeb4c27828099ae": { + "67d4602d36d5415e9618ca500f54744b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22110,55 +23308,34 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "60dae5c3458c4f2490dc11353474cb58": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "60de004e799749fab0fbfc4787f44ca2": { + "67f42ad129054bf18b1b3bfafc1b8dab": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9ddcf80b54c448659d40eb246408ce2a", - "max": 39.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_c41a6a91c55047bdbf640b77fc219514", + "layout": "IPY_MODEL_f1eabed15865477c9ad9707b022376cb", + "placeholder": "​", + "style": "IPY_MODEL_7aee4d2038e5490bb8f45d3538ae1df1", "tabbable": null, "tooltip": null, - "value": 39.0 + "value": " 591/599 [00:01<00:00, 362.74it/s]" } }, - "61179f11be4d4ad3980c87be54abc0e5": { + "67f6d304a779470da994d819a825d1e9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -22176,7 +23353,7 @@ "text_color": null } }, - "61c25ba14662472d92c40579c69b680a": { + "67f87618a5944bae9c3875356563f61b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22229,30 +23406,31 @@ "width": null } }, - "61d65093718847e4be786be5d6afbeb8": { + "6801dff3175545f69d35d3219e3d7fcd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_88a1f1ef70e04a98b2ead0f5e45a18e8", - "placeholder": "​", - "style": "IPY_MODEL_0722cdd68ced4db8ac1516a4c8e0852b", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9dd43b56b85d4581873c1376cdf6cbd4", + "IPY_MODEL_bdc789dda4db4007949298732bcfaf17", + "IPY_MODEL_eac431f7c30346d2a14ca7e19ef1c49f" + ], + "layout": "IPY_MODEL_2387eb6414e042ec94b6d8456cb0661b", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  52%" + "tooltip": null } }, - "61eb86b98b4b4462b7b5a119f742b342": { + "680bb1809d75429b864a887ac5295f87": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -22267,15 +23445,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_e4b754781f6a4496828d6ab199a52e38", + "layout": "IPY_MODEL_6b4aafd2d56b493eb5ec448c11853175", "placeholder": "​", - "style": "IPY_MODEL_9c9f3b931b564870a41e892f72f302f3", + "style": "IPY_MODEL_52d74280b7ee46a0ac2a92833aa91683", "tabbable": null, "tooltip": null, - "value": " 72/89 [00:00<00:00, 356.57it/s]" + "value": " 367/399 [00:01<00:00, 354.81it/s]" + } + }, + "684dc2d3caa84db0964a014a338efaa3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_86221ceb3bb143909d134730daa1f688", + "IPY_MODEL_f862a37fdccb4249b59851554d9d90c2", + "IPY_MODEL_7c2fd7cd242c45ec816277879529d441" + ], + "layout": "IPY_MODEL_cfb39d3fa8bd4f38aea2de288a4d93fc", + "tabbable": null, + "tooltip": null } }, - "632bda88d5834271a6286cec2918ae51": { + "68578e172c194160a613d16c6a6b5eaf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -22291,40 +23493,57 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c40be986db794cd58b1b129f5abc33fb", - "max": 19.0, + "layout": "IPY_MODEL_ae11e88505c8462881be1d3cec128043", + "max": 499.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_fd3c7bb2465e454f8593489d99cc3047", + "style": "IPY_MODEL_3d268026f4a44750a9fe0750aa5b9354", "tabbable": null, "tooltip": null, - "value": 19.0 + "value": 499.0 } }, - "632e3f3f886642ce9963971e663ea7d8": { + "68afcc9f2dbe4030982ece5bc7294ce3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9bdf6403cdd644e981afee06da78ef12", - "placeholder": "​", - "style": "IPY_MODEL_1c115f9d563f46c1ad7126da2121989e", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7b7cad16e2e24ecb8715a6d5b29eb469", + "IPY_MODEL_bb91ef8684f14e92a7d33b9db78e6522", + "IPY_MODEL_06c542b4f87b407499fa3333e2de571b" + ], + "layout": "IPY_MODEL_42a07055564948abacbcff5422ccc5c1", "tabbable": null, - "tooltip": null, - "value": " 664/699 [00:01<00:00, 358.97it/s]" + "tooltip": null + } + }, + "68bef75b3c654d27bc2c65bc0a29d940": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "632ee97aff484e7e98a12b6192ff4a2d": { + "68eb60fc9da1475592a83cd04a5031f9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22377,25 +23596,60 @@ "width": null } }, - "63597cc6e8b7497bb97c1eb85e27dd4e": { - "model_module": "@jupyter-widgets/controls", + "6932fdc9d9184aab96f40553cd268888": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "63c18b60c8b340ed8ea6b0e878cf2c69": { + "6942e119616440c5ae04c4009659fdf6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -22411,40 +23665,88 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_17301b11d79b48ff90855f239fcd32cd", - "max": 59.0, + "layout": "IPY_MODEL_5570957f2a6c497fbd40283a3c0f5496", + "max": 49.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_ad7c5164053345a3b53a2c2623993ebf", + "style": "IPY_MODEL_ba62cfdfe1dc4e4da6f225330f050eb6", "tabbable": null, "tooltip": null, - "value": 59.0 + "value": 49.0 + } + }, + "694b01eb169b48dab92ee4b39d34f7e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "63d2a279689449a8a22c76721f8634cd": { + "6950a2e5bdc040a6a33bd80d60cc9b34": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b440836d41b84b47b178e910da6f4bf8", - "placeholder": "​", - "style": "IPY_MODEL_eeade946e22646f8bba9134ada76a58b", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  52%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "63d481c2220943d4b7153dbdbbd01710": { + "695cee95d751499db8f64b7eca530791": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -22460,7 +23762,7 @@ "description_width": "" } }, - "63f988873c6b4f44890eaf9a6878be72": { + "69a5808d20fa456988d9b6f59f947684": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22513,33 +23815,30 @@ "width": null } }, - "63fff5f4ee614f37a6c514bd9092531a": { + "69ba337a363f43a8a48c0388e954c14b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7b2ac3cba0ea4d568f5e253b0a5b955e", - "max": 29.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_a847f8f9f9d2446cab5a97349d94fa7c", + "layout": "IPY_MODEL_d0f1dc6dd7874991a453cfb2cb76e508", + "placeholder": "​", + "style": "IPY_MODEL_f46eca7df02f4203bc30550cccb05692", "tabbable": null, "tooltip": null, - "value": 29.0 + "value": " 369/399 [00:01<00:00, 364.66it/s]" } }, - "640aa044b6fc459899be2394f34c19c0": { + "69e8bd2b865545d0b5b015c4d2eb5f01": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -22554,38 +23853,31 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c8c0e1f905b24acdbfa568cdf6ee23d6", + "layout": "IPY_MODEL_b2cde72def81416db0b9c3c47530cc38", "placeholder": "​", - "style": "IPY_MODEL_dc9cc67c03584932bb357cd6a440babc", + "style": "IPY_MODEL_9679d122977449e89c61e767f362be84", "tabbable": null, "tooltip": null, - "value": " 371/399 [00:01<00:00, 365.50it/s]" + "value": "Converting outputs to AnnotationStore.:  97%" } }, - "6415484c7f904f95a97273ca8d4e6249": { + "69f4350a7c844c6a82b533745ee31e8a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e2d8483a206d47aaa5e6bad0f8d44e54", - "placeholder": "​", - "style": "IPY_MODEL_7e537cd48d2c4608af66f8b4fa8d0e62", - "tabbable": null, - "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "642aeba1abc24ad1875c6af58fc36115": { + "6a112e2eae2e4a049d1c7d5c8363d06e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22638,25 +23930,54 @@ "width": null } }, - "64328995eddd4d0b9edbe66b85afcb25": { + "6a42e66e95064a438ebe8f6cd78151c7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8d5ef092d1d4603bda06b82071593ca", + "placeholder": "​", + "style": "IPY_MODEL_5942ac1fd4c34a7c8af80120b7e098bc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "6a537fd1a1c249d88bc22d4690a76b75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_33e8a76effcf4002ab4aa1eed232c291", + "IPY_MODEL_edf283d5063c494d8de6170bb093172f", + "IPY_MODEL_c12b307bc25c4cc4a2855bffc9c5e490" + ], + "layout": "IPY_MODEL_4c996d7d8ef547c6af0c85f1ad392170", + "tabbable": null, + "tooltip": null } }, - "6489a182240c431494fe27e8130d66e0": { + "6a5a422ef8714d379be8c6c8d2fef118": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22705,11 +24026,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "6489ac4263e54beb93bcb3b7d91f786d": { + "6a70333c3dcc49e588b2d7ca2fe69ccd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22758,34 +24079,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "648e40aae32243c98e5cb2c6ce8899a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_044dfc445e544deaaf2bc132418a4ac8", - "placeholder": "​", - "style": "IPY_MODEL_be92533c011b48bea564987edff34fb3", - "tabbable": null, - "tooltip": null, - "value": " 73/79 [00:00<00:00, 358.82it/s]" - } - }, - "64c00cf3334d4406bbe84b27a6213689": { + "6a71b93217e4456687188de66e6ef93e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22838,81 +24136,131 @@ "width": null } }, - "64e89c05702c45f3ac0558317f9f55d5": { - "model_module": "@jupyter-widgets/controls", + "6a8578ea1efc448f99a3c6bb34fe5335": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "6545213986fc431b9109dc7b527a4892": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_93d68c4c299f4422acdc5a59e02b2a0d", - "IPY_MODEL_e65de43cf3d845f5bd10fc9300d1c6ff", - "IPY_MODEL_e1507bee1c2e451ba1c83c5ec8ad1d67" - ], - "layout": "IPY_MODEL_c3f3bc3d118948e6807827c79cb1e194", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "654c7c69cb6141c987f854aed167344d": { - "model_module": "@jupyter-widgets/controls", + "6af1b8be0fae4ea8b49862a4698469ab": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "65a04c10d10640c79e62e4753df0f393": { + "6b1ed5d530bf4ba99034fd68289dac13": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "65c751148d5942eeb004930ef5dcd52c": { + "6b4aafd2d56b493eb5ec448c11853175": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -22965,48 +24313,86 @@ "width": null } }, - "65e919da54cf4e05bbbc660cf3ebe80e": { - "model_module": "@jupyter-widgets/controls", + "6b5b2b4eb097432e996ebccfbc269567": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "6615bf33ecc44a3da71c0b8e04ed8e6a": { + "6b87a941d4fc4135b2bfc1268da08483": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_cc840cc144ca42c48191a10a6b063c19", - "placeholder": "​", - "style": "IPY_MODEL_2f46ec3dd30a44c396902bcac10a18b5", + "layout": "IPY_MODEL_b408e6a7be504c48a10b39d1d6754bb1", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_97ed54b6cbb34c45bdb68c20962da6a0", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" + "value": 499.0 } }, - "66649f05b065413fa78b45be339edb0b": { + "6bcaabafd9ed43cabf6de9ab858a73fd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23055,78 +24441,153 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "66a0d901d13d43acbb00cc373f5a1712": { - "model_module": "@jupyter-widgets/controls", + "6c0e6203ee3d4ff5aad83f5faa85a1ce": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "66d4058fafd64f4f950379b55767810f": { + "6c24396932714be29a4bb20c321da514": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f10a4f9987574935b5881e29722076ed", - "max": 699.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_cf2dd5279b0f42dcbb04a738db897ae7", + "layout": "IPY_MODEL_2f2bbd8357da451091dbc30a78476caa", + "placeholder": "​", + "style": "IPY_MODEL_58044bf7b14f4d168f1a061775f28157", "tabbable": null, "tooltip": null, - "value": 699.0 + "value": " 0/19 [00:00<?, ?it/s]" } }, - "66e9d77edd784b41a9b35a676021b82d": { + "6c24fcf5223645afb8d7245f88f1036b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_256819f1cb0c41b29b446229cfbb74a4", - "placeholder": "​", - "style": "IPY_MODEL_a14b675871374ff89a5051199843f1fd", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b1fd6d5f8bd14bfe8b17cd9d0365dbe0", + "IPY_MODEL_d3635dfaf62b4a8c9e57873ff9288933", + "IPY_MODEL_1149599e5af94bd5811ba75eb36bec30" + ], + "layout": "IPY_MODEL_a43bb73a03c94f809f6bfbcbe348dcff", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" + "tooltip": null + } + }, + "6c3a197e403e49c098636b5be9572818": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_00ddcba768f2455bbd3f6d393cf0e659", + "IPY_MODEL_6942e119616440c5ae04c4009659fdf6", + "IPY_MODEL_2e2ea624b9754e9eab65970f6234780b" + ], + "layout": "IPY_MODEL_e1d73b3a193a4f31a2b6ce3a9d8de812", + "tabbable": null, + "tooltip": null + } + }, + "6cad2e859a37425092ddac5942f613e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "66f50f81d94242a0a7c92f3c1acd7ce4": { + "6cbd64db129f4f0bb4a38afe64ab9fbc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23179,7 +24640,7 @@ "width": null } }, - "6731ba8c21bd448d98e16d3c3961ce34": { + "6d199f3efbc34732a23ce1ff7c9270c8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23232,7 +24693,7 @@ "width": null } }, - "6735bb8ce55b4d74a04e686baa7c3894": { + "6d2bae6b665a48d4901b783a4c65ab30": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23285,25 +24746,7 @@ "width": null } }, - "67c50f30b4184b90bcb9d8d8da59ab00": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "67d5c96dc9f5461b87330916c305b4b0": { + "6da5553a89574b298e471285c26b2a3b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23356,7 +24799,7 @@ "width": null } }, - "67dddc48ed9944748afc25e1d75ff05b": { + "6db9de00a119405a8a5e66846bdf8128": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -23371,34 +24814,69 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_18179e83577c4292a4b0c6264d39ebe0", - "IPY_MODEL_dc51427dd8fb4662adce820a83d7e7cf", - "IPY_MODEL_fe9a989ad2c64316bf1d9bd4fb2acf86" + "IPY_MODEL_868d200984f34b76bc3e2d7325f6f782", + "IPY_MODEL_84995f93cf78464a95c941fcdf734415", + "IPY_MODEL_790fc8a8db48481b905baad049a8a3cf" ], - "layout": "IPY_MODEL_58a2d0ed21224b8b8f9e43a4e6a8296a", + "layout": "IPY_MODEL_e46cd31731cd4b8e9e584c6cac759d68", "tabbable": null, "tooltip": null } }, - "681f63faca654225afd68d7584bd114b": { - "model_module": "@jupyter-widgets/controls", + "6dc8bde88e28418d986b723dd962e76f": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "68433c7916cc4732a85ef3ed3a3c6e56": { + "6de7f42dafb741e5a8402de2b4b91feb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -23413,15 +24891,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ea9d152434c44c8e8f6bd7aced190103", + "layout": "IPY_MODEL_6a71b93217e4456687188de66e6ef93e", "placeholder": "​", - "style": "IPY_MODEL_433a22b03c454b08ae34cd8d5ead62fe", + "style": "IPY_MODEL_d39418e9914e4a8fa76cd325562fcf83", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  96%" + "value": " 969/999 [00:02<00:00, 360.56it/s]" } }, - "684e2d618bd640bcb736ac88afab5769": { + "6ed6e46243f3408ea9d7bfa6037d2e7b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -23436,16 +24914,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_43b744746ec840cabe8da606987564e2", - "IPY_MODEL_456fd90eaeb140628da39c6a96f6a7f5", - "IPY_MODEL_6a2498e402084a28b935886762e0533c" + "IPY_MODEL_523ddd1d3ad643ff95bcc2ccc43addfb", + "IPY_MODEL_368b0548bd9647f28b2f3d5c7399f865", + "IPY_MODEL_42eba7a883954c9398f6234bd2c34728" ], - "layout": "IPY_MODEL_f0163d82a0da4d8796c79376cb59ba60", + "layout": "IPY_MODEL_9b206ad6aaec4773b8b3a8388d67c323", "tabbable": null, "tooltip": null } }, - "6866a64e6a494644ae47e04fbe9567af": { + "6eef21ee72594bdfaadb724457930c01": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23498,126 +24976,60 @@ "width": null } }, - "68744436f7954d1d90fa5e02877e5c44": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b59083f0ec09407dac286854bfb5f42a", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_cd23969b19544ac798b5505542a1b869", - "tabbable": null, - "tooltip": null, - "value": 999.0 - } - }, - "6915182708974687bc9a94f20011c6fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_96831a1dc2604a4aa68fd22e2ae3678b", - "max": 599.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_f05c396f9638427b8ff97ae0cc1d304c", - "tabbable": null, - "tooltip": null, - "value": 599.0 - } - }, - "6965bd8b51a7496c83698123a8dc7478": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_61c25ba14662472d92c40579c69b680a", - "placeholder": "​", - "style": "IPY_MODEL_fbc2e2800f69459e9adc3a61700c71b5", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  81%" - } - }, - "696da8126c1841168596b216aaf22aca": { - "model_module": "@jupyter-widgets/controls", + "6f692c43749f4f899eac406bc3132a1d": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "6977c8e870d6452fb31d45a02e09d113": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_53667d101b214cc3b3e40eb7a83c99a6", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_c5845f14cd234dd88eb917236dc1ea7e", - "tabbable": null, - "tooltip": null, - "value": 899.0 + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "69af71543bad4eca9e1fc061c2029a09": { + "6f7286e663514b54bec3b1b538d72338": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23666,184 +25078,14 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "69cd31c536d9404d92d39b4d91549d19": { - "model_module": "@jupyter-widgets/controls", + "6fbe79bc11584675902b3edc7cc44782": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b8fd8c018d42415ca5d867c6d5527f7b", - "placeholder": "​", - "style": "IPY_MODEL_dd21b7e9f2204483a81155c8c942a14c", - "tabbable": null, - "tooltip": null, - "value": " 73/89 [00:00<00:00, 357.64it/s]" - } - }, - "69cf359906074f75b6be86e700d6a417": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5723301a17ea4558bbfca3fc8238d906", - "IPY_MODEL_3aa0235ce0ab439fa30d148062415ea2", - "IPY_MODEL_15bacaaa83cc4d4d8178c97f3132e31d" - ], - "layout": "IPY_MODEL_0eff6eb6b0464bb99d15ed98f3c6528a", - "tabbable": null, - "tooltip": null - } - }, - "6a241b90ea934dfbb7681056ccf7de62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_c6e0e8835ce34e21a3a4ddf1e0bd3c92", - "max": 699.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_9c49f5baec4442f89e280a9601e77095", - "tabbable": null, - "tooltip": null, - "value": 699.0 - } - }, - "6a2498e402084a28b935886762e0533c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_361f5bf265d04118866d71ed7620197e", - "placeholder": "​", - "style": "IPY_MODEL_b0f0e7ff3137469cb9bf38983eb4bc17", - "tabbable": null, - "tooltip": null, - "value": " 74/79 [00:00<00:00, 365.62it/s]" - } - }, - "6a2ef554ab7548399ae616331f89d96c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_66f50f81d94242a0a7c92f3c1acd7ce4", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_11b70c1674db47d8bae8cb991942250b", - "tabbable": null, - "tooltip": null, - "value": 799.0 - } - }, - "6a58bb9506034a7a9a236632ec663b53": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6965bd8b51a7496c83698123a8dc7478", - "IPY_MODEL_ee0f9c2fc55e47bc982180eee3863d3b", - "IPY_MODEL_08edb965c1a0472287c034112093d682" - ], - "layout": "IPY_MODEL_fb046d79c2604487b3f754060000488a", - "tabbable": null, - "tooltip": null - } - }, - "6a6c374cac544ee18a1f2313bbd4e9c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_75cf65f8b1ae4829bbceb7a5335622dc", - "IPY_MODEL_f123cf87de6b4d6986dfcb05a9aed4c0", - "IPY_MODEL_5b100a208c634c92acf8aa66b5c26f24" - ], - "layout": "IPY_MODEL_acc2541152ad42ad904a608103986423", - "tabbable": null, - "tooltip": null - } - }, - "6a9ed65510764abb955653db0e7ee27b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", @@ -23893,49 +25135,7 @@ "width": null } }, - "6b081fd7b0d04dbd9a04c9d4ab595589": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "6b46da5e916f4a58bc0f661400a2b780": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a08167146de343a98ad9b927545e880c", - "IPY_MODEL_ec127cbcbcd34525a3314895422c4a52", - "IPY_MODEL_884d7c1a96864130809764bbd0083ee3" - ], - "layout": "IPY_MODEL_834d1ac7aa9140828523cd26219a2788", - "tabbable": null, - "tooltip": null - } - }, - "6ba40fe467a245cf8236007fcb4ac620": { + "6fd53aa9c116481289bbac5e00168f12": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -23988,76 +25188,25 @@ "width": null } }, - "6bb48ac44e154515865180e401f675f3": { + "6fd5746a6d5e4c7f8e026fbe22333b3e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "6bdd84f7701b4c47ae60dcfc0bf5b276": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "6be0780908634d7c9b6949f92f8a68b2": { + "6fe8246e8d594706b86c84d7a62ee7f5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -24075,113 +25224,48 @@ "text_color": null } }, - "6c0e153016a94e5a8300a31fad2acea5": { - "model_module": "@jupyter-widgets/base", + "6feac2f64e5d47c2a83d74c8e0dcc539": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1465ca55900843ceb59658b2b6f733a6", + "placeholder": "​", + "style": "IPY_MODEL_f121f860b8db4236b9c00f3c5523e048", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  91%" } }, - "6c1761f7fe5b4b9bb5db2466388b6f77": { - "model_module": "@jupyter-widgets/base", + "6ffc473f5ec445f1b9f2bc8251ba5dee": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "6c1d48561201444f93ca459429f43c09": { + "700a163adba84e838c7b256c5bdd96e9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -24197,17 +25281,35 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f26f7cd6572344afb1df3d7dfb92f478", - "max": 59.0, + "layout": "IPY_MODEL_d958316f5210497daf8211068f41e12f", + "max": 79.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_74ea3b1b795b4c86afabc8faabfeff66", + "style": "IPY_MODEL_2dbfe8df36f940e6a71e17fa76d83bdb", "tabbable": null, "tooltip": null, - "value": 59.0 + "value": 79.0 } }, - "6c637650a170405ebdf9b07b83ac83bb": { + "703f96c620f6473ba611f6a1738d45a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "70547f4edb4a4dd5b87db110c89d13b9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -24223,7 +25325,25 @@ "description_width": "" } }, - "6c67410295884800a620f374d0d87830": { + "7072d198ccfc44eca813f458a163c6ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "70aeb88f2d7c4c068ea3d2b725c4f753": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -24238,68 +25358,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9045bf1e1a564f2c98790e37e57fdd70", + "layout": "IPY_MODEL_77a6c0f75fd24cb4b5f0085f43dcdeeb", "placeholder": "​", - "style": "IPY_MODEL_a557bb53bc8642749f8560bb1c0985f5", + "style": "IPY_MODEL_32d1aa79e800431591903cdee0b4c3e9", "tabbable": null, "tooltip": null, - "value": " 898/899 [00:02<00:00, 323.11it/s]" + "value": " 776/799 [00:02<00:00, 338.16it/s]" } }, - "6c6a06ed639a422c8d8853ff59c4b1b7": { - "model_module": "@jupyter-widgets/base", + "70b54da7dd874fe5ae6f400a47b0f781": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "6c9c1f760faa4bbf966682d22838e8b6": { + "70c55b604a37448cac0043695794e1d1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -24348,51 +25433,60 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "6cafb5e03115448cbe616cef3548c178": { + "70c60ea1aa114e7584609188edf06256": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b842634c17bc430eb57f5c102cd9d838", - "IPY_MODEL_3340bd63010b4136a2f321d8fa0c528b", - "IPY_MODEL_3aecb2a4a5404d4c838f0c826c3e76ba" - ], - "layout": "IPY_MODEL_7c67bcdcdc9d46a2add5ed6fb6d1d760", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3073387c75ca4ddea20a8563bdcb897d", + "placeholder": "​", + "style": "IPY_MODEL_64fb14e7d9c44b9d94db8a1b6fa88f36", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 887/899 [00:02<00:00, 363.76it/s]" } }, - "6cb14dea20cf43ec9a6d6c8785c6cece": { + "70cbcc2a16864e45ad9ea55fefb77f48": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e44b30a72b774bc5905ff7bc4ab17629", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5379c9731539432eac2f83387c106c4c", + "tabbable": null, + "tooltip": null, + "value": 799.0 } }, - "6cbcef1a9aa448d3a5437ee29d76c770": { + "70df042231194fbe82ead72f6b9f2e60": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -24408,166 +25502,7 @@ "description_width": "" } }, - "6cef078f27b34534aad4200d93d0f910": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "6d340030ab4a4a5c99c2a10b79695418": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6d3b327094f54cb48f6be0adc8283f2e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "6d3ccec4c42b402b996aa16bc7b9e2d5": { + "7112463e81b045839ebfbb1667af164e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -24585,7 +25520,7 @@ "text_color": null } }, - "6d93a53d604049e08e5720f826739d68": { + "71668fd6d677488fbbeea29f7c9a2a0a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -24603,54 +25538,54 @@ "text_color": null } }, - "6e31475de7ac433caaf1847bea3ee857": { + "717487e4c2c14329a81d3d95f13dfd64": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fe78982fb27943eda4f9448dd2cafeac", - "placeholder": "​", - "style": "IPY_MODEL_1d8a9819f75143a792325a6a1e24c888", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cc6f4ec9dd164fc7bdb8b702cb8de8ba", + "IPY_MODEL_458130e0e4ce453380f6671d58cb0610", + "IPY_MODEL_9e03ee6506ee4c4db8f1897fbe116601" + ], + "layout": "IPY_MODEL_087f9233505e4f38b5e276a8fb744d62", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  82%" + "tooltip": null } }, - "6e9bb6066bdf49c88efe29f269344687": { + "71cecd7b751d43969aca71d9db9b5767": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f52e4c4680d3402fb7e0db7394ebed75", - "IPY_MODEL_710c485400d14a848d0a2633265a55d3", - "IPY_MODEL_fd645dbd466f4d53857b74abc5891616" - ], - "layout": "IPY_MODEL_6c9c1f760faa4bbf966682d22838e8b6", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4c26738c84a245a8ab72b75d5a5782c0", + "placeholder": "​", + "style": "IPY_MODEL_e1165605afa542aca4d73fe573eb7702", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 17/29 [00:00<00:00, 169.12it/s]" } }, - "6f832ffb2e7b482385c6de4ed139a7ae": { + "723e0d886f394340a4af62a692898f32": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -24703,7 +25638,49 @@ "width": null } }, - "6f97f3f8078648f499ec2cf3e8d5c29e": { + "7285f3cbf7c84a0986d0d5a459ada8c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7291352398564cb89a8fa097aa96e49e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1078e72727fb40578ac947e90578782d", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_61c54d536b7e4141a7ae00384cec20e0", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "72fa5be009b1428681afd6ea2d3aa600": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -24756,25 +25733,30 @@ "width": null } }, - "6fa895fc623a4058b809bffb7eb68519": { + "7347e2d2b17342ef84da80cc00a6b36d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9afb98d7126747b5b80672d25bf0893c", + "placeholder": "​", + "style": "IPY_MODEL_dd9ac98c3fe144c6bacd968b4eee5976", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "6fcdc0a474df4b66a1f7bd8ad0689c21": { + "7353f29152ef4e619142ca03867eb216": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -24789,15 +25771,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_a7f1bb5697c346f7a6968f3ce65a49bb", + "layout": "IPY_MODEL_1b8d05386e7942a9beec9e6f906f538d", "placeholder": "​", - "style": "IPY_MODEL_0fe3cac99b2b4e26a5ae84ed7da87675", + "style": "IPY_MODEL_1109ba3c8a164801a60f1d6eef1f9f56", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": "Converting outputs to QuPath JSON.:  91%" } }, - "7021866ffaf74b48b951a0d457173c2e": { + "73a8e1e7285d4478928bba34cda0c13d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -24850,46 +25832,33 @@ "width": null } }, - "70354077febd42db84a54d2bf0fc088f": { + "73e09763d0a94859a5156960d0be26eb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_57ad35adfd6d41b49b52590309c70bbe", - "placeholder": "​", - "style": "IPY_MODEL_187ea56dade04dcf9af1d225eee8ac22", + "layout": "IPY_MODEL_4944d3da1b524f949fe4e557659629e5", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b7f5534d78924cc6940b0d413abfd820", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" - } - }, - "70619300dd114a6cae94b4d91ea55e11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 999.0 } }, - "708974b8aecd47ef963493532093de01": { + "7421c9b289f74f3d9420ad30d50b0f6f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -24942,31 +25911,7 @@ "width": null } }, - "70f12c89e3af482c8bc0ec35da4cf5ba": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_19fdb976dfaf42e8ac15f8a64ab307fb", - "IPY_MODEL_8450f3c696e84e9bbbe7e90598139078", - "IPY_MODEL_c1cfd029710349e8bb2a6720ae411985" - ], - "layout": "IPY_MODEL_890eaf610af7408c8137b6a626d6012f", - "tabbable": null, - "tooltip": null - } - }, - "70fe49d3a40942d298e2504e40da90bc": { + "742edab5440f46f2ad4ea31bf7c82326": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -24984,33 +25929,7 @@ "text_color": null } }, - "710c485400d14a848d0a2633265a55d3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d0378c9c2cc049c98bd4ff706f607836", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_75ea079f1da349299ee02309936d0530", - "tabbable": null, - "tooltip": null, - "value": 499.0 - } - }, - "710c80d0beee4809beba178b2fe4d62c": { + "74a381d409c04c7d9feaf6039f551c18": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -25028,33 +25947,7 @@ "text_color": null } }, - "7190e2d5f06b494191fac51ea03d3013": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ca1248100bea43b1b7758f88369fff6f", - "max": 69.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_6cbcef1a9aa448d3a5437ee29d76c770", - "tabbable": null, - "tooltip": null, - "value": 69.0 - } - }, - "71ca441c651843b5ab369965e9fff8aa": { + "74d2e8bc8f89480da859936e7cc65085": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25103,60 +25996,43 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "71d61ef4180b4c498e69fdaf5deccb96": { + "74ebc23a78ac49869b504d3ce0f319b5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9b12610ec0dd453a80680804659a950f", - "placeholder": "​", - "style": "IPY_MODEL_2ffc7c0b499747e4859a41fc0a38a575", - "tabbable": null, - "tooltip": null, - "value": " 885/899 [00:02<00:00, 337.23it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "72040055ac464cc5ae07bbd7b8f42d85": { + "75122864ec6847fd9247373a01af451f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_60764445686346e4bdeb4c27828099ae", - "max": 399.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_283a5ae3c76046ee9011294a32e8d487", - "tabbable": null, - "tooltip": null, - "value": 399.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "7249d35604ea4dd5ad74f2f58dc166b8": { + "7526d925e31d40f680e88fe17803ac2b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -25174,83 +26050,23 @@ "text_color": null } }, - "72977439fc354dbe81b6f7e1c051b209": { + "756dbf15767f4d0598abcc9cb70f4b75": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f708fdbc67674d22b9e64017ccd7571b", - "placeholder": "​", - "style": "IPY_MODEL_51f50733a19b4ae6bbbd4420a8a08340", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" - } - }, - "72e11d753a6d4b7c8d70e84694cae823": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "732c72fbd0ac4b9cb68bb1f77d88d4ba": { + "75786ef0047e4daabf4ad9c2b42786c0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -25268,7 +26084,7 @@ "text_color": null } }, - "73587d88a7244b6bbb8e239ac3e479e4": { + "75a22ce6730e4173bd312b9fb01aeff5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -25286,53 +26102,31 @@ "text_color": null } }, - "73b020aab87b477f9258d472e64bc365": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9706dc5644ff4d2aba97ca170e545439", - "placeholder": "​", - "style": "IPY_MODEL_96837fd03fbf417bb0fc348dde7d1451", - "tabbable": null, - "tooltip": null, - "value": " 72/79 [00:00<00:00, 357.13it/s]" - } - }, - "73e7969992bc47719d5806d90e79fde6": { + "75c87d59d5fd45bb8890383755e748b8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_306a8f365de746fb96d9898459d2d185", - "placeholder": "​", - "style": "IPY_MODEL_b4b4001d21704f6d9722b7baad72dd26", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_00ab537bb0dd4bb2aec926f542d533f7", + "IPY_MODEL_7bb3dd6db19a4f3ebfd541c7a1084565", + "IPY_MODEL_8d547599e9e1444fa43ffd89d8db9450" + ], + "layout": "IPY_MODEL_42ca03e38d9c4653b1454dcfa8bc6188", "tabbable": null, - "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" + "tooltip": null } }, - "73f0959e57604fdcb6042ddd4d37ac7b": { + "75f6bf0cd9b94e139a480b13cdb7629b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25385,60 +26179,25 @@ "width": null } }, - "73f0c77a4a99477583c0f2e43d41cf7a": { - "model_module": "@jupyter-widgets/base", + "75f7c3a2ad1b4c66af6bdbc7569dd562": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7421837a72f145c19e42660ab6d9b86a": { + "7607e3b62c5e46fb961ae68e2cc7996c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25491,7 +26250,43 @@ "width": null } }, - "742c8964f8e345d882b4df12f377dd46": { + "762ed4b07e8c4367bea77d1e57740c1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "76730fc61384421da65d47ea3758d466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7687b4c8364a4963abe985780792c7c2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25544,31 +26339,30 @@ "width": null } }, - "745240905efa4d70951fed68152308a7": { + "768a28368c5340ad93e460b279359387": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0eb06dd7112d444185d8378055502557", - "IPY_MODEL_e755273fe7414af393da0e637c45cb6c", - "IPY_MODEL_da46a2589b244ea59a9ec83fa6a984a2" - ], - "layout": "IPY_MODEL_ac565eb12f424e02aaee1713f6830bd6", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a187df2ebeb44b62813b0559b2e3b406", + "placeholder": "​", + "style": "IPY_MODEL_fb2d4e6ff12443fda45af43367604f1a", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 72/89 [00:00<00:00, 357.49it/s]" } }, - "74526b09aae44f80b5578703630e8478": { + "76c042875c5b4193a77e8e56bb65e422": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25621,23 +26415,7 @@ "width": null } }, - "74dd164326ee4953a184018186b6d9ea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "74ea3b1b795b4c86afabc8faabfeff66": { + "76d9e0ea8bd14332802ebb8ba9f2067b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -25653,7 +26431,7 @@ "description_width": "" } }, - "750888b11d054b8abf80aba23ff3b7d3": { + "76dc82edf3544e2389b85f42f4264905": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -25668,15 +26446,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0126894018224984b563e8bcb410d05d", + "layout": "IPY_MODEL_09bc7553943a451db3d1e7c4c0167763", "placeholder": "​", - "style": "IPY_MODEL_075e2975edcc4b538157b98ef22e4ad1", + "style": "IPY_MODEL_8d8d4a581f804131ac5851cbceb23f09", "tabbable": null, "tooltip": null, - "value": " 73/99 [00:00<00:00, 358.95it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "752ad6e08aeb4421af878c91a4a38e5d": { + "77a6c0f75fd24cb4b5f0085f43dcdeeb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -25721,226 +26499,90 @@ "object_fit": null, "object_position": null, "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "757021aeb7cc4645856216561db002f6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a4ac22479ee04dc5bd7b96347fe9b5f1", - "placeholder": "​", - "style": "IPY_MODEL_b2becf330305494798229d046a60ffad", - "tabbable": null, - "tooltip": null, - "value": " 773/799 [00:02<00:00, 347.87it/s]" - } - }, - "75cf65f8b1ae4829bbceb7a5335622dc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_e6da76fcbbce45558f7d698926f56490", - "placeholder": "​", - "style": "IPY_MODEL_b5138b22c1ea49bab49fd56ccbca76e1", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  91%" - } - }, - "75e0a5581429468dbb12e4f0523baf1e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "75ea079f1da349299ee02309936d0530": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "76570316d23f43809be5856b491f1b0e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_67d5c96dc9f5461b87330916c305b4b0", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_bb04a2592724400c93e6c968f22b30b2", - "tabbable": null, - "tooltip": null, - "value": 799.0 - } - }, - "766f2422c6c14704bbea3fe759a29a31": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "76afe945b755482abc45b5e568995a6c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "76d7332ffd45486faf2b251a563ff724": { + "77ebf88552fc41d5a5f0c5e1221ae215": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_449499c388ca4b0f8d1d58604791529b", - "placeholder": "​", - "style": "IPY_MODEL_cf8d72605023472e93d5fafcb932a082", + "layout": "IPY_MODEL_42ccc5e639b546b9bb7299dadb9ae7ad", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1d3d8307b76c40da956fb3eb6d0b20c3", "tabbable": null, "tooltip": null, - "value": " 36/49 [00:00<00:00, 358.81it/s]" + "value": 39.0 } }, - "76ef200b1a9b445eab8e50b258b02c92": { + "77f4031b11cf4221a822f828ae77486e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b57c7ff42f9b49c59a427dcd06f42710", - "IPY_MODEL_7c9002d84e45477ea8410b43ca31a599", - "IPY_MODEL_c6ec5a672f2d4b289c1d6319fb96229c" - ], - "layout": "IPY_MODEL_6731ba8c21bd448d98e16d3c3961ce34", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5c01fc665d164c62ab8450dcfbd10bb9", + "placeholder": "​", + "style": "IPY_MODEL_cc83b4ec96674f2b8af46552fcedd93a", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  82%" } }, - "7712728c73144961a6cd32df93caba86": { + "78919eaaede04982b64631c67dc473b0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9cd1c8f5093d4cf88234a53abb8aa455", - "IPY_MODEL_a75e3652be124a3886c39a30a2610599", - "IPY_MODEL_8b8d9060127e4c3e8087e7c0079d42d7" - ], - "layout": "IPY_MODEL_6c1761f7fe5b4b9bb5db2466388b6f77", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d9a4a04c80cb45c1b73fc55737f96e2f", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_bb49305c3af74a308e33f574fa5484cd", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 299.0 } }, - "776ad76aba9548ff87f451346ffe5e6e": { + "78a1c9ce03b247e29bde5cf2cd868efc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -25955,39 +26597,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_da2bf1956cc545ca8cc0d568b915d4b4", + "layout": "IPY_MODEL_4561344306f743fa84bfcd4ca3faad81", "placeholder": "​", - "style": "IPY_MODEL_d12c7f9fe8f949c5a413058f75fe9159", + "style": "IPY_MODEL_940b71325dd74ef1a6ce72503443b3be", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  93%" + "value": "Converting outputs to QuPath JSON.:  74%" } }, - "777b18b6acfa4d4fb711d81c6cb170f9": { + "78b3e207ee2045ea9510bba15b2873b5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6fcdc0a474df4b66a1f7bd8ad0689c21", - "IPY_MODEL_80322a1fd9f645e3aadaba8e90df699a", - "IPY_MODEL_0b1fe2bfddaf432e8689aa62f0b7a7fe" - ], - "layout": "IPY_MODEL_96b58127d2384a8eb80a48c4250a3a29", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7784ced197a241ce8f72d0b75833f4d6": { + "7909d6ca3f5944a9bf46cf8319aa6da9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26040,7 +26676,30 @@ "width": null } }, - "77caf9bc83a4425eb8a2307926eeb99c": { + "790fc8a8db48481b905baad049a8a3cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8f528ad011b4bceb1af3db800487ba3", + "placeholder": "​", + "style": "IPY_MODEL_e14297571c0e4af8a43b9c98f1e9628a", + "tabbable": null, + "tooltip": null, + "value": " 696/699 [00:01<00:00, 363.06it/s]" + } + }, + "79130a2cb7014a19b946d2b50db39108": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26093,47 +26752,7 @@ "width": null } }, - "77db329df29b48f1b21c6585dd05d327": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f49954c8368243b8978265281ec86c4d", - "IPY_MODEL_0f52b0bb14a2422f8255a59614352d54", - "IPY_MODEL_31c1eb4f79f4459b8125293e0af13fa8" - ], - "layout": "IPY_MODEL_12a6aba1c13649ce83260edd991ec1cc", - "tabbable": null, - "tooltip": null - } - }, - "77e08403607348f9938f0d851c8d537e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "782e9f59991440fb8f2bb58d0540321b": { + "7965c2da37514e1b860aef0e35d81843": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26182,87 +26801,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "78a732d26aa746149241725cfeeb95a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "78c944b5ea5c4cdeb515d72c4eee6022": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "78e58664ca7f48c388cab93235a0af8f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_84ac33aab3f241d1b6754c7ee4107e3f", - "IPY_MODEL_03620e83b2a54d48974c46c04af50a11", - "IPY_MODEL_1098bcfa42894381a07c5883849c651c" - ], - "layout": "IPY_MODEL_205298a761d64130beb1f7385fe7a829", - "tabbable": null, - "tooltip": null - } - }, - "7947d8d88c46427286df33834c3e2dd7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "794891c9744b49379f3238ab072dac41": { + "796bc589404642bb951496bd95004ee1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26315,71 +26858,7 @@ "width": null } }, - "794a33346ea242d7a5d23a41ad6f1741": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4b66b8c24ea04799aea8281d6bc5a43a", - "placeholder": "​", - "style": "IPY_MODEL_b3acf684348f4c47b64c350a910a0a2e", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  52%" - } - }, - "7957afe16ff442eb94130d2c2c2b52ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "79afd59b049d4f68a33a08106aeb2c48": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b787c0b07c794e05a349801dcf28d706", - "placeholder": "​", - "style": "IPY_MODEL_c707f497aec24165a474eb94658f6fc6", - "tabbable": null, - "tooltip": null, - "value": " 72/79 [00:00<00:00, 355.67it/s]" - } - }, - "7a29cd41f64543d18867f9502d4a962d": { + "797d8fb72ab043e4a8939caa006de9e2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26428,11 +26907,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7ac5a584492f495e974cf19baf7a1aeb": { + "798f0ea056f8403ca07fb0e4162571f8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -26448,17 +26927,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_3ef923e128e74249a7d86472b4cd4f04", + "layout": "IPY_MODEL_406927b85b3048159b0df61910f254b3", "max": 79.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_77e08403607348f9938f0d851c8d537e", + "style": "IPY_MODEL_db2b379d38a74a7996a712bb339ba6c4", "tabbable": null, "tooltip": null, "value": 79.0 } }, - "7b2ac3cba0ea4d568f5e253b0a5b955e": { + "79952c9a9ca64892b392cb29335ba17a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26511,48 +26990,49 @@ "width": null } }, - "7b747ac67ff84204a5c2350d8d444226": { + "79a40931a67a41399ce56fc2a2b7ac89": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "7b84cd45efd545269a100538c34053a1": { + "79db4b3171064ff3978cfe64d3d2fa37": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_5a8b523400a34072b4ae0e9563294207", - "placeholder": "​", - "style": "IPY_MODEL_226b394a4e034a7085a9f6305aa0e2dc", + "layout": "IPY_MODEL_188027fdf4ed4ef09dad099b06c01ae6", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_49d208dff05741d0a68402663c5aa060", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" + "value": 799.0 } }, - "7bb460b12a98451bb3dbb3b6d28548ee": { + "7a0d9f508cc64ea585f7b96d6cafdf7f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26605,31 +27085,60 @@ "width": null } }, - "7bc2fed1bee6438e920225161b18814e": { - "model_module": "@jupyter-widgets/controls", + "7a64f216006e44bc9f30528179470a56": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f16b839c197540b68f4a0909fc868037", - "IPY_MODEL_9556773e77fe4c63a47ff11b9883c366", - "IPY_MODEL_76d7332ffd45486faf2b251a563ff724" - ], - "layout": "IPY_MODEL_72e11d753a6d4b7c8d70e84694cae823", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "7c00d2df8ba842e7bd57cc122101387e": { + "7a829f82d7c1421cbb720a434f9151b5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26678,64 +27187,249 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "7c4ab050194a4c5388ddac084f35b483": { - "model_module": "@jupyter-widgets/base", + "7ab05e2a4cdd4bfd883167f38ef76a13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d2ddb887eed049ebb0ab1affe12ea42e", + "IPY_MODEL_8cbb58f7a5cc46e8b529786e5c447edd", + "IPY_MODEL_c4b6b898846b4fdbbdf55c1d23641015" + ], + "layout": "IPY_MODEL_46bf5dbb99ea494d8501a099615ef7a2", + "tabbable": null, + "tooltip": null + } + }, + "7ae345151c5a46afad1a453ade8be695": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2c4042132ebe4f18b90cc76d94ebb5d6", + "IPY_MODEL_fb1c7afda849493986881acee2b7fda7", + "IPY_MODEL_fa8d2922585e47989ae328b3db783c96" + ], + "layout": "IPY_MODEL_7de82fa1c1504f1d9164a8b8225badb1", + "tabbable": null, + "tooltip": null + } + }, + "7aee4d2038e5490bb8f45d3538ae1df1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7b6f284007e347749f3254cc1cd352e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7ebfa11b72e94f809cb4bdfc1841e2a7", + "placeholder": "​", + "style": "IPY_MODEL_d4a59925d41f4714afe016dec372cae4", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" + } + }, + "7b78816f860644e8b4460f40366e8b8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7b7cad16e2e24ecb8715a6d5b29eb469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d8c517392054f02957a8e34aa46ef46", + "placeholder": "​", + "style": "IPY_MODEL_c6f29e89b2e745199cd9425ebcbbe3cd", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  52%" + } + }, + "7b7d3016f75342c280b55daaa55796a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_df381c6c534249e0b0cc286ccfa871a9", + "placeholder": "​", + "style": "IPY_MODEL_f0312c9d3c4149bb89f8d2e02ad458cd", + "tabbable": null, + "tooltip": null, + "value": " 295/299 [00:00<00:00, 362.85it/s]" + } + }, + "7ba32272fc624659919e5f44086fe82e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_244d80f7d02b4ffabfbe6199ecb7f500", + "placeholder": "​", + "style": "IPY_MODEL_02f3a258b1134729b738ef9faa00f48b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "7bb3dd6db19a4f3ebfd541c7a1084565": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_879e145889dc4b978d8562faa92ec229", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_94558855c7724c06a1bab49b38b4df07", + "tabbable": null, + "tooltip": null, + "value": 69.0 + } + }, + "7bbec7ea432340de99f675f9d9c64d7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7c15bc4381674e079c404cc42c8c7b8f": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7c67bcdcdc9d46a2add5ed6fb6d1d760": { + "7c193ad6cd9c42d9befc3e39bb4745f9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26784,37 +27478,75 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7c9002d84e45477ea8410b43ca31a599": { + "7c2fd7cd242c45ec816277879529d441": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_35ff4862dad0431192a71f939e407761", - "max": 19.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_3433e75bb0a540d883d4c418b00b7eb4", + "layout": "IPY_MODEL_6d2bae6b665a48d4901b783a4c65ab30", + "placeholder": "​", + "style": "IPY_MODEL_317595359d6840338f3cae4eabb6a127", "tabbable": null, "tooltip": null, - "value": 19.0 + "value": " 72/89 [00:00<00:00, 358.01it/s]" + } + }, + "7c3959e149ab462ba6ea4f2630db92c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c31b7e861d8d434c942059cbc3aa8c46", + "placeholder": "​", + "style": "IPY_MODEL_7c15bc4381674e079c404cc42c8c7b8f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "7c3d29e225e24d408c436977640994a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7c90fc17341947eeabc79ee2cc52c82c": { + "7ceb7f50be444f489587261eccc85900": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26867,7 +27599,7 @@ "width": null } }, - "7c97f6da49da42e2841c10de0d670f26": { + "7d5ea3d0cbb34492b8f76b05274a8590": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -26885,30 +27617,33 @@ "text_color": null } }, - "7d46a86b30ac472e819e62c37d28735e": { + "7d7fbe0cffde42a08acfd14d5278929a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b064303dfefd4611a09a96fd21a6992d", - "placeholder": "​", - "style": "IPY_MODEL_1eef03ceabf1453ca62cc83a0cc21bd5", + "layout": "IPY_MODEL_c53b12a5e77e42fe9ecfceb69fd60ce3", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_947843a5d882496c8e34cc12356dafbe", "tabbable": null, "tooltip": null, - "value": " 73/99 [00:00<00:00, 359.53it/s]" + "value": 69.0 } }, - "7d7bce6493db49089fffafc473535096": { + "7de82fa1c1504f1d9164a8b8225badb1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -26957,29 +27692,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "7d917ed562794cc8ab9c188afa2a67cb": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7d969ae053bd4f6f941d7b78b6429da8": { + "7df84bda0ac74b1b8e9dd64bda80210d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27028,29 +27745,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7dc391b4eaf84a27b73ef0ec43783a73": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7dc6b4f355e1474799ad5666985523ca": { + "7e26015500fe4f5a82b07bcf92f328d1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27103,66 +27802,7 @@ "width": null } }, - "7e42c9deb4a04e2b8e5a2fac4026125d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_0f5169afe8414d4a8f7c9c1aac77f5dd", - "placeholder": "​", - "style": "IPY_MODEL_9896b94d5451419b9d5900bbd2417237", - "tabbable": null, - "tooltip": null, - "value": " 295/299 [00:00<00:00, 353.71it/s]" - } - }, - "7e4e24585c9349c498bbd58bbdcc7254": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e537cd48d2c4608af66f8b4fa8d0e62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7e60587e2bc741fcb53a6dc45634470c": { + "7e56697f340e4fa4bd204f3e7b3f8ff2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27211,27 +27851,29 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7e6680f705bb41a892ee641163892bb1": { + "7e70f9f1e75d4c58a80c10a4c08870d7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7e68d485ea5947429b58a31ce3fc975b": { + "7eb4a998e8fa48d696ee4de69e090856": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -27246,31 +27888,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c9353fd9741940e889fdf60256660075", + "layout": "IPY_MODEL_2440e333c75041c1b28a9ad90238cca4", "placeholder": "​", - "style": "IPY_MODEL_fb53cda1dcbb4485a5f473d418e06873", + "style": "IPY_MODEL_762ed4b07e8c4367bea77d1e57740c1d", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  61%" - } - }, - "7e98fef5de29464fbe91fc48112fafe6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": " 0/29 [00:00<?, ?it/s]" } }, - "7eb7be66cbf4447d89f755bfb089b7fc": { + "7ebfa11b72e94f809cb4bdfc1841e2a7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27319,11 +27945,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7ecea0052a7a423db97e345dbf84e1b0": { + "7f309413defb45bb966bf925a2d16ef4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27376,7 +28002,23 @@ "width": null } }, - "7edcd082516745a38fdae77e062f1046": { + "7fa232374d634f96b82babb9aa41da4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7fa96e9bc18a4cabbba007218253de43": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27429,25 +28071,7 @@ "width": null } }, - "7ee8719625d4475aa482c5280db4eeab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "7ee8a152f1f64b188e96971d435a98b3": { + "7fb78a276ec649c3ab4fb1157baa8da0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -27465,7 +28089,7 @@ "text_color": null } }, - "7f06dba9e4614c7fa0a1281402b452ce": { + "800500470f3a4bd9976b0a1605c64c78": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27514,11 +28138,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "7f3f013e4dc14d80a97c057101e02673": { + "800ad6baefba4d41a5d29048d1d3d9b9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -27533,15 +28157,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0e483bb542e74106a15fecceb78d8e19", + "layout": "IPY_MODEL_99bc652941124363a1eed2abebf849e5", "placeholder": "​", - "style": "IPY_MODEL_32703beeb6c245ebac7648b6f48b6b3a", + "style": "IPY_MODEL_6fe8246e8d594706b86c84d7a62ee7f5", "tabbable": null, "tooltip": null, - "value": " 184/199 [00:00<00:00, 364.24it/s]" + "value": " 72/89 [00:00<00:00, 255.20it/s]" } }, - "7f52da9b70204a2c964d3b7c9bb5f22c": { + "801ae2f2aeff464485df714ee32b091b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -27556,68 +28180,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_424ad561ee3b419db0c62ec97a88d8f7", + "layout": "IPY_MODEL_69a5808d20fa456988d9b6f59f947684", "placeholder": "​", - "style": "IPY_MODEL_b581ba9b94144c68ad527b841857aea1", + "style": "IPY_MODEL_33aeabc350da4651bec79df8ff64562f", "tabbable": null, "tooltip": null, - "value": " 184/199 [00:00<00:00, 361.34it/s]" - } - }, - "7f6f33376b1c49e788ac42fda6bdaed0": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "7fa4aebf91ec47cc946851ec20bb3700": { + "8058a1b3d13a4daeaee5357c6551e564": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -27632,173 +28203,169 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_108807822cd546bf8582c7b3ffaa5591", + "layout": "IPY_MODEL_fee27e89bf564c96af3e11528649ab64", "placeholder": "​", - "style": "IPY_MODEL_ce4f691af9a5482a85053f82ccc34097", + "style": "IPY_MODEL_ba7b5a0ba38340729c6800c495a82a7a", "tabbable": null, "tooltip": null, - "value": " 779/799 [00:02<00:00, 366.48it/s]" + "value": " 181/199 [00:00<00:00, 359.53it/s]" } }, - "7fb372d2c2ec46db80e769762abf4355": { - "model_module": "@jupyter-widgets/base", + "80653a42679243279810a4739f562709": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "7ff2061a53d64858a4966097763166cc": { - "model_module": "@jupyter-widgets/base", + "8077bde4ce534c39a5d0b2837d3e44d4": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "ProgressStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "80c480500d96438c87e22ff10b5b16e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8100c3c3f3e549d39c669afdf6656465": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8127c0f2b5a5487a95ab2e81eadb18d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_47966c62f9a0427ead6a81d32aef4ffb", + "placeholder": "​", + "style": "IPY_MODEL_b9216d527d68471a96f37c9fdf870402", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "813aede5e317485cb728287ec1b4ee6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5ee8f74d85d46fc83928cf15ec63619", + "IPY_MODEL_70cbcc2a16864e45ad9ea55fefb77f48", + "IPY_MODEL_6022557a45bb432aa79b3767d6cd46d8" + ], + "layout": "IPY_MODEL_955ec825d640487e846b7afc5a14bf01", + "tabbable": null, + "tooltip": null } }, - "801232451ebe4578b71c34528b8d964c": { + "81596e2291ac4d60bffed4acc03b4eec": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9408b864baaf4818a43ef0598306fdcd", - "max": 19.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_c44ee9e2b04a4fd4916ccfd57ce4c005", + "layout": "IPY_MODEL_2e2b910756ec4e7780d4c7a09d3c699c", + "placeholder": "​", + "style": "IPY_MODEL_ae796170aafb41ef9724a108bfbcdf14", "tabbable": null, "tooltip": null, - "value": 19.0 + "value": "Converting outputs to AnnotationStore.:  92%" } }, - "80322a1fd9f645e3aadaba8e90df699a": { + "81cc56809e4c4d918ac0364257a100fd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d200bdfc11a547a9b3f6b6bb42e203b1", - "max": 19.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_d0a6d8f78e6942078f7c54f5c1032dea", - "tabbable": null, - "tooltip": null, - "value": 19.0 + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "8034dffc34894238b3dec4bc38dd602c": { + "81da6dc3eb504ee29431dced068f667f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -27813,15 +28380,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_5c32c6d8cf9042eda7fc17cdb3ef62a3", + "layout": "IPY_MODEL_7965c2da37514e1b860aef0e35d81843", "placeholder": "​", - "style": "IPY_MODEL_e6fcb0ec556241c59d66ea22eff8e79d", + "style": "IPY_MODEL_80653a42679243279810a4739f562709", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" + "value": " 36/49 [00:00<00:00, 353.57it/s]" } }, - "80353b3841a949cbbc38cbe60c077b34": { + "8205d636cc4b4569beaf4119eaac714a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27870,64 +28437,29 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "8037175b913c4f648cafdf3e2b750b0f": { - "model_module": "@jupyter-widgets/base", + "822c77d06cb44f02b677facf061164ac": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "80ddd1f13b0240718cd9b6c4385d8651": { + "822d29863aa94c20ae900523f78273b2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -27980,7 +28512,7 @@ "width": null } }, - "80e99db76e4b45d395684a813a3e4d22": { + "825c17e5f75f469aa183d288ff12b41f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28033,7 +28565,7 @@ "width": null } }, - "8154d81442eb4d539c6f9ae3f50d134c": { + "828fae556e4a4ed1b464a3195cba6806": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28086,60 +28618,30 @@ "width": null } }, - "81b10617b323434fa5dd09739c4c4d61": { - "model_module": "@jupyter-widgets/base", + "82b1b162c473485c905ecddb8f3ba9a6": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e98c04a84dd2409bb998dafb2755c106", + "placeholder": "​", + "style": "IPY_MODEL_02427ba1c88340928ae2a9221dc3bf78", + "tabbable": null, + "tooltip": null, + "value": " 963/999 [00:02<00:00, 359.83it/s]" } }, - "81df698edc2c4823b2461273e8a11cf1": { + "82e9b6bc286a484fa5d09fc24ef653c1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -28155,58 +28657,43 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ac25dc86d6944604a7e82a5dde8e249e", - "max": 9.0, + "layout": "IPY_MODEL_3cdeacc78c024e93b82b64fade202e8e", + "max": 399.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_fd77ef4f213f4512b115fefe337a1d5f", + "style": "IPY_MODEL_6368753371f24353b2c70e7c3b70f350", "tabbable": null, "tooltip": null, - "value": 9.0 + "value": 399.0 } }, - "81f3e1633f0f4edc90a2916d81b9bb01": { + "82f323b0c4d8495bbe8ae0a81fe86e6f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_49f8c028aac745818f39efa25ae920b2", - "placeholder": "​", - "style": "IPY_MODEL_1f5389db68f140c5973775f895865a38", + "layout": "IPY_MODEL_3ba2b12f61484c80b4e340ec57482816", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5854d51b6471462c86ee1f2546501e4a", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" - } - }, - "820ddcf258474b2789909b69fedfde3b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": 9.0 } }, - "829902796e8447b6acf6ab15b5c29da8": { + "83bf380dc89945bdb86fd7e917d3f7c5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28259,83 +28746,51 @@ "width": null } }, - "82a647356d4e49f1a8e1b5406a0a5083": { + "83eca6f29d034bc0ba02a5efeaa0a0a9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_2a3a3aa6cd8c4030b0db46dbff2b0422", - "placeholder": "​", - "style": "IPY_MODEL_f3b1fddd95784c8e8d50ab319f0ba4e4", + "layout": "IPY_MODEL_35adcf7acf6d49dea6a705d97859cf37", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4093bcd4c7dd4e1a9e0bc440a932014e", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": 19.0 } }, - "82e2592a59b447fd83029863de4344a4": { - "model_module": "@jupyter-widgets/base", + "8405d160f8b74ad9a34d604323539872": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "830304cced404723afbaeb3a9c1ca6ba": { + "843d4058bb49470ab9604abbce518aea": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -28350,86 +28805,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c469f539c05241afaa7884fa3a7b7f60", + "layout": "IPY_MODEL_95851d1614524ee499bdfd925d3bc5d9", "placeholder": "​", - "style": "IPY_MODEL_e24ac04487814b3794160710ae12f57e", + "style": "IPY_MODEL_43e142d27a804525ac6025af8eb4167b", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  63%" - } - }, - "834d1ac7aa9140828523cd26219a2788": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "837ebb58052b4b5ca947beed81390d5a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": "Converting outputs to QuPath JSON.:  95%" } }, - "83c133914ba64a9d8b30afbf629912b9": { + "8450550fc6024610a6bc525fad7664d0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28482,64 +28866,7 @@ "width": null } }, - "83c763d3fb93490d984f60bd34f86485": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a2856414241546efa76c6089226d15cf", - "placeholder": "​", - "style": "IPY_MODEL_5ef16409e8e043c7858b926c93f14394", - "tabbable": null, - "tooltip": null, - "value": " 37/39 [00:00<00:00, 360.21it/s]" - } - }, - "83c7ad2db9f441ec97e8e2ea74cbba91": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8428758943004c549e3fc8419c1af086": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "8450f3c696e84e9bbbe7e90598139078": { + "84995f93cf78464a95c941fcdf734415": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -28555,40 +28882,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b7caebf7e06740b7a92a0441bd573cee", - "max": 19.0, + "layout": "IPY_MODEL_a0189c9fb18c4402923666cdd07a0095", + "max": 699.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_01364955bb824efb8419965b3dfd964d", - "tabbable": null, - "tooltip": null, - "value": 19.0 - } - }, - "846975ec6484423a83c9a2e462d7d933": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_23d38259eaad459380bc3c0f4040cec2", - "placeholder": "​", - "style": "IPY_MODEL_bb118a11d49d42ccb562978a4c384d2e", + "style": "IPY_MODEL_cece0c2c564b45c99a80874f42eb277a", "tabbable": null, "tooltip": null, - "value": " 36/59 [00:00<00:00, 355.43it/s]" + "value": 699.0 } }, - "846a4ca0e4b94aa2b72291e83e43d66a": { + "84a197ce9f1448f8a167692036264ff0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -28603,38 +28907,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_1dc5f7a42c654151b547c0c19fb8e969", + "layout": "IPY_MODEL_36bc4c06ad2a41488b65c86f172fd797", "placeholder": "​", - "style": "IPY_MODEL_10d96c31ac9040508c5e8a8efdf66596", + "style": "IPY_MODEL_c921c87c7bd443e5becb5d4c0dc16cba", "tabbable": null, "tooltip": null, - "value": " 590/599 [00:01<00:00, 364.00it/s]" + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "847dea10a3b24e3fb69fb7bc20600e97": { + "851ab66845154dd691d6ec663432077f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_22b46da5eaa648dd88272a46a47b45ae", - "placeholder": "​", - "style": "IPY_MODEL_cddcb3dbed6f4acabdf059adde3e8f58", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aaf496ae361a42b19fd29f4dd9e97cb9", + "IPY_MODEL_cb25640fd0154a4d827daec1dbf7ec27", + "IPY_MODEL_1557d81245854706ae3e7d470f0d33d1" + ], + "layout": "IPY_MODEL_05f173a45ab24d17b481680442e99912", "tabbable": null, - "tooltip": null, - "value": " 36/69 [00:00<00:00, 356.87it/s]" + "tooltip": null } }, - "84ac33aab3f241d1b6754c7ee4107e3f": { + "854ec3a8d681477bba97f3a245f61b66": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -28649,33 +28954,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_2c87e239c66c41b5ada589a29b583e6b", + "layout": "IPY_MODEL_0dd68639fb61466d8c4e4dd16f34d07c", "placeholder": "​", - "style": "IPY_MODEL_feb30733b37147bbab8f0a130c92bd05", + "style": "IPY_MODEL_12ae94c01a8d4871b23d5b6cba01d4e6", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" - } - }, - "8555452d88a24c1b83130071b4002e3d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 995/999 [00:02<00:00, 336.60it/s]" } }, - "8559cc625eef4b61b67169eb8b23cdbf": { + "8573f92cb07e4628a65c4bcac66b95b9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28728,7 +29015,46 @@ "width": null } }, - "85a29b2dd1634be7ad97027681f62fb0": { + "859646c302f64c5cb7fb6d9479b0f0e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86221ceb3bb143909d134730daa1f688": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4a38d27a221040da80dc660607276854", + "placeholder": "​", + "style": "IPY_MODEL_0b3645ef51674ceeb20cb60cfb3687c4", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  81%" + } + }, + "8662766e5e3f411e9c6e2ba4e37b4f78": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28777,11 +29103,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "85b2264e560f4dfaa64ee77e144a3d20": { + "866a90a0cf0c4e93a1928109d3ab9cde": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28830,11 +29156,66 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "85b94dcab7e342e1bae99ed7893d2f09": { + "86801af0b1724e8a99011d85936dd519": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "868a9a012091425bb57ca05d007774fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "868d200984f34b76bc3e2d7325f6f782": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_79952c9a9ca64892b392cb29335ba17a", + "placeholder": "​", + "style": "IPY_MODEL_f01005a3aff94d30b42e4f404f1eebd1", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.: 100%" + } + }, + "873ffd5da8b949738a6f6bc01a08964c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28883,11 +29264,29 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "85e2e887e88b4cfebb0f86edb7894d9b": { + "875174c479bb47f79e5cf2c7d6cc0835": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "875c68cbdfcc4f289ae2b40519388d4d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -28902,16 +29301,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e3bed6d60cf248a7b2113d6c27fb7e0f", - "IPY_MODEL_241c4bc13fed4998b5523c3305c8a032", - "IPY_MODEL_640aa044b6fc459899be2394f34c19c0" + "IPY_MODEL_be37ae18be2344cc8f772a2a021d5789", + "IPY_MODEL_c5d432a4377b4c0491e32157f5ede3cb", + "IPY_MODEL_d2b985e214fd43ed815e5c8e5fcbe54d" ], - "layout": "IPY_MODEL_bfc68748100d4a7ea463cc6f96ab8087", + "layout": "IPY_MODEL_99a0651c0e834c1d82f906131b355a32", "tabbable": null, "tooltip": null } }, - "85fb74ae8c21489198b8c41dd88ae229": { + "879e145889dc4b978d8562faa92ec229": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -28964,7 +29363,7 @@ "width": null } }, - "86179bf42ffd4e2fbcdb69876bf2430b": { + "87cbd710527241e9a11d41465c967c0b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29013,35 +29412,43 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "8618600335164da2b72cb3db70edf98c": { + "88a30f9aebb84b3fb04956d9a4ca4032": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_7b84cd45efd545269a100538c34053a1", - "IPY_MODEL_d0341cebf53b49658928e1655458a47a", - "IPY_MODEL_cd4ce0cefe9a40889d773a60ceb7f1fc" - ], - "layout": "IPY_MODEL_45ad0a69cdac48eebb2fe1b7fb7e0b71", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "897e4bd5aea343d8bd32f50f41889917": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "861fda405f12450ba53a25bfa6a8c240": { + "89b174b280b54c0496387e5f77a70aae": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29094,7 +29501,33 @@ "width": null } }, - "86b75f8cad5a46d7b97da5b62b2b89bb": { + "89cc589a882048f7bfdeae7711ded275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_14d7440977dd4a0a8f665aa4c814c013", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_033e9d6c632d49a89dfaab95604e100a", + "tabbable": null, + "tooltip": null, + "value": 299.0 + } + }, + "89d7a96904334316b82982840d76a401": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -29112,7 +29545,7 @@ "text_color": null } }, - "870ec753188f458a8fea1d2cf7cfc7f4": { + "89e0bbabedc847349b39bc75c88c9736": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29165,7 +29598,7 @@ "width": null } }, - "875113f8ea91403f82deffd8f48d689b": { + "8a1c97e6b1be41ed88ab99e243255ce7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -29183,7 +29616,7 @@ "text_color": null } }, - "876169a19ac84d64b4eaf6b05a42c538": { + "8a5f6b005cb1496b95a103356e3dc285": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29236,46 +29669,7 @@ "width": null } }, - "87c85f7b73e34cb2bdc10b8417ceba0e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "884d7c1a96864130809764bbd0083ee3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3c29b17a7070414e8ddec58e9700afad", - "placeholder": "​", - "style": "IPY_MODEL_4397aa33d8d94a79950ff8577dde46bf", - "tabbable": null, - "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" - } - }, - "88a1f1ef70e04a98b2ead0f5e45a18e8": { + "8a8e180fa3b34b89891ca51d5695aea6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29328,7 +29722,7 @@ "width": null } }, - "88e8abe3eca34410a1941bbc595713c6": { + "8aa5c35d34274ec887dc7cec48e11e23": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29377,11 +29771,70 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "890278b32a154b97894ee3a225e1c05f": { + "8aa98fcd15574e298f63640511291eef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8aedc79dce4e45da9ce07692a4a5cec8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8b075f11215b42339e9c86d708a021f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c37961812de6410f8f4d1aa6569133e8", + "placeholder": "​", + "style": "IPY_MODEL_97adc707997c4ce8974d921732d27441", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "8b55a273538645c4bdedb9d5a0faa07b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29434,7 +29887,33 @@ "width": null } }, - "890eaf610af7408c8137b6a626d6012f": { + "8bb8d988e8734e4c8d6b65a113db005e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_800500470f3a4bd9976b0a1605c64c78", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2bc60aaa3620476ea0f5690bb12dbee5", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "8bc431a1a85449eeae2b277fe85c7b22": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29487,25 +29966,108 @@ "width": null } }, - "8913ae8f453543f1b3fbf11078e24087": { + "8c00761acac24a84ac935fbb4403bb1e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_182311da489b4aeab46ef8374b1972cd", + "placeholder": "​", + "style": "IPY_MODEL_30ea34fec1184bf19aeae46cdffcca29", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "8c309bc857a1409f896ec3dc6a3988da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6a70333c3dcc49e588b2d7ca2fe69ccd", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1730ffb71cfa42f0a45291929d0e52f7", + "tabbable": null, + "tooltip": null, + "value": 599.0 + } + }, + "8cbb58f7a5cc46e8b529786e5c447edd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0643c852f8164b8a950b8438a28531bc", + "max": 799.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ad4aaf1410de4c19884a38a61cf2d918", + "tabbable": null, + "tooltip": null, + "value": 799.0 + } + }, + "8cc3d6685a8a4516b8bf1773001baae0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_922159f64fda4e7a87a28c6ed8949a68", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ebebef6d182b40998d4c8cb3482dad65", + "tabbable": null, + "tooltip": null, + "value": 599.0 } }, - "894a2956493e4c9d8223a99014b5ae4a": { + "8cd777158a9f4b80ac84da6c3ccd0f93": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -29523,7 +30085,7 @@ "text_color": null } }, - "897daa6ded384f73b2907776c86a1823": { + "8ce8f7bcbb054863b63a46a3cd231d0a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -29538,166 +30100,115 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_3a39e2f5dbab451e95d8290ef656261f", - "IPY_MODEL_37d7a6888567468bad32bb5eeeb65d68", - "IPY_MODEL_846a4ca0e4b94aa2b72291e83e43d66a" + "IPY_MODEL_eee4f68d4cec4ab99fee05e5a9ecf34a", + "IPY_MODEL_9a9fa94f32a5456d94ee2aa5b5550546", + "IPY_MODEL_9b1b7233ba0c41be86c6e4acbd882349" ], - "layout": "IPY_MODEL_e99de2c5cff54076b8f33791a6e0b19c", + "layout": "IPY_MODEL_274d5383ac43426bb2a3ad46a6143774", "tabbable": null, "tooltip": null } }, - "89c1205e28c94a9fbbc1e67a716a2aa2": { + "8cf2b527f4b5458c95a9ebc0c115cdd4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_40a68014923346b596b67ac0a4a193f4", - "IPY_MODEL_60de004e799749fab0fbfc4787f44ca2", - "IPY_MODEL_c803853185e04f32b8898930aed802a0" - ], - "layout": "IPY_MODEL_936ae29026c648c4829f91a3a5da492e", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "89c15203ace248d1a02a02594b023db4": { + "8d547599e9e1444fa43ffd89d8db9450": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_5fdee5efd1e149aca7df20d34599cfb4", - "max": 59.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_6c637650a170405ebdf9b07b83ac83bb", + "layout": "IPY_MODEL_7909d6ca3f5944a9bf46cf8319aa6da9", + "placeholder": "​", + "style": "IPY_MODEL_32aa36340c2241b590dc3693552d1319", "tabbable": null, "tooltip": null, - "value": 59.0 + "value": " 36/69 [00:00<00:00, 354.22it/s]" } }, - "89ea9978425b4528b483a06a93762e8b": { - "model_module": "@jupyter-widgets/base", + "8d55a1ae6fbc4bfab18d5625be079373": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "ProgressStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "8a18ffdbb37642bba04ea599e5538b68": { + "8d650c457b4d42048adda9a925a2e97c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f6b6db4ea31f43b58e492efff1cec142", - "IPY_MODEL_2ea4afc14a0046d198c3a249246a0246", - "IPY_MODEL_47c365b75b674b73aa3e5ec64a4dcaaa" - ], - "layout": "IPY_MODEL_1d7d48573d2544f898b30176610f737f", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "8a50b8decf89476dacacb5953b63da39": { + "8d8a81ffd06a4e26a6526391c8e75466": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c435008f3f544ad2b2494ea4170ff841", - "placeholder": "​", - "style": "IPY_MODEL_b85b758d39c247b9b76d9f25c11b1f66", + "layout": "IPY_MODEL_40622752c6ce4805b010ef38c70ac776", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3620d2774665429a9fa8a6b510f7c6c2", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  95%" + "value": 299.0 } }, - "8a8a5222321946e38de69b513db84a8e": { + "8d8d4a581f804131ac5851cbceb23f09": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -29715,7 +30226,7 @@ "text_color": null } }, - "8ab9fcd143bf46919318a3bb77aa3e1c": { + "8dcf181c55b7482f8ee16666dc8b8676": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29764,11 +30275,60 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "8abc7f6b14c64c9ab6f07badd64512a0": { + "8e8859e575224fa8b8c7b6dbc23bc628": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_48c392144bb8446eb9ae1cb4a34fef3f", + "placeholder": "​", + "style": "IPY_MODEL_c045b41eda0c46abbd020a9e64f17aef", + "tabbable": null, + "tooltip": null, + "value": " 73/79 [00:00<00:00, 356.01it/s]" + } + }, + "8f0f556f01794e1eb87769c2fd1213e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f2d74cb76e534abc949498140ab6f14f", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_1202fd5ef10741d4930d50263089b513", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "8f4e91bbf0bb4777ab17b2e196806154": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29821,7 +30381,7 @@ "width": null } }, - "8adda907b62942fda7c7558e4baf9a94": { + "8fa39122b79f4c2ab144890149bac228": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -29836,68 +30396,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_1a8ca8069f06429e901b97416032595b", + "layout": "IPY_MODEL_6dc8bde88e28418d986b723dd962e76f", "placeholder": "​", - "style": "IPY_MODEL_f93db39f5b0446a78c10220f2692d6ee", + "style": "IPY_MODEL_78b3e207ee2045ea9510bba15b2873b5", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  73%" + "value": " 36/39 [00:00<00:00, 355.00it/s]" } }, - "8ae5a42f72d9481d9e484419eaf858df": { - "model_module": "@jupyter-widgets/base", + "9002601ca82340cd832f6c7b0117e3c5": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "8b28cd8da30042dd967bf6d6251cd42e": { + "900cef3116ac40dbab13f4199ecda0ec": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -29946,11 +30471,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "8b8d9060127e4c3e8087e7c0079d42d7": { + "90df3d1f323346d6bf071601bd83e2e5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -29965,33 +30490,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_01276c00429544beacdb0a66b06f7676", + "layout": "IPY_MODEL_aa996145d23f451586abe23a75e1c846", "placeholder": "​", - "style": "IPY_MODEL_0d9da7bf768a43f7ad3e279838a2bfce", + "style": "IPY_MODEL_cb877600828f4dd5ab04c06420361ef1", "tabbable": null, "tooltip": null, - "value": " 73/99 [00:00<00:00, 360.88it/s]" - } - }, - "8b95af3fe6ec49b6a2f3d7edfd4172a5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 591/599 [00:01<00:00, 364.50it/s]" } }, - "8bbe0e3bc2bc4d59bd35c50e1ad706f0": { + "91a21eef705d4fd2b428e47ea6a31022": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -30009,7 +30516,7 @@ "text_color": null } }, - "8bce25e51a4f433faf80447c79476251": { + "91aaba070560491e88986044a99ee9cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -30024,33 +30531,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_74526b09aae44f80b5578703630e8478", + "layout": "IPY_MODEL_de5677865f72474f8ac090ffe895ed78", "placeholder": "​", - "style": "IPY_MODEL_242e890a22f547c88a91c5ce4029d7a2", + "style": "IPY_MODEL_3fc42343701e4e0eae1c80b9f981ded0", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  73%" - } - }, - "8c0be0ea0e614e60be0712b34b142bd8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": "Converting outputs to AnnotationStore.:  96%" } }, - "8c149e832c2344a6a13d48e6ca6fba0c": { + "922159f64fda4e7a87a28c6ed8949a68": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30103,31 +30592,30 @@ "width": null } }, - "8c34e8f0b5774faca5891cd7a6239b88": { + "9229831101224676a7dbea9ee203b3ef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b007ff62602a4a2d876b1efe3afd3673", - "IPY_MODEL_81df698edc2c4823b2461273e8a11cf1", - "IPY_MODEL_bfe66051460d4067b93fc18294eb6d9d" - ], - "layout": "IPY_MODEL_7e60587e2bc741fcb53a6dc45634470c", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f065899c862944ddb82bc77b3352c825", + "placeholder": "​", + "style": "IPY_MODEL_5a434a2eae7641ed849fa331173444e6", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "8c3bc90181324aae887c0903fe049539": { + "9231cb74058044aa96c81eb63b651ac2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -30143,75 +30631,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_484eb3d61373421481e5e7cc01b38b03", - "max": 29.0, + "layout": "IPY_MODEL_0b13a5d3a66f497a8f64b903a3d6dcf1", + "max": 699.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_efd8dadbee4b4526a15eaea1489d3dca", + "style": "IPY_MODEL_68bef75b3c654d27bc2c65bc0a29d940", "tabbable": null, "tooltip": null, - "value": 29.0 - } - }, - "8c5a8111755e4b539ef3fd3c91590b87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_1f5b3ccaf27a481d8288195af1ec372f", - "IPY_MODEL_d0f8a3ab51954f1391a21336ef2ed4e3", - "IPY_MODEL_97628bce7bd9417a9ec12c82bdbea666" - ], - "layout": "IPY_MODEL_b645e5a2abfe49fe96ce6bb537d91029", - "tabbable": null, - "tooltip": null - } - }, - "8c71d8800d2440a78faae5237b85fda1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8c837adf34524549b4fd3ec0c3a4d530": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 699.0 } }, - "8cb772963b0d4f9b97d1b497b81e5787": { + "9236d754207b4335a55419b9843478a5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30264,7 +30694,7 @@ "width": null } }, - "8d04f608e3b7419199e4900abbb061bb": { + "9252c0846a074377b50045e8bf787f39": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -30280,40 +30710,93 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_da1789b52e594f8bad8427cd64a63db9", - "max": 49.0, + "layout": "IPY_MODEL_32a71e4cc23c4214b4936dc058f957c4", + "max": 599.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_3e977a3b67614cfca6d57b2f08f7f3c2", + "style": "IPY_MODEL_47ecda5260d64c2db5b6eb2e88d3d5cb", "tabbable": null, "tooltip": null, - "value": 49.0 + "value": 599.0 } }, - "8d3a2ef735174a10bee2b092d744275e": { + "9268c7d1802d4930b5dcd10c57e99466": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "92c59c6ccfbe445392b1c5134017e1f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "93205096546342df899e6bd0dd1ae80d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_92d9178b9a524148bc2fd57aff6dbbb9", - "placeholder": "​", - "style": "IPY_MODEL_2f2549fe184843d3a55c2bdf93bdc1b6", + "layout": "IPY_MODEL_5f7100c8becf41f7ba530467ce4dbd5d", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6603f689299e476cb632d4be04ef0141", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  51%" + "value": 399.0 + } + }, + "9352b342bdac447181d442f9d6721d34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "8d75ea1674e44d96af14247550d590cf": { + "936410a4ed2d41dc880a8d9284a6c7fd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30366,114 +30849,7 @@ "width": null } }, - "8dd11c0ad50b40f4b046b2dc9192f1a4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0b3333a3f2d242eeab9043467a135115", - "IPY_MODEL_66d4058fafd64f4f950379b55767810f", - "IPY_MODEL_632e3f3f886642ce9963971e663ea7d8" - ], - "layout": "IPY_MODEL_272c6e13d6bf4f6d91e775b05ba90942", - "tabbable": null, - "tooltip": null - } - }, - "8e26c83d6073406a852eac2034d65be6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8e644957f81047b8add0fc659615700e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5cb086b732d34ff49205154cd69967d6", - "placeholder": "​", - "style": "IPY_MODEL_ad5b8dd38022462396e962705dd1e98d", - "tabbable": null, - "tooltip": null, - "value": " 885/899 [00:02<00:00, 363.23it/s]" - } - }, - "8e8f1de56f6647fbb3b5e7b86bf0a295": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "8ef6227139994ec2b5879afe2a1294e7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_31ef47419b114e8e9cf1e4b2bb499aed", - "IPY_MODEL_d0a9f7554f944deebad0e0f494e0b340", - "IPY_MODEL_1f92f0e2d4ca49c58361bab50d093a43" - ], - "layout": "IPY_MODEL_4ce4d1cb1d5040458b65d731b611043a", - "tabbable": null, - "tooltip": null - } - }, - "9045bf1e1a564f2c98790e37e57fdd70": { + "9366946ef7e14c51ba46def7c98e074d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30519,53 +30895,14 @@ "object_position": null, "order": null, "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "905333b503af4652a03ec8ce2d49e7d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9068eeed80a84a5e993cde7355727880": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_77caf9bc83a4425eb8a2307926eeb99c", - "placeholder": "​", - "style": "IPY_MODEL_932453791cb642afb3696fe3f0e4b006", - "tabbable": null, - "tooltip": null, - "value": " 73/99 [00:00<00:00, 363.28it/s]" + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "90afbda5a11b422bbb56317ebe3d3079": { + "93dd196c9e1d445ab8ab0de1102fc6fe": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30618,33 +30955,25 @@ "width": null } }, - "90bd6562f6b74386ac396b89f73f4429": { + "940b71325dd74ef1a6ce72503443b3be": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_04989c6b1d6d487786b5cc6185bbe9f3", - "max": 69.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_5b98aa6d7b56442db773d661d1569276", - "tabbable": null, - "tooltip": null, - "value": 69.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "90be65850b384b7ea507a284a2978b86": { + "9411cd45d672462f9e65c3c6316c61ab": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30697,31 +31026,7 @@ "width": null } }, - "90bf76864db94a7b94fc22af8067ae8e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e38c530f121746cb8a0bff30f7eff6e4", - "IPY_MODEL_0bc9005f8c1c4516afe4fa8b208fb1eb", - "IPY_MODEL_d6327d5992a946208d63034400da112d" - ], - "layout": "IPY_MODEL_52a1c2c1ea774909bcde9522ae401efb", - "tabbable": null, - "tooltip": null - } - }, - "90d8fb3e006047c7ad1f67747bc12d8e": { + "944a3d36f7aa4379b2a983bc7ac55016": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30774,43 +31079,23 @@ "width": null } }, - "90dbd87ef8644cb6ad32b3cc8e1955b2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "90e083fd95754dbca7d6f77d89a8aac9": { + "94558855c7724c06a1bab49b38b4df07": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "91ce479998ce4fc3915fa56338763eae": { + "94681603c5d04894874724741aaa33bc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30859,11 +31144,53 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "91ff649d1d1840c18123da3d8b384fb6": { + "947843a5d882496c8e34cc12356dafbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "94bf5dfb8af74d4daa2c9bee5d7c3d5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6f692c43749f4f899eac406bc3132a1d", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_be500d18fc1f4bfa8a572fb137967f31", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "94d3ef450eb546e1a20802055ca484a4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -30878,15 +31205,75 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b773b548738b4088aa5fa5cb905b3583", + "layout": "IPY_MODEL_a81df8077add49b1b70ef2655c07c4e7", "placeholder": "​", - "style": "IPY_MODEL_66a0d901d13d43acbb00cc373f5a1712", + "style": "IPY_MODEL_3b272a1d7e334f4188d3358c3347ea0a", "tabbable": null, "tooltip": null, - "value": " 592/599 [00:01<00:00, 364.18it/s]" + "value": " 775/799 [00:02<00:00, 361.28it/s]" + } + }, + "9535f31594da4ab3b63a4833791fd08d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "95398bb076a1440cae2c3217a3b56c95": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9542360425234377a470cf10f3b02b36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_584e89b065ce458fa98822891356173f", + "IPY_MODEL_e2f6700c2eb14a6fbdae9951720a03e1", + "IPY_MODEL_680bb1809d75429b864a887ac5295f87" + ], + "layout": "IPY_MODEL_e517229c687345eebf8e21929bf28940", + "tabbable": null, + "tooltip": null } }, - "923a8f8e39e944b28f48d80793a06540": { + "955ec825d640487e846b7afc5a14bf01": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30939,7 +31326,7 @@ "width": null } }, - "92d9178b9a524148bc2fd57aff6dbbb9": { + "95851d1614524ee499bdfd925d3bc5d9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -30992,7 +31379,25 @@ "width": null } }, - "92dde195120c458e9d2c1aa2049fdaad": { + "95e384cd1d254baeb3afbcef94dce794": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "95eeaf0ccae44001b3c0d3fd04e753d3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31041,11 +31446,45 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "93182494b09f422e987faef2c4484f13": { + "9622fa15bcf74c7c9643f29b64c6ebd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9651d16bc4d94fe3b691d21de516b98a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9676ed1964754239a89e1d2fa069d79a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31094,11 +31533,47 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "932453791cb642afb3696fe3f0e4b006": { + "9679d122977449e89c61e767f362be84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "96838a1e0d924d60932338d8c3b54981": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9696fb40fe7c4862b76e8a98998984b1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -31116,7 +31591,54 @@ "text_color": null } }, - "936ae29026c648c4829f91a3a5da492e": { + "96b70992ca594ea3a9b72e3c98a47a42": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e3cda54caf9048408cb11ad5e3c6b19c", + "IPY_MODEL_c8d288224f454e9db253a567893fe151", + "IPY_MODEL_1c05050d1bc64b3a96c8e0270d11911c" + ], + "layout": "IPY_MODEL_67d4602d36d5415e9618ca500f54744b", + "tabbable": null, + "tooltip": null + } + }, + "96d4ed7b866a43998b0fba08c9272608": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_66ebc0ee6f6f4facad2e53077e32c199", + "placeholder": "​", + "style": "IPY_MODEL_df68ed583e76420e9be461973fa1a024", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.: 100%" + } + }, + "96d772ab6af6456cafc8478adbb51fc5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31169,46 +31691,7 @@ "width": null } }, - "93d4bffa867445508dfeb08eb7cddac1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "93d68c4c299f4422acdc5a59e02b2a0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_dab13f6588d94e1ea06facae48a345a6", - "placeholder": "​", - "style": "IPY_MODEL_b24a0b8a75424936bebf06a5cd6a54be", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" - } - }, - "9404db936ef347d19c7938726480dab1": { + "9729768eb1444460bec18b68f8f70ff0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31257,11 +31740,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "9408b864baaf4818a43ef0598306fdcd": { + "9759a4eac7dc4873ac30d755c457544a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31310,11 +31793,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "94a88227eb484887a751d951a09a7dca": { + "9773198c89ef4a28b968888b6b2e380b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31363,34 +31846,45 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "952c36ed6d154fd9bc2778f7d7a157a1": { + "97adc707997c4ce8974d921732d27441": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1349031413004abd8f5755f9de81d47c", - "placeholder": "​", - "style": "IPY_MODEL_2db019ca42504212a3233c8e22ba73fc", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  74%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "9538d61e6b184a778e6385a5b7c98257": { + "97ed54b6cbb34c45bdb68c20962da6a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9827aebad82d48bd8b8b880e277572fe": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -31405,117 +31899,156 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_794891c9744b49379f3238ab072dac41", + "layout": "IPY_MODEL_cc27f756a8e34122a05dd186ee8f17b4", "placeholder": "​", - "style": "IPY_MODEL_12fe1abb25ea47dd9478f195b718974d", + "style": "IPY_MODEL_9535f31594da4ab3b63a4833791fd08d", "tabbable": null, "tooltip": null, - "value": " 587/599 [00:01<00:00, 359.48it/s]" + "value": " 474/499 [00:01<00:00, 360.32it/s]" } }, - "9556773e77fe4c63a47ff11b9883c366": { + "982a7911c5c04321a7c403bb3a7b9f96": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "988ad3fd739e4c34ab91bdacc6268a99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_467f22de5d254df5b5f472b9189b246f", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_4f210a78887a49fdb4e21d136094f12b", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a4308b23f79c46d9baa44c7e1d3d8876", + "IPY_MODEL_8c309bc857a1409f896ec3dc6a3988da", + "IPY_MODEL_14b540bbd78845488fdca7e097b222b5" + ], + "layout": "IPY_MODEL_13c1e395326b4b698d4f4b465da7c537", "tabbable": null, - "tooltip": null, - "value": 49.0 + "tooltip": null } }, - "96710220aae5465183fb43b5fe5b265e": { + "98bdd8aeda3e426bbdd7d1b9093fbdc1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "98c6ea1e637a4ffdae72eb035046ca77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "98cabba1994245fa8898c1621e7d6472": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3ae9adb1174549d4ba0765594c21ef94", - "placeholder": "​", - "style": "IPY_MODEL_53f6cf534d854995b66a138d82f38f05", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ea70cd5b26e54df29b9a55e658a69e93", + "IPY_MODEL_73e09763d0a94859a5156960d0be26eb", + "IPY_MODEL_82b1b162c473485c905ecddb8f3ba9a6" + ], + "layout": "IPY_MODEL_99c5135e1cdc41999f6e9f56132ac0a0", "tabbable": null, - "tooltip": null, - "value": " 36/59 [00:00<00:00, 358.45it/s]" + "tooltip": null } }, - "96831a1dc2604a4aa68fd22e2ae3678b": { - "model_module": "@jupyter-widgets/base", + "99016dbb40fd40a89cb69604e5c18987": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "991ee200fcd342c3b1feccbd99b7b3bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_529b1ec4105944cc99989d87eb5a16d2", + "placeholder": "​", + "style": "IPY_MODEL_822c77d06cb44f02b677facf061164ac", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 358.30it/s]" } }, - "96837fd03fbf417bb0fc348dde7d1451": { + "9950f5a5e80f4d6eb753c7a7551852d0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -31533,7 +32066,7 @@ "text_color": null } }, - "96b58127d2384a8eb80a48c4250a3a29": { + "9984f32d9dd64aec962488033710b053": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31586,7 +32119,25 @@ "width": null } }, - "9706dc5644ff4d2aba97ca170e545439": { + "9989c56958fd4d68b5be367443a45d6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "99a0651c0e834c1d82f906131b355a32": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31635,57 +32186,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "97628bce7bd9417a9ec12c82bdbea666": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_08a4c1252645469aab123b139f486913", - "placeholder": "​", - "style": "IPY_MODEL_20c44e454ad94ca4b1ace2b8df13277f", - "tabbable": null, - "tooltip": null, - "value": " 73/79 [00:00<00:00, 363.07it/s]" - } - }, - "977a91b067e24994a38c9c3890cab2cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d7b5bc789ea846109c2966954f666e5c", - "placeholder": "​", - "style": "IPY_MODEL_73587d88a7244b6bbb8e239ac3e479e4", - "tabbable": null, - "tooltip": null, - "value": " 482/499 [00:01<00:00, 364.77it/s]" - } - }, - "9788a286e84a4450acdeaf4a5ff306b6": { + "99a080898a97498e97dae48489894b53": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -31700,15 +32205,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ba78799094b347d78d70dbcd8fee7d85", + "layout": "IPY_MODEL_de180b912fe24f76a078b152855b9abe", "placeholder": "​", - "style": "IPY_MODEL_64328995eddd4d0b9edbe66b85afcb25", + "style": "IPY_MODEL_1988658a4be743acae0c7010c4ccb6b9", "tabbable": null, "tooltip": null, - "value": " 894/899 [00:02<00:00, 367.36it/s]" + "value": " 887/899 [00:02<00:00, 358.81it/s]" } }, - "978a701e7e5b42f78ad268e2ea7e3e36": { + "99bc652941124363a1eed2abebf849e5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31757,11 +32262,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "97b2f9188b224719a6a73a98964a6c31": { + "99c5135e1cdc41999f6e9f56132ac0a0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -31810,61 +32315,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "97b8cfee6364472aa65403ca8a153f9f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9896b94d5451419b9d5900bbd2417237": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "98eb1189f08a4fd0a1ca39dd50787b21": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "98f250094b874a2781e0ebe476b27b85": { + "99e7b7a6cfb14213932fd95633a1a66c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -31879,15 +32334,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0bcedd3d0a1647868942cd10b21bdc7a", + "layout": "IPY_MODEL_fa59a1d541c2405284c7296537655c5d", "placeholder": "​", - "style": "IPY_MODEL_367fc8903c0647f88f4a2d046b19d517", + "style": "IPY_MODEL_1a42b6e31ef940d6af68a8240c3ecadc", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" + "value": "Converting outputs to AnnotationStore.:  98%" } }, - "994772e07dd54886860bd3ff52f44310": { + "99ecdb24af234e8793f4937602f3665c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -31903,60 +32358,7 @@ "description_width": "" } }, - "9994d11815364fe0a205a24457276f26": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9a093f90a30e409cbe3152a63c84fc3b": { + "9a819b15c93f48f1ace585cd53454e4d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -31971,15 +32373,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c01615d310244dc793bf18a43f795ea1", + "layout": "IPY_MODEL_4f6c9974b1bc4cc0b386aace834b9fbc", "placeholder": "​", - "style": "IPY_MODEL_db9eb05a179a4dc5bf699ba7982c2815", + "style": "IPY_MODEL_67f6d304a779470da994d819a825d1e9", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" + "value": "Converting outputs to QuPath JSON.:  61%" } }, - "9a5b64d269de4e92b26f073ad1b9fbca": { + "9a862b46ccd640bf8256c253221cfda2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32032,31 +32434,7 @@ "width": null } }, - "9a7df1ecff3049c494786d0df894f99c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_13f0f814d19d4c7eb8c2a28a50175477", - "IPY_MODEL_33ae1b4cc09c4b64a69ea6923a1e5cdb", - "IPY_MODEL_a3ebc9da861e4af3bce977449342ab1d" - ], - "layout": "IPY_MODEL_a63c9f8d6d7045919becc483c1dae9b8", - "tabbable": null, - "tooltip": null - } - }, - "9a96669e38c449f698334512a42575d4": { + "9a9fa94f32a5456d94ee2aa5b5550546": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -32072,33 +32450,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_09d89a1d3bb64595a47d85dfecf2fe5e", - "max": 399.0, + "layout": "IPY_MODEL_1c89e4f87a5b4c1f8bf5d5e6f2dbd31a", + "max": 19.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_551aca7081014f0181381105695a83d4", + "style": "IPY_MODEL_04bbb697ff2a46c299d60c00158249e0", "tabbable": null, "tooltip": null, - "value": 399.0 - } - }, - "9aa3085b168c4a199a60a78c0d67dda4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 19.0 } }, - "9ad7aafb378f449f8cf7293f196a5510": { + "9ad24b54d98d4b4ca0783f6464a37307": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32151,60 +32513,25 @@ "width": null } }, - "9b12610ec0dd453a80680804659a950f": { - "model_module": "@jupyter-widgets/base", + "9aeb3efbdaa24aadb2577b5738df3118": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "9b1e34eb82bb4740b46ba721b4da8101": { + "9afb98d7126747b5b80672d25bf0893c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32253,37 +32580,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "9b6c83606a7c4d85a8c9b22505d783e1": { + "9b1b7233ba0c41be86c6e4acbd882349": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_00c2ce8137c8400d8a248a035dec5b14", - "max": 69.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_deae5739c6514cabad9f0e09b6584099", + "layout": "IPY_MODEL_bcc01b81545c4b4fb6ad752979a00053", + "placeholder": "​", + "style": "IPY_MODEL_45575c5868ea4ed2955c02f24b57dceb", "tabbable": null, "tooltip": null, - "value": 69.0 + "value": " 0/19 [00:00<?, ?it/s]" } }, - "9b6cf4af509b4bebbc25c8e5cd713190": { + "9b206ad6aaec4773b8b3a8388d67c323": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32332,11 +32656,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "9ba4c18dcdfc4ed092d98d9596488a6e": { + "9b23c6d7cc324d56a100a882f6266c82": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32385,35 +32709,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "9bc6ebd59e4f4005a21c9446fdccd958": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f4a024683a44416e984e25d202634705", - "IPY_MODEL_801232451ebe4578b71c34528b8d964c", - "IPY_MODEL_c34f858766a54c92be832fc10138950f" - ], - "layout": "IPY_MODEL_cc7500408b274601a1c97553d24c9900", - "tabbable": null, - "tooltip": null - } - }, - "9bdf6403cdd644e981afee06da78ef12": { + "9b3145839b5740b9b6c3805c2e1f588f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32466,7 +32766,7 @@ "width": null } }, - "9c081ca24bd74659a65bb864ad786a9f": { + "9b5aedfc554849d5a60bf07d7c402c66": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -32481,16 +32781,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_cac5a08da220495296d54d267dc6e766", - "IPY_MODEL_4465fe99e1114f66a001c2770fc06b22", - "IPY_MODEL_e217203ba78544ad9e74b8ef8a85b907" + "IPY_MODEL_d3f2c6a8fc8e4a10acb082c97ab84d2f", + "IPY_MODEL_233985b5ee4d4e259db25ea8b2965a79", + "IPY_MODEL_6047b24816e74fe68f408dd740ee8bb6" ], - "layout": "IPY_MODEL_183774794cb14f0e83961426f95f60be", + "layout": "IPY_MODEL_650c7e7e1b4749e983db4e2c41231969", "tabbable": null, "tooltip": null } }, - "9c17bfe97cc9428d86e3d378eee8b5d3": { + "9b614784a2f74e4bbbd19dfc35699f27": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -32505,137 +32805,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_aa687bd844e94b2d9e9eeb0b143582d1", + "layout": "IPY_MODEL_bc052344e9ed494db4c6f86527c86ea2", "placeholder": "​", - "style": "IPY_MODEL_9e1577f43049420cb456edb60bcef748", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" - } - }, - "9c49f5baec4442f89e280a9601e77095": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9c4a8b5471fb4b2baedb1b273d9434d1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_033245f09b9b44d89d4679e28ace6ef2", - "max": 9.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ef552844b99341d79625224f4bd6e572", - "tabbable": null, - "tooltip": null, - "value": 9.0 - } - }, - "9c6f49d105f14d058f4d932bcc35b4f7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "9c73221770084648ab4a5ec0804196a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "9c8f38be56c64ae4b038567f96db6500": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_870ec753188f458a8fea1d2cf7cfc7f4", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_9f988a48438441588eed8c5dbc246898", + "style": "IPY_MODEL_9989c56958fd4d68b5be367443a45d6f", "tabbable": null, "tooltip": null, - "value": 899.0 - } - }, - "9c9f3b931b564870a41e892f72f302f3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 36/59 [00:00<00:00, 350.44it/s]" } }, - "9cc5dae3a64c4eadbb102b500f243165": { + "9c0e7ff131724b9ab99421ec5b86189f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32688,129 +32866,49 @@ "width": null } }, - "9cd1c8f5093d4cf88234a53abb8aa455": { + "9c5e42d53769443a8ba2f3b9d9679181": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1bed2502aa8c4773b2b33950356f8124", - "placeholder": "​", - "style": "IPY_MODEL_5e85fe84118c4f54a26cf2500c6af9a1", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  74%" - } - }, - "9cdf78cc7bd642e0b9d7982209392e22": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "9d1b19421f184307b1b8d776ef202cf6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_90d8fb3e006047c7ad1f67747bc12d8e", - "placeholder": "​", - "style": "IPY_MODEL_2f443fe263424ffba5ee02553a353f13", - "tabbable": null, - "tooltip": null, - "value": " 37/59 [00:00<00:00, 364.00it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "9d4c58a0443e4f488e244a5ef5648f3c": { + "9c74ee67c9d044919ab99eee70edbbfe": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_e2a7e797571a442aa6856ae6fae6e8c6", - "placeholder": "​", - "style": "IPY_MODEL_29ed50dabf784806aad2fe583689beaf", + "layout": "IPY_MODEL_50d86d5c91b340d49cbc965b0f34f11d", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9c5e42d53769443a8ba2f3b9d9679181", "tabbable": null, "tooltip": null, - "value": " 73/89 [00:00<00:00, 361.77it/s]" + "value": 199.0 } }, - "9d6ddcb3aa0c486983263fe5b2c7cc37": { + "9cab60c6300b46c4a3e94f2258ee54f9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32863,7 +32961,7 @@ "width": null } }, - "9da369ada4dc421f8645b288fa83aa94": { + "9cc272d377ce408ea3031d099f2a28eb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -32878,15 +32976,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_e5404053ec2a45bc9ccaf5b92e178632", + "layout": "IPY_MODEL_33192a22bcef471db8f96fe4b26c47bd", "placeholder": "​", - "style": "IPY_MODEL_1210f02976414c3789c0b00cbe9ff17d", + "style": "IPY_MODEL_2cd3ec7ecf5e4e54a8c3b766efd4d32d", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "value": " 183/199 [00:00<00:00, 363.99it/s]" } }, - "9ddcf80b54c448659d40eb246408ce2a": { + "9d92573db7f74978aeff421e3a2205ed": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -32939,25 +33037,46 @@ "width": null } }, - "9e1577f43049420cb456edb60bcef748": { + "9dd43b56b85d4581873c1376cdf6cbd4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8e922f3f5b641c8bce261d1b6062231", + "placeholder": "​", + "style": "IPY_MODEL_c1a27d0687da4883bec110becf0d1f52", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  91%" + } + }, + "9dee15171132423785e164874c7ef163": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "9e23e688de2c4c849d2c4bb43bec6f1c": { + "9dfde71c2f964bd2aba42d0cbe3e422f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33006,11 +33125,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "9ea39809e1ef4d01adf80f76422ba7d0": { + "9e03ee6506ee4c4db8f1897fbe116601": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_796bc589404642bb951496bd95004ee1", + "placeholder": "​", + "style": "IPY_MODEL_5995d5053ad542c8ae8563a31bf0f18b", + "tabbable": null, + "tooltip": null, + "value": " 589/599 [00:01<00:00, 360.84it/s]" + } + }, + "9e22136d18e448ebb8b804a6439b5fe2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33063,7 +33205,7 @@ "width": null } }, - "9eee605f30bc412aa48d9ff2fe8683ca": { + "9e6b5a443dea4b588cd7fb348154d4c4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -33078,16 +33220,60 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e5abefda2b3f4d6098a926782d4fa807", - "IPY_MODEL_4981ad09da8f480e931bddd371b58d83", - "IPY_MODEL_8e644957f81047b8add0fc659615700e" + "IPY_MODEL_513cb9319a4f41d9a5feb1fc5fde6479", + "IPY_MODEL_82f323b0c4d8495bbe8ae0a81fe86e6f", + "IPY_MODEL_bfb84208bd294bf0a557053c0241372a" ], - "layout": "IPY_MODEL_5c79d618639c487aadb061349b282f0b", + "layout": "IPY_MODEL_89b174b280b54c0496387e5f77a70aae", "tabbable": null, "tooltip": null } }, - "9efbcffed0d640ec95650f6b44597dac": { + "9ea01d0c079a4dbba87e3421b2e9ab4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "9f06a8e3d24c445dae46289e755a463c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f73cdb08a8394132ad51b2a78b945777", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_55aa4fa946134f3ebb81e891214006f2", + "tabbable": null, + "tooltip": null, + "value": 89.0 + } + }, + "9f2d1b1364024a939cea0045a8e558d3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33140,33 +33326,53 @@ "width": null } }, - "9f386df69e474796bb2042258c34baca": { + "9f65b68e5ba34a669072d06e5a3c84d8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7fb372d2c2ec46db80e769762abf4355", - "max": 19.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_157298b29fda4f85b5d13b1be48369b9", + "layout": "IPY_MODEL_53973fb0e574496bb0e7dd9cf87732bd", + "placeholder": "​", + "style": "IPY_MODEL_1136f9c98e2e4cd4820cb10e0b0e5757", "tabbable": null, "tooltip": null, - "value": 19.0 + "value": "Converting outputs to AnnotationStore.:  92%" } }, - "9f38f2848c3f4144a8f520ed3fe3313b": { + "9f93da88675c4b93bd7bd6eb0a3664f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_46f21dd1f9c244bf95057e462ce3acd0", + "placeholder": "​", + "style": "IPY_MODEL_3bf4dc137f0b47d38f18abda273237c7", + "tabbable": null, + "tooltip": null, + "value": " 183/199 [00:00<00:00, 340.11it/s]" + } + }, + "9f9c5e57870b401995bea4fff59d0188": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33219,46 +33425,7 @@ "width": null } }, - "9f775967506145889b3f58b2f8077818": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_318ca864920f49929982f4de537a718e", - "placeholder": "​", - "style": "IPY_MODEL_65e919da54cf4e05bbbc660cf3ebe80e", - "tabbable": null, - "tooltip": null, - "value": " 36/49 [00:00<00:00, 357.69it/s]" - } - }, - "9f988a48438441588eed8c5dbc246898": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9fc95f811a0643df88cf59a88f77e44e": { + "9fb9da09528841918133b674f40ae056": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -33274,17 +33441,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f6369d1079f0474aa29bf88fc2759164", - "max": 89.0, + "layout": "IPY_MODEL_de8eeab28d654f6ba239e20e24d166e3", + "max": 899.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_258500a849bf40ce9144c54163b0f70b", + "style": "IPY_MODEL_bd9fb2df8193443786b308f94bff588b", "tabbable": null, "tooltip": null, - "value": 89.0 + "value": 899.0 } }, - "9ff75787e6594279980931eccff786d5": { + "a0189c9fb18c4402923666cdd07a0095": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33337,30 +33504,33 @@ "width": null } }, - "a0201e82ba4c49d08d45d4dc2a347490": { + "a02ef4c3d2e543339d9cb7ac47356b0b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b28318c6531440e9af69ab17fbbd6bfe", - "placeholder": "​", - "style": "IPY_MODEL_23fdf25c2f62496cb2a46a757859536a", + "layout": "IPY_MODEL_f62b2b5027da476ebefa97cea736234e", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2911b334e7c44fce9a54641247b46423", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" + "value": 19.0 } }, - "a0223917d2f4457e9e236222d44b7f3c": { + "a0eb39e0dfef4db7856aef0eede98f0a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -33375,40 +33545,34 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_d4a21d30e2e742bdbc11e4b2d113052d", - "IPY_MODEL_3a2adba6f0604289a9047d5785051169", - "IPY_MODEL_e487871e3b3a4357b3f3d3f5fc58c837" + "IPY_MODEL_0871d638a80a48bfae0a624154af9132", + "IPY_MODEL_c922748953f446f48477412df7b093ae", + "IPY_MODEL_991ee200fcd342c3b1feccbd99b7b3bd" ], - "layout": "IPY_MODEL_7a29cd41f64543d18867f9502d4a962d", + "layout": "IPY_MODEL_6d199f3efbc34732a23ce1ff7c9270c8", "tabbable": null, "tooltip": null } }, - "a0473d4a6bbe4cc3be07eaceb2d6a35a": { + "a1685e2f90824976b7d5e61f997edb7b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3622146964264166862fb39d34a8603c", - "IPY_MODEL_2b56a0ae92af48a285260a8d75e33180", - "IPY_MODEL_ae95193431e547b1b936a5a2f839464f" - ], - "layout": "IPY_MODEL_a70308a855784318b8f3a1c887098fb8", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "a0522f22ebdb4197b1b7dbaa37799733": { + "a187df2ebeb44b62813b0559b2e3b406": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33461,7 +33625,47 @@ "width": null } }, - "a06fa235eb974b11919167dc583e4409": { + "a2143e05ba7f4a7b97a6eaba83b239cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fc2e7719cc4c4c6388d6a49d718df8b3", + "IPY_MODEL_4af96f228e5042ef944d84ba3749afc1", + "IPY_MODEL_2c57f3d785fa486588b9afc05eebbcb1" + ], + "layout": "IPY_MODEL_30d0d73e82724d95a9eabfefd74e7913", + "tabbable": null, + "tooltip": null + } + }, + "a238ec9a71f14a97b5895681d20b1688": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a24f990ff14f4406ab54f6456289bfea": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33510,11 +33714,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "a08167146de343a98ad9b927545e880c": { + "a25ef53382594eab84ce4066db6e1acb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -33529,68 +33733,129 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_053c536d46334f02bcc1be9ebad98279", + "layout": "IPY_MODEL_490d5179c19b4e558ab83a345562cc26", "placeholder": "​", - "style": "IPY_MODEL_6be0780908634d7c9b6949f92f8a68b2", + "style": "IPY_MODEL_2f9b9ec5691342d0a22d0458ff734240", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "value": " 73/89 [00:00<00:00, 358.46it/s]" } }, - "a08a766751ea409fae236604550a3568": { - "model_module": "@jupyter-widgets/base", + "a2c82c8c191a4ca196bdafdcfca18bc8": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9e22136d18e448ebb8b804a6439b5fe2", + "placeholder": "​", + "style": "IPY_MODEL_46ab2b12d12c47cb91ee6f885560206a", + "tabbable": null, + "tooltip": null, + "value": " 36/39 [00:00<00:00, 354.11it/s]" + } + }, + "a2dd8cfd816643a19f694ee065601bd8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bfc2ab40b67347cb907fe38db31080e1", + "IPY_MODEL_9f06a8e3d24c445dae46289e755a463c", + "IPY_MODEL_768a28368c5340ad93e460b279359387" + ], + "layout": "IPY_MODEL_620730f846fe450790fc483ceded86b7", + "tabbable": null, + "tooltip": null + } + }, + "a2e7b50d04404434a1401dc255ea0d5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d965f240b86847c9915c050c9bb38e0c", + "placeholder": "​", + "style": "IPY_MODEL_daea84d699c949f89e5c0bda39fb03c4", + "tabbable": null, + "tooltip": null, + "value": " 35/39 [00:00<00:00, 349.08it/s]" + } + }, + "a2e7cfaf2a544c5a81e82c7745dbf1a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a9dfb4c542e84aa49fd53a8e65d18c47", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_60b4ef84a55249f78ea86d1b61171fff", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "a301c1c38aec48d0ba34e3ff572e93f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "a08e0f412404497a86f103832e131a4b": { + "a37698ad3c8046a0b150fe0742c61c02": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33639,29 +33904,37 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "a14b675871374ff89a5051199843f1fd": { + "a3a1eab2326544f59877d63c7e4732ef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_589d9bbe63864dc2842500b779ddccda", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e49168c656684fa7b8db3751a62edd24", + "tabbable": null, + "tooltip": null, + "value": 299.0 } }, - "a18aac23a7124bcfaeeabff25faa246d": { + "a3ad9028956b445b85e67ee30a0ad787": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -33676,15 +33949,65 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ee14622cd15749439820c42a23e60fbd", + "layout": "IPY_MODEL_93dd196c9e1d445ab8ab0de1102fc6fe", "placeholder": "​", - "style": "IPY_MODEL_ebd16efb451e4bf8845891e94faa9b56", + "style": "IPY_MODEL_ac10db6b8ead41ecad1cf60ebed0fbcb", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  51%" + } + }, + "a3ae402e09d546b1a0aceabf5baa7ba9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d74dd6f6eada4adba7d67d89248681d8", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_2de6d80caf2743c3869b7f67608fe533", "tabbable": null, "tooltip": null, - "value": " 775/799 [00:02<00:00, 361.34it/s]" + "value": 29.0 + } + }, + "a3b75fd89b9d4c71b5b62e7e37e0d3ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b349b63c5fc54aee97051210e0c13512", + "IPY_MODEL_ff4920731d62401a944991334e27cb0c", + "IPY_MODEL_3a30ae75d03a42db87db7ea2a98555ef" + ], + "layout": "IPY_MODEL_b3dd93c48166441c90d1eef2cafa4134", + "tabbable": null, + "tooltip": null } }, - "a1930905d7944c0abc37bab11d78cb62": { + "a4308b23f79c46d9baa44c7e1d3d8876": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -33699,15 +34022,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9b6cf4af509b4bebbc25c8e5cd713190", + "layout": "IPY_MODEL_450dde43f144464abaa0338b90ed6286", "placeholder": "​", - "style": "IPY_MODEL_a7306245921c4ea0bc79a6c073fe078c", + "style": "IPY_MODEL_6127ce0fc57c466990db3e1e0c0b7b4c", "tabbable": null, "tooltip": null, - "value": " 369/399 [00:01<00:00, 361.08it/s]" + "value": "Converting outputs to QuPath JSON.:  98%" } }, - "a2366512a78941d9b2e293d1b6fb9c99": { + "a43bb73a03c94f809f6bfbcbe348dcff": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33760,43 +34083,55 @@ "width": null } }, - "a241f36ed23240d698bc228bebf55681": { + "a466639fdbd94435a5c10cdfbd0c90cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_16023c7981a4428e97185e80eb5137a6", + "IPY_MODEL_27b727ac94344198b60b6c8f35f71a94", + "IPY_MODEL_d1d7d6dc779142d7906d8c2537b469c6" + ], + "layout": "IPY_MODEL_822d29863aa94c20ae900523f78273b2", + "tabbable": null, + "tooltip": null } }, - "a255af21947f4e9da8d97d58890a1e1c": { + "a46c0ff35f684db3b80c1b3c249b2383": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce869bac5f45494b879e026a3bd151b4", + "IPY_MODEL_ce55b4346d934300b7e8f21ed5c19d03", + "IPY_MODEL_9b614784a2f74e4bbbd19dfc35699f27" + ], + "layout": "IPY_MODEL_c701fcf1276d48ea97a061a20923965f", + "tabbable": null, + "tooltip": null } }, - "a2856414241546efa76c6089226d15cf": { + "a475084b68dc428c9433502ae20d768a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33849,7 +34184,49 @@ "width": null } }, - "a29586ff07d8448f93ce88eb1d9b3405": { + "a4a2064e1ee043889936721ea0d74506": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a4aa8b3328bd493d9f7eb4031638da2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4aaa8cf48074189a13ac527448ed165", + "IPY_MODEL_0c8f156a0dee46a0aee4dda2988cc23a", + "IPY_MODEL_1e8a516b8ab148e9af3de02174149338" + ], + "layout": "IPY_MODEL_1413473634414eb9b9fded83b8e3f594", + "tabbable": null, + "tooltip": null + } + }, + "a4b21b8e95604668b3aa35cc3f8d3cc5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -33864,16 +34241,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_1dfd6ca45c2648d4a76b5550135d6d12", - "IPY_MODEL_4a463b8084ad4227bdc5c39992a54d14", - "IPY_MODEL_496f2d2db8cd4d6c80a59944837c14e3" + "IPY_MODEL_204a680037754d4aa072f9cce0bc132a", + "IPY_MODEL_a84205a587bd45a6b16bcd0a3af0c101", + "IPY_MODEL_13841302755946aa9b5b624933344cae" ], - "layout": "IPY_MODEL_2927b89096ec44288bc314528c24f65f", + "layout": "IPY_MODEL_245183e44125490ea7b8b868149793b9", "tabbable": null, "tooltip": null } }, - "a2a1c7b5e4424ec293b9081596e5fe06": { + "a516d3458e0948b3940132c58a0f1f2a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -33922,27 +34299,77 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "a2a91473024c4d33913e49a2f8553979": { + "a51a11dbdc1d4446b3ccbfbb9ab83536": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_43338b6762d44123a270dc7e672607e0", + "IPY_MODEL_a960ec2997ad4ac39153991bd6482464", + "IPY_MODEL_0585bd3ba4114cd0ba5973af673efc7b" + ], + "layout": "IPY_MODEL_73a8e1e7285d4478928bba34cda0c13d", + "tabbable": null, + "tooltip": null + } + }, + "a549d8845ade4a52a6ed2181419d5c65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a5b7b301923542088c00c4a38bd01cf4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_66c2958f021542c4a54053e022d2d173", + "IPY_MODEL_9fb9da09528841918133b674f40ae056", + "IPY_MODEL_f617a520ed454e59bfca9162efc0c02b" + ], + "layout": "IPY_MODEL_cfb43e4412694e9eb8a3f79fdf54e909", + "tabbable": null, + "tooltip": null } }, - "a2e89e916dd04db9bfd98eee00a49147": { + "a5c0f436502a48e9b890fbb59edd5a27": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -33958,7 +34385,43 @@ "description_width": "" } }, - "a3359f583de74b66847fd6e657baa90c": { + "a60d6a4d11ce4e638dbda3cb0668d5f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a6945edce8d140bfa82de7cfa227ae82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a6f796ff46704ebb9ff313c51baa4d61": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34007,37 +34470,75 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "a336db13ecb1496f889be30676adc46c": { + "a71543e410a5411589b9af9cf97bc349": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0aa5d390f8884c5483607403b475ec17", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_905333b503af4652a03ec8ce2d49e7d0", + "layout": "IPY_MODEL_936410a4ed2d41dc880a8d9284a6c7fd", + "placeholder": "​", + "style": "IPY_MODEL_8405d160f8b74ad9a34d604323539872", "tabbable": null, "tooltip": null, - "value": 99.0 + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "a7c49a2242de43b08eb9b76b6853d5f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a7c6c848b93e4e12a08e107c2b96df3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ced3faa091c2469cbbec4a93c24d75f2", + "placeholder": "​", + "style": "IPY_MODEL_a9c903f2a8a24ef795c75671bfed0ff2", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "a33a001b159349fab9741fd08f1e74dc": { + "a81df8077add49b1b70ef2655c07c4e7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34090,25 +34591,60 @@ "width": null } }, - "a340a170e0214eda8adb7d7e13f46c29": { - "model_module": "@jupyter-widgets/controls", + "a83320d78dba4e00bb9066a779653553": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "a355e395f10040dfa002089118841303": { + "a84205a587bd45a6b16bcd0a3af0c101": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -34124,17 +34660,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_a0522f22ebdb4197b1b7dbaa37799733", - "max": 199.0, + "layout": "IPY_MODEL_07f5cda023544b3bbaa36c10d7e3c242", + "max": 49.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_e8916415b5ef40c68f39362bb2fa14c3", + "style": "IPY_MODEL_eabd515abc4f4c6b83862bddbdeead45", "tabbable": null, "tooltip": null, - "value": 199.0 + "value": 49.0 } }, - "a35d6c88b5a740008757e625a41371e2": { + "a8501bc2bc9f462aa42e447b3d09e814": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -34152,7 +34688,7 @@ "text_color": null } }, - "a3ebc9da861e4af3bce977449342ab1d": { + "a8518783677c4086bb0208a8fa09cc4b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -34167,68 +34703,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_d8091fc330484f93ae0428ae85d8afbb", + "layout": "IPY_MODEL_05e638b0a4d24f09add74e870206463b", "placeholder": "​", - "style": "IPY_MODEL_3050a1864c2b4706a1df4a5acad077cb", + "style": "IPY_MODEL_65bb7e5fc4844c28a454f6e5c5abffa3", "tabbable": null, "tooltip": null, - "value": " 478/499 [00:01<00:00, 360.56it/s]" + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "a436284c4732400e9b8c8f443966b7fb": { - "model_module": "@jupyter-widgets/base", + "a8583d223fe341ebb31b2cff1b581f23": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "a4ac22479ee04dc5bd7b96347fe9b5f1": { + "a85af86961cc4aebb044f66104761185": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34281,7 +34782,7 @@ "width": null } }, - "a4f115a5e1434f97955e0ff7264f8afa": { + "a867ce2e904c489e8640912e779148be": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34334,31 +34835,30 @@ "width": null } }, - "a51b4cbcf05f4046a4623771929e5cf5": { + "a874714e44a64c869a3ef23395cf3e4c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_17053bb3933543e69322a36217dd2d99", - "IPY_MODEL_4c440dd136144f749019ea43419ed99b", - "IPY_MODEL_83c763d3fb93490d984f60bd34f86485" - ], - "layout": "IPY_MODEL_d7ffdc53aa764cab94c829dcce0a5f90", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5d31df8b004f4055b0788dfaecc2f094", + "placeholder": "​", + "style": "IPY_MODEL_54548d8157b042bfa61ad88de710ee77", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 771/799 [00:02<00:00, 363.11it/s]" } }, - "a540492a97c542419a05fd5d1d10a971": { + "a87e0af40efd46fa832b40f3621a26b7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -34373,56 +34873,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ae7a1716b0a14b43924414469bb3c47e", + "layout": "IPY_MODEL_3ccc5911d21d413cbc20897f0c8c1620", "placeholder": "​", - "style": "IPY_MODEL_b76df83bba1b4424a8e29b89fe9d031d", + "style": "IPY_MODEL_5c1e982f72074c59953900c818a5a2d9", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  98%" - } - }, - "a5407b0a1fa74f35b775c39905a804ae": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 36/69 [00:00<00:00, 359.97it/s]" } }, - "a54c5dd9bbc64f5b97c32c37a0211929": { + "a9083826b8b54ed1877eda78417661ab": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a2a1c7b5e4424ec293b9081596e5fe06", - "placeholder": "​", - "style": "IPY_MODEL_9c73221770084648ab4a5ec0804196a8", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a7c6c848b93e4e12a08e107c2b96df3f", + "IPY_MODEL_1c9d3fe672cd44f2b68eb053d2f69ace", + "IPY_MODEL_df0a219fbdca497f9dd3064e76abfbf9" + ], + "layout": "IPY_MODEL_8bc431a1a85449eeae2b277fe85c7b22", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" + "tooltip": null } }, - "a557bb53bc8642749f8560bb1c0985f5": { + "a953a66662c24f4aab5308e30a2e8dcc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -34440,99 +34923,51 @@ "text_color": null } }, - "a590d9e986e24dd2b7e9e847555d6cae": { + "a960ec2997ad4ac39153991bd6482464": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_af2706de906e4a54aae9cc27e50fe862", - "placeholder": "​", - "style": "IPY_MODEL_c9a6a71bfcfd4a75bb716c66ecd4b731", + "layout": "IPY_MODEL_c842ccf7da0e4030b16b302aef76719c", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b4f3808862404ebe94f3fe6787de7451", "tabbable": null, "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" - } - }, - "a5919878920d41b9b612514c78460e91": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "value": 69.0 } }, - "a59245fd27c84e1fa9f32f9568ba2884": { + "a9c772b8db6849e0917ba5787a1c964c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "a5bb1cdab18b4fdc996a5f2118d037a2": { + "a9c903f2a8a24ef795c75671bfed0ff2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -34550,7 +34985,7 @@ "text_color": null } }, - "a5f7a5c23d0f4a1facc5a14763124c8b": { + "a9dfb4c542e84aa49fd53a8e65d18c47": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34603,76 +35038,33 @@ "width": null } }, - "a5fbfbb96bd940b6910b8461c35a803a": { + "a9e9d589b357412aa16caf06badfd984": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "a63c9f8d6d7045919becc483c1dae9b8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e5e87323eefe48338843e25757748279", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_673588c2b2b648c29c0166c3b671cbbb", + "tabbable": null, + "tooltip": null, + "value": 89.0 } }, - "a661b4edaa614a9cb46f7306f1d46a1c": { + "aa0eaa941c64493e84fa94ad7ce9aaf1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -34690,57 +35082,7 @@ "text_color": null } }, - "a682d84851a44defa0ccc688483ab9cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_15c9cafd7e2e43548f1d26762b9e26f4", - "IPY_MODEL_54a23534e2fa4254af596b2dd7122cd3", - "IPY_MODEL_bc61a09d90384286a1c6029f74dadf4a" - ], - "layout": "IPY_MODEL_c0b8ed31060546adbec7628e74034b36", - "tabbable": null, - "tooltip": null - } - }, - "a6c41bd3946a46eb9f60e521964bde62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_afa1c174b740462695db3650f5469963", - "max": 199.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_2abd18ce78f4431fb12a9068651c4590", - "tabbable": null, - "tooltip": null, - "value": 199.0 - } - }, - "a6d07bdeb8914e1ca87a5a78ce2dcc9f": { + "aa2070ec1e6c44edb5d9543670cb61c5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34793,30 +35135,7 @@ "width": null } }, - "a6ec65736570464d8e2b338dba9e0d16": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8037175b913c4f648cafdf3e2b750b0f", - "placeholder": "​", - "style": "IPY_MODEL_63597cc6e8b7497bb97c1eb85e27dd4e", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  61%" - } - }, - "a70308a855784318b8f3a1c887098fb8": { + "aa302e7632234a9a8d3236e54be0fca9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -34869,69 +35188,30 @@ "width": null } }, - "a71616c00a964b458de213c82e775098": { + "aa323f9226bb44f991ad2e5c97ce70cf": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a7306245921c4ea0bc79a6c073fe078c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a75e3652be124a3886c39a30a2610599": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_09896c1482f9411ead4ab9b1e53033df", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_6cb14dea20cf43ec9a6d6c8785c6cece", + "layout": "IPY_MODEL_39c0b5bf6a7e49eab47960056b854725", + "placeholder": "​", + "style": "IPY_MODEL_23af2efd63c34545bff4f28479e9ddf9", "tabbable": null, "tooltip": null, - "value": 99.0 + "value": " 0/9 [00:00<?, ?it/s]" } }, - "a7931ba0d9754c17bcdb4e91c4d5a5db": { + "aa4533f4b72d4b1684637a977bc435c5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -34946,16 +35226,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_fc553ccf6a0b427aa55c04996ced8786", - "IPY_MODEL_524fc73795d24111b5aa33045f0451dd", - "IPY_MODEL_09758263bc224d42ab0415b16f594e8d" + "IPY_MODEL_cfa98cf631fb467fb44af939ea163fa3", + "IPY_MODEL_444db4142ebe469f97542f252451bd1a", + "IPY_MODEL_1bac9679c59f4c75b75f4a200f495d0a" ], - "layout": "IPY_MODEL_80353b3841a949cbbc38cbe60c077b34", + "layout": "IPY_MODEL_e20c34ef318f4ea181a8b75c41909da9", "tabbable": null, "tooltip": null } }, - "a7a2d91e2baa48c3a34cbfa0e37672f6": { + "aa8f243213e14ddb879fc3cfe6c10b03": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35008,7 +35288,7 @@ "width": null } }, - "a7c73efd6e9e416c85de8edd3c3a1b3d": { + "aa996145d23f451586abe23a75e1c846": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35061,7 +35341,66 @@ "width": null } }, - "a7f1bb5697c346f7a6968f3ce65a49bb": { + "aaf496ae361a42b19fd29f4dd9e97cb9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2786fcf242d247699682b01adce9c3d6", + "placeholder": "​", + "style": "IPY_MODEL_c1c6a8928bdd4914ad28dd262c1e0e3d", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  74%" + } + }, + "aaf5c3e8883f4c0faf7cf6d1f702f0f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aaf9204a0cb84ab68e2c9d5ac08c9c23": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aafdd9e4fccf4bbba3f79440240716e4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35114,7 +35453,7 @@ "width": null } }, - "a83d2632ae0e490fac1363f9af87a06c": { + "ab273f1e68bd4bf29ddeaa04c57cac59": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35167,39 +35506,71 @@ "width": null } }, - "a847f8f9f9d2446cab5a97349d94fa7c": { + "ac10db6b8ead41ecad1cf60ebed0fbcb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "a86ef9e81e8d447b96fe630b03dc3170": { + "ac31071afd7a4490b17598491302bc19": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b1adcf67f146406da7d12dd676a72613", + "placeholder": "​", + "style": "IPY_MODEL_95398bb076a1440cae2c3217a3b56c95", + "tabbable": null, + "tooltip": null, + "value": " 587/599 [00:01<00:00, 361.92it/s]" + } + }, + "ac5eec4989d844b587b4282facd23096": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e432b1f158334b06b2fba61305ee70e4", + "placeholder": "​", + "style": "IPY_MODEL_f959e77699564d89a4a6fd64274e51d6", + "tabbable": null, + "tooltip": null, + "value": " 73/99 [00:00<00:00, 358.71it/s]" } }, - "a8e1874938074203ac81d478fd1e201d": { + "aca3140cd99140feb31535c0ad1e63f0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -35214,15 +35585,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ca6ad57cfb5941159f5f1c6b055c5183", + "layout": "IPY_MODEL_bdd47076fdec4c59a142712c2580cca9", "placeholder": "​", - "style": "IPY_MODEL_ad1c29fe56904195b160834cba04a0c7", + "style": "IPY_MODEL_6950a2e5bdc040a6a33bd80d60cc9b34", "tabbable": null, "tooltip": null, - "value": " 479/499 [00:01<00:00, 363.69it/s]" + "value": " 90/99 [00:00<00:00, 317.71it/s]" } }, - "a904c112f7594f0991e7b6c55bde148d": { + "acb325923fac40dab9ad6e4ba696e3bb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35275,126 +35646,7 @@ "width": null } }, - "a90d8a4ab2b54abab95419fb2e366e60": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e4b9e8510735418b98f75fffef37a5db", - "IPY_MODEL_1b3ce017807544c1b918460d658f8161", - "IPY_MODEL_c3b352168ac64b7da2c4d78a0fc9e3ca" - ], - "layout": "IPY_MODEL_1188553b527c416585862b84380cf028", - "tabbable": null, - "tooltip": null - } - }, - "a9256530ab154816ab380145906b2153": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6f97f3f8078648f499ec2cf3e8d5c29e", - "placeholder": "​", - "style": "IPY_MODEL_1fc31890d70149829ae5cf8efb6ff8ac", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  93%" - } - }, - "a9262ac2952b4d09b5a52834601ee8e0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f5c1186dec3e4d24afea411ce9e31051", - "IPY_MODEL_e1436fcb37b4445d913bf68df979444c", - "IPY_MODEL_69cd31c536d9404d92d39b4d91549d19" - ], - "layout": "IPY_MODEL_9404db936ef347d19c7938726480dab1", - "tabbable": null, - "tooltip": null - } - }, - "a9d0b4ec984d4c318c970a4757df9d13": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_07d17c41ab2d4770bb6098c26363e34b", - "IPY_MODEL_40416f56012a46ed9ed4caa07e74d73d", - "IPY_MODEL_977a91b067e24994a38c9c3890cab2cf" - ], - "layout": "IPY_MODEL_80ddd1f13b0240718cd9b6c4385d8651", - "tabbable": null, - "tooltip": null - } - }, - "a9ed73f78a6a49b3b2f36919f6e0cc18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a54c5dd9bbc64f5b97c32c37a0211929", - "IPY_MODEL_509d9a27430844dea588744428b1d13d", - "IPY_MODEL_a590d9e986e24dd2b7e9e847555d6cae" - ], - "layout": "IPY_MODEL_b1201d00bc18498ab9894655b8ff4101", - "tabbable": null, - "tooltip": null - } - }, - "aa449fc079084c5c855152f32565c1c3": { + "ad09e32a6bc24250a8fd390dbc31d8da": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35443,11 +35695,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "aa687bd844e94b2d9e9eeb0b143582d1": { + "ad24b73e4e034dfb8d0723ab0dee29e7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35500,83 +35752,120 @@ "width": null } }, - "aa68cbb92bf6492a818c9be528955058": { + "ad3316882f9a4bb2938b634b5eaae4be": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a475084b68dc428c9433502ae20d768a", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_53193d5f8669482bafe580800acfad9d", + "tabbable": null, + "tooltip": null, + "value": 39.0 } }, - "aa9fd23d74804b7699edb91ca672e49c": { + "ad4aaf1410de4c19884a38a61cf2d918": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "aaf48d038b0045e697d3f60c20e8e1f0": { - "model_module": "@jupyter-widgets/controls", + "ad4b6513b15b41039ea448b804082eb6": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_28d07f56029c49e59ccf4d2e358dd949", - "IPY_MODEL_89c15203ace248d1a02a02594b023db4", - "IPY_MODEL_ce60bfb1c1a842e7b793f3562da27f9b" - ], - "layout": "IPY_MODEL_ef0f9b18e54546fd8ada11b2118939ae", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "ab7ee20281f048f4b741aef6e2a4720d": { + "ad6c469b0937450e9b479a6158f1b37f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "ab980fad443a46288c7c9020ebcb0454": { + "ad98fcd3b45848088325663f3bac9d6e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -35591,31 +35880,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c63f98624a854b9fa5db5fbaf96bdcf4", + "layout": "IPY_MODEL_e92568352b194e9f8501a0e9ef4d85e7", "placeholder": "​", - "style": "IPY_MODEL_190e7fa99dad4ca1b3656e8ca37da0db", + "style": "IPY_MODEL_fd8c57e995c54376892a28a89c042405", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  95%" + "value": "Converting outputs to QuPath JSON.:  91%" } }, - "aba0cb800126442a8fb0da38129ac004": { + "ad9d483153824272b416be214c50d020": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "abad997f6dc64f9c94624291452d15c1": { + "adb0ccf8ab734a9fbda3727d2733decc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -35630,32 +35921,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_ed0e4971bd794b4bb3060657b66b8fff", - "IPY_MODEL_9a96669e38c449f698334512a42575d4", - "IPY_MODEL_bd92dc4e293a46588004a9a1352214de" + "IPY_MODEL_c9a9a4ba171741e7bf0cc39b57eabb17", + "IPY_MODEL_c20ea0b88ddb40b4b195d8bf47a759ba", + "IPY_MODEL_3c6a677e69ec4cb59ef9ed18ddb27cbb" ], - "layout": "IPY_MODEL_df6fab5a0c22465b8e1ff3ab2829117a", + "layout": "IPY_MODEL_b6ad48c2a88445ffa0ab40467979764d", "tabbable": null, "tooltip": null } }, - "abc32f9329d04aea9313056d069ae33a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ac25dc86d6944604a7e82a5dde8e249e": { + "adb8302d715242ae99ac7a9cf0e8d4db": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35708,7 +35983,25 @@ "width": null } }, - "ac2e5f9254b5480cbe979aece5461b9e": { + "adbb08f0f45c4394ba8fe7f00e9d9a70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ae11e88505c8462881be1d3cec128043": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35761,7 +36054,30 @@ "width": null } }, - "ac5149c12508461494509e9c89b33757": { + "ae411931c684402d961cf461eec8c4c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1546f73e54af4e55a1d94bd8dfeb9976", + "placeholder": "​", + "style": "IPY_MODEL_3f936240f6204290b5439eabc4309d1b", + "tabbable": null, + "tooltip": null, + "value": " 36/49 [00:00<00:00, 357.74it/s]" + } + }, + "ae6719d3bae74c73b76f93727125029c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35810,11 +36126,122 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "ac565eb12f424e02aaee1713f6830bd6": { + "ae758b3b9cae474ea6476f2d3d63c5d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a37698ad3c8046a0b150fe0742c61c02", + "placeholder": "​", + "style": "IPY_MODEL_dafc978020bc4609b21e5c6c0263d4ff", + "tabbable": null, + "tooltip": null, + "value": " 369/399 [00:01<00:00, 313.05it/s]" + } + }, + "ae796170aafb41ef9724a108bfbcdf14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aeada5ef1208471980d98b1c7608fcd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_48a1923f3c7c4e8b802d136a551598fc", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_81cc56809e4c4d918ac0364257a100fd", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "aec00a07c9ae451aaa35345da3858731": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f96bca2f8e51474f8a81270510141c4a", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_695cee95d751499db8f64b7eca530791", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "af5369c6c54940b0874511dd412f6668": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "af62ea5119c54f51920c5598dfa83ebd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35863,35 +36290,27 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "acbf1653664b439483f72287bb24dd6a": { + "af653c02ca594f969765d485cc49e0c8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a540492a97c542419a05fd5d1d10a971", - "IPY_MODEL_c21eb73ba424423e86846d7447dc2b49", - "IPY_MODEL_db0dcff9dd144d069a54398862e9c984" - ], - "layout": "IPY_MODEL_4bb794dfe1744d55aa533efe8522ebdb", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "acc2541152ad42ad904a608103986423": { + "af746d2e44ac4f3e85da91000e5637d4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -35940,29 +36359,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "acc62cb85534464da464081371d494dc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "acd256a9ac3b4b2abeb614cc7400cb65": { + "afbadadb9c7040e583e17e3de4cc4d84": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -35977,15 +36378,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_3c5184bc80de492e9758c899b7600bc2", + "layout": "IPY_MODEL_e8ed18d0e06d4908807807175a91e75d", "placeholder": "​", - "style": "IPY_MODEL_8a8a5222321946e38de69b513db84a8e", + "style": "IPY_MODEL_13e40c06735540a48095222abd7a3f8e", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "value": " 72/79 [00:00<00:00, 358.97it/s]" } }, - "ad1c29fe56904195b160834cba04a0c7": { + "afcb4005b3784a9e8adfeae0c6685e8d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -36003,25 +36404,33 @@ "text_color": null } }, - "ad5b8dd38022462396e962705dd1e98d": { + "aff1ade3723842db845738d1e3bac7fc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_baecf6899e1842e7ad849879947a936c", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_416d33f49b174a6897d564b364dfaf41", + "tabbable": null, + "tooltip": null, + "value": 9.0 } }, - "ad759a9a72194a3d82076c6601322a6e": { + "b025dc1794eb469185ae0f899cddd156": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36074,64 +36483,7 @@ "width": null } }, - "ad7c5164053345a3b53a2c2623993ebf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ad9a82eb73344ff5bad6273bd3a47485": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b25062c206d143aab590d0fda7cb514d", - "placeholder": "​", - "style": "IPY_MODEL_d12c898e7e1844788d3d748ad2bd8167", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  91%" - } - }, - "adbfcdc5027c4ba798eb04931bd5e539": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ade3073776f24e57aa8d4acd8b874822": { + "b069858f0a4b46258f3fa506dad56313": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36184,23 +36536,53 @@ "width": null } }, - "adf76844a8d94c318d7b11f124e05ca9": { + "b06bf1c41d6b425e9a6c284a9e470709": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c2e97b1b1d7047ca983c77663f99da42", + "placeholder": "​", + "style": "IPY_MODEL_301771feabe84c3d911acccbcd74f07f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" + } + }, + "b072f1110efe447c90112dc0a98a55cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9ad24b54d98d4b4ca0783f6464a37307", + "placeholder": "​", + "style": "IPY_MODEL_562b45528e364dcdbfa0e4c4219c4ede", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  74%" } }, - "adff666cc0da41eb82076f798f8491af": { + "b08c46c588e34e3a83348c4cdaa29caa": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36249,35 +36631,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "ae0e27e36ad64d11b539cc8bbef4ba18": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_acd256a9ac3b4b2abeb614cc7400cb65", - "IPY_MODEL_33051702a54a44748f00e635574ac265", - "IPY_MODEL_648e40aae32243c98e5cb2c6ce8899a8" - ], - "layout": "IPY_MODEL_7eb7be66cbf4447d89f755bfb089b7fc", - "tabbable": null, - "tooltip": null - } - }, - "ae4f0036524f4a2badd0c345344a8fba": { + "b0fee13778044f908c58f4c29db9ddb6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36330,7 +36688,7 @@ "width": null } }, - "ae7a1716b0a14b43924414469bb3c47e": { + "b19509231b4f404e99b700fa4222d73a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36379,52 +36737,35 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "ae89dd9343ed4eb8814e10c101143c05": { + "b19f60f6b4a94cf0b18f3f534c44a4af": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ae95193431e547b1b936a5a2f839464f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_11fd9acc6eec4a58b00464a6a6748efa", - "placeholder": "​", - "style": "IPY_MODEL_c09575ba0b07438bb3236b145d560c6e", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6feac2f64e5d47c2a83d74c8e0dcc539", + "IPY_MODEL_9c74ee67c9d044919ab99eee70edbbfe", + "IPY_MODEL_51a794dba05346298151e9c08b769765" + ], + "layout": "IPY_MODEL_38d7231626294235bb8cd302a79227d3", "tabbable": null, - "tooltip": null, - "value": " 480/499 [00:01<00:00, 362.39it/s]" + "tooltip": null } }, - "af0e038f4de74c778a7304432a8ae7af": { + "b1adcf67f146406da7d12dd676a72613": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36477,7 +36818,30 @@ "width": null } }, - "af2706de906e4a54aae9cc27e50fe862": { + "b1fd6d5f8bd14bfe8b17cd9d0365dbe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fb9e66c1eb244ec19b447e0261510d1e", + "placeholder": "​", + "style": "IPY_MODEL_a8501bc2bc9f462aa42e447b3d09e814", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "b2cde72def81416db0b9c3c47530cc38": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36530,7 +36894,81 @@ "width": null } }, - "af3de1ec3b064b26a4c80a88601cbd29": { + "b2cf2528a6f747378071157f32031170": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_99e7b7a6cfb14213932fd95633a1a66c", + "IPY_MODEL_0014f231b32443b8bfab117ab121d886", + "IPY_MODEL_183eb543201c45c3990047737f88b3b3" + ], + "layout": "IPY_MODEL_723e0d886f394340a4af62a692898f32", + "tabbable": null, + "tooltip": null + } + }, + "b2eca7b5574a4b3db78272c2c6b6cc04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a867ce2e904c489e8640912e779148be", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_70547f4edb4a4dd5b87db110c89d13b9", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "b2fd804650fe41eaa214942cc13f595c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cbe03234c932448e8af72c157bfe2670", + "IPY_MODEL_82e9b6bc286a484fa5d09fc24ef653c1", + "IPY_MODEL_0f638ebe107040cf9a64cbf06516ace7" + ], + "layout": "IPY_MODEL_2ef2712eb11743d79fd85dbb0964bc3d", + "tabbable": null, + "tooltip": null + } + }, + "b2fe64d58aa044118a38cebcbaddd29c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -36545,16 +36983,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_81f3e1633f0f4edc90a2916d81b9bb01", - "IPY_MODEL_1e9dc8e16b7442e8b4b6cbd2ef6bfd63", - "IPY_MODEL_4a9b2f8743c545ffb56f3cd00d26b3d9" + "IPY_MODEL_6a42e66e95064a438ebe8f6cd78151c7", + "IPY_MODEL_4281e037c1be4a04a5c0586fbe23d27a", + "IPY_MODEL_301b81d03e37420d8a1d12568eceb284" ], - "layout": "IPY_MODEL_d8b3bbfe035547f8b5583462b73d54b8", + "layout": "IPY_MODEL_c4e6a3d86d3e472eae5dde2c7d5c33e3", "tabbable": null, "tooltip": null } }, - "af9caec5dc16457491cb6a0d858c965d": { + "b31e3578fa894e8e904e1157619b8f9f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36607,7 +37045,71 @@ "width": null } }, - "afa1c174b740462695db3650f5469963": { + "b32093fb46334dfe899ce0f1b29053b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1bd4c0a21e4b4f1aab5c09636e30c61a", + "placeholder": "​", + "style": "IPY_MODEL_2d8cc8de11c8466f825698ae268bf35d", + "tabbable": null, + "tooltip": null, + "value": " 996/999 [00:02<00:00, 359.38it/s]" + } + }, + "b349b63c5fc54aee97051210e0c13512": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_655e863c62474a34aa8dea4c37157b37", + "placeholder": "​", + "style": "IPY_MODEL_33e136242f184bf288b3b4914f89832b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  91%" + } + }, + "b3c49f7322214952855810016b5872bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b3dd93c48166441c90d1eef2cafa4134": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36656,11 +37158,34 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "afd2ef8a040b4348bc98a17b1ff49021": { + "b3debfbb74194023aa76ad471799c958": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_64914986996b4154912c4369fe1f56c5", + "placeholder": "​", + "style": "IPY_MODEL_703f96c620f6473ba611f6a1738d45a8", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 355.90it/s]" + } + }, + "b3f67d994be040b582ce06c5fd29f403": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -36678,7 +37203,7 @@ "text_color": null } }, - "b007ff62602a4a2d876b1efe3afd3673": { + "b4015293f3ac4a16ac4ba21218c0f70d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -36693,15 +37218,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_8d75ea1674e44d96af14247550d590cf", + "layout": "IPY_MODEL_4f6c16aa09404df492a21cf05e3bc7fb", "placeholder": "​", - "style": "IPY_MODEL_f87278b7c22546cdbaae634fb57a8984", + "style": "IPY_MODEL_0a31f5c3e3b94f26a9bdd7f05f3a0b4d", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" + "value": " 0/29 [00:00<?, ?it/s]" } }, - "b064303dfefd4611a09a96fd21a6992d": { + "b408e6a7be504c48a10b39d1d6754bb1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36754,83 +37279,41 @@ "width": null } }, - "b0683478a18b4a92a1e2c29f78fa8ef4": { - "model_module": "@jupyter-widgets/base", + "b4aa2ca5638b4c19b45abc9c5fc14fda": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "b0a58eae94e746e6b407403b1f19364e": { + "b4f3808862404ebe94f3fe6787de7451": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8abc7f6b14c64c9ab6f07badd64512a0", - "placeholder": "​", - "style": "IPY_MODEL_0514849d6d8c4727a4751a7c66a05ca7", - "tabbable": null, - "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "b0f0e7ff3137469cb9bf38983eb4bc17": { + "b4ffb2e0fd1241a0975082f6b1152276": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -36848,7 +37331,33 @@ "text_color": null } }, - "b1201d00bc18498ab9894655b8ff4101": { + "b58c3219b8da4565bd0396e7253468f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e0514e0deae14410a629b153d324211d", + "max": 899.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4785898402dd496ab26e7bf263668dc8", + "tabbable": null, + "tooltip": null, + "value": 899.0 + } + }, + "b5e89d421ae34cc6902ea09438556b0d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36897,50 +37406,58 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "b1587905de344c799dae783551080f27": { + "b5ee8f74d85d46fc83928cf15ec63619": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f343fc0ebf394065a3713794fbbca812", + "placeholder": "​", + "style": "IPY_MODEL_626995cf5ec54c99bb689141ce31dc21", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  97%" } }, - "b17bc236385d4dd68417114366161ecb": { + "b65f8956fffc4557be6416270b68e2ef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6ba40fe467a245cf8236007fcb4ac620", - "placeholder": "​", - "style": "IPY_MODEL_f896916f00ea483388f1a885471b5edc", + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_78a1c9ce03b247e29bde5cf2cd868efc", + "IPY_MODEL_bd18e9c3c8ac482aa51ded548e02763a", + "IPY_MODEL_ac5eec4989d844b587b4282facd23096" + ], + "layout": "IPY_MODEL_9773198c89ef4a28b968888b6b2e380b", "tabbable": null, - "tooltip": null, - "value": " 36/69 [00:00<00:00, 352.40it/s]" + "tooltip": null } }, - "b18f0cf4f37545aeabbfd819430fc1c1": { + "b6ad48c2a88445ffa0ab40467979764d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -36993,7 +37510,7 @@ "width": null } }, - "b1bcd5ba576748079cbe5e5af0a7c26a": { + "b6da4af56e5d4d82ac18a5ab30ceba0e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37046,7 +37563,90 @@ "width": null } }, - "b1f1056fbadf4ef28147dbb1ffd2f01d": { + "b6e6896f050b4ab0b73041502a4bc634": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_aa2070ec1e6c44edb5d9543670cb61c5", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4202fdad659042e0a289d7772f42140d", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "b703b5b4b1d04219aad63a6d40539eb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b7210993339b4e3e8696cc635194bd0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b7542732ee5545e09341723cdbeda907": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1ad4976a6a3545328728e43198f3c4d4", + "placeholder": "​", + "style": "IPY_MODEL_6cad2e859a37425092ddac5942f613e2", + "tabbable": null, + "tooltip": null, + "value": " 996/999 [00:02<00:00, 361.65it/s]" + } + }, + "b77b87c613dd4902b32d29daa1d1bdde": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37099,7 +37699,23 @@ "width": null } }, - "b24435a8972d41b0b12249bf609467a0": { + "b7f5534d78924cc6940b0d413abfd820": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b7fb937234034362b0c0a03c1f3a3bd1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37152,7 +37768,93 @@ "width": null } }, - "b24a0b8a75424936bebf06a5cd6a54be": { + "b879ae9000e04638b07a607f0d89ccd0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c571657ec07346adacaa4c32f1ea4aec", + "IPY_MODEL_2dc876b11d8a48388110a94a30f05ae9", + "IPY_MODEL_307bd8d7a31549ff8cff744c616079df" + ], + "layout": "IPY_MODEL_d01d58d95c064216a7b3770f1da7d1c6", + "tabbable": null, + "tooltip": null + } + }, + "b8ec6ce75bd64634b84709a7aad28a6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b8f17ab6d50745839aae7f0fd65d6c49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e71d5f6bfbfd4405997fdfb34b886c27", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_04a8b7dd821745fc914e50f13b873036", + "tabbable": null, + "tooltip": null, + "value": 39.0 + } + }, + "b9216d527d68471a96f37c9fdf870402": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b92350319fc34353ae51b0173513add9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -37170,7 +37872,7 @@ "text_color": null } }, - "b25062c206d143aab590d0fda7cb514d": { + "b92c0f1fc2dc426daf7902b55afeb2a9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37223,7 +37925,30 @@ "width": null } }, - "b28318c6531440e9af69ab17fbbd6bfe": { + "b9b500b1c03b4c2b95f03273d5a64287": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9cab60c6300b46c4a3e94f2258ee54f9", + "placeholder": "​", + "style": "IPY_MODEL_577cf572db044d8ab80fa0852365222f", + "tabbable": null, + "tooltip": null, + "value": " 885/899 [00:02<00:00, 364.59it/s]" + } + }, + "b9ecaf3c140c4f9ba60c54de797c8773": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37272,29 +37997,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "b2becf330305494798229d046a60ffad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b33ef3e8d72e4847b01a501a1ee5ae32": { + "b9f591c574624533858c0a2ac3c595bc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37347,25 +38054,7 @@ "width": null } }, - "b3a6f71884f8468687c7b586e2cc4d5c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b3acf684348f4c47b64c350a910a0a2e": { + "ba0e5cc96a50429bbe81af86f5331268": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -37383,7 +38072,7 @@ "text_color": null } }, - "b440836d41b84b47b178e910da6f4bf8": { + "ba1bd3a71271471b9dafd286189557b5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37436,159 +38125,7 @@ "width": null } }, - "b4b4001d21704f6d9722b7baad72dd26": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b4d8f3506da145de8a68e64bb20c1302": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_568c091a7401479aba1cb5f80507730c", - "placeholder": "​", - "style": "IPY_MODEL_8555452d88a24c1b83130071b4002e3d", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" - } - }, - "b4e67d26b8574f92be05b3b64e87c54b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1c1386ede9054a138b858dc1545ac542", - "max": 69.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_93d4bffa867445508dfeb08eb7cddac1", - "tabbable": null, - "tooltip": null, - "value": 69.0 - } - }, - "b4eac108d5154f239da0f9bcf1ac232c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_708974b8aecd47ef963493532093de01", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_4688f773988748efb9a575ca2855de8f", - "tabbable": null, - "tooltip": null, - "value": 799.0 - } - }, - "b5138b22c1ea49bab49fd56ccbca76e1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b57c7ff42f9b49c59a427dcd06f42710": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f6bca00a5f5b4ff39af06e4db0ebc705", - "placeholder": "​", - "style": "IPY_MODEL_3c46f81cd95a46348b7f8ee31dc6c6bf", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" - } - }, - "b581ba9b94144c68ad527b841857aea1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b59083f0ec09407dac286854bfb5f42a": { + "ba5c0aeadc0b49cb983b3c91613db4cf": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37641,7 +38178,7 @@ "width": null } }, - "b5bc22f2c50b46debf6fc7ba099f98b0": { + "ba62cfdfe1dc4e4da6f225330f050eb6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -37657,80 +38194,74 @@ "description_width": "" } }, - "b5c37a10a2294bfb88e0a513d9d34e30": { + "ba7b5a0ba38340729c6800c495a82a7a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_98f250094b874a2781e0ebe476b27b85", - "IPY_MODEL_2037dae5bfa342adac4d8a9a4a822809", - "IPY_MODEL_9538d61e6b184a778e6385a5b7c98257" - ], - "layout": "IPY_MODEL_1c33f01e4a684804bb4510536b3192cd", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "b5ca46c46b7e40509783a90787d49d4b": { + "ba9158f846de4863bef5b2aced1b8b9c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_bad6a6bb8e9547088a37c12128130fcb", - "placeholder": "​", - "style": "IPY_MODEL_1467cab00aa44370904975393b23f428", + "layout": "IPY_MODEL_203279656d204c4d8ba4fd094ac4b3f4", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_34bee3d9d0814334a03cf2e76dd54669", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" + "value": 199.0 } }, - "b5d92701d5044ff58eab8aed0910cf31": { + "ba9bf089f6844a3bb304e0dfa291ecc7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_41a7596b7e514adea09b0dc106ab5e41", - "max": 99.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_70619300dd114a6cae94b4d91ea55e11", + "layout": "IPY_MODEL_bbceb3366dfd4155bcdbcc3e0dc6c8ea", + "placeholder": "​", + "style": "IPY_MODEL_7e70f9f1e75d4c58a80c10a4c08870d7", "tabbable": null, "tooltip": null, - "value": 99.0 + "value": " 36/59 [00:00<00:00, 354.99it/s]" } }, - "b5fdda2c579a4cb4b17d2640ee0438f4": { + "bac21c5ee3234e99b8741d14d56a2b36": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37783,7 +38314,7 @@ "width": null } }, - "b619b1f451714ae39ee040335567b356": { + "baecf6899e1842e7ad849879947a936c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37836,101 +38367,23 @@ "width": null } }, - "b6234c14756549c19227699e587fa72d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "b62e99b4317c433faf9fd66bba58f136": { + "bb49305c3af74a308e33f574fa5484cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b643570874b24c3a9be931ef4a85da3f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_57116be0cb5142c59d6bf15babd666c9", - "placeholder": "​", - "style": "IPY_MODEL_e0bd5a7cfd4a4569920b77d5d1d3344f", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" + "bar_color": null, + "description_width": "" } }, - "b645e5a2abfe49fe96ce6bb537d91029": { + "bb49e18206e14affaa7d5a4d78d3cf4d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -37983,25 +38436,33 @@ "width": null } }, - "b6b0d2ce759f4d43857b4b691e20afc7": { + "bb91ef8684f14e92a7d33b9db78e6522": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8662766e5e3f411e9c6e2ba4e37b4f78", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5a3e51c824244c7badf019718c49e776", + "tabbable": null, + "tooltip": null, + "value": 69.0 } }, - "b6b69847001047279339b2394de2f13c": { + "bbceb3366dfd4155bcdbcc3e0dc6c8ea": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38054,7 +38515,7 @@ "width": null } }, - "b6f325f9cff2428aa16134558ef6514a": { + "bc052344e9ed494db4c6f86527c86ea2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38107,7 +38568,7 @@ "width": null } }, - "b732443cad9f4984b424f182f682f953": { + "bcc01b81545c4b4fb6ad752979a00053": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38160,25 +38621,82 @@ "width": null } }, - "b76df83bba1b4424a8e29b89fe9d031d": { + "bcdd6c3d31de4273ae026df54e0c5291": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d0413dff8834c16882a4ff65642f2f8", + "max": 999.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_0216c0cbb3ac48809a3f7b28b2a3e541", + "tabbable": null, + "tooltip": null, + "value": 999.0 + } + }, + "bd18e9c3c8ac482aa51ded548e02763a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fbe1765e09fb4d30ba000cfe8295e636", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8d650c457b4d42048adda9a925a2e97c", + "tabbable": null, + "tooltip": null, + "value": 99.0 } }, - "b773b548738b4088aa5fa5cb905b3583": { + "bd4fa9023e224822b3917bfab3443d16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_226a3cbecb0542a3b5d7d303b519b29b", + "placeholder": "​", + "style": "IPY_MODEL_ffd39ee9b3474becafdda6a81004543f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  92%" + } + }, + "bd5616ad3f014c9cb608018b80a98502": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38231,7 +38749,23 @@ "width": null } }, - "b787c0b07c794e05a349801dcf28d706": { + "bd9fb2df8193443786b308f94bff588b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bdade6cbc64c40968082e0174e5efa1c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38284,7 +38818,33 @@ "width": null } }, - "b7caebf7e06740b7a92a0441bd573cee": { + "bdc789dda4db4007949298732bcfaf17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_cf765084dad944c38c10ce353dce6ccf", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9622fa15bcf74c7c9643f29b64c6ebd8", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "bdd47076fdec4c59a142712c2580cca9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38337,49 +38897,7 @@ "width": null } }, - "b7ced44e9d9145e69c0f7cd2a3ab33fd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_3f77a1911c514851a307fd95121fa807", - "IPY_MODEL_dc4a5a362ab946b9b8124de81578769a", - "IPY_MODEL_96710220aae5465183fb43b5fe5b265e" - ], - "layout": "IPY_MODEL_9e23e688de2c4c849d2c4bb43bec6f1c", - "tabbable": null, - "tooltip": null - } - }, - "b7e0716341f74ce181718c62e6d6c208": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b7eba7cfdcf7448c93712428f4fa57dc": { + "be08a34588634a7cbe7e8f9ccd7e921f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38394,41 +38912,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ca90ea44457344ebaeac61889a8d37f9", + "layout": "IPY_MODEL_ebcc786e775344e595d40c2b290d79ea", "placeholder": "​", - "style": "IPY_MODEL_7b747ac67ff84204a5c2350d8d444226", + "style": "IPY_MODEL_c25e5c8040bd466783e93e0360d2bf44", "tabbable": null, "tooltip": null, - "value": " 291/299 [00:00<00:00, 360.76it/s]" + "value": "Converting outputs to QuPath JSON.:  73%" } }, - "b7ee1f2389c4437f88556be7c5ca20e2": { + "be1e5bc6e6034cf39656188cd765c137": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fed10a9fc2e149869e098e315605f5c5", - "max": 49.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_bce88a5077414d8c9081384eecad3c4f", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_093ef839989f4971a4fbf57157b4144c", + "IPY_MODEL_13a0882ac5144028a742e6525c0d687e", + "IPY_MODEL_1e765df6b20b49f3a8c15b4f31214cb1" + ], + "layout": "IPY_MODEL_e58d293a7316427682613c97223ac6dc", "tabbable": null, - "tooltip": null, - "value": 49.0 + "tooltip": null } }, - "b842634c17bc430eb57f5c102cd9d838": { + "be37ae18be2344cc8f772a2a021d5789": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38443,15 +38959,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b90680aa1b824cc6b8ce8c6512d4d27d", + "layout": "IPY_MODEL_ab273f1e68bd4bf29ddeaa04c57cac59", "placeholder": "​", - "style": "IPY_MODEL_7dc391b4eaf84a27b73ef0ec43783a73", + "style": "IPY_MODEL_058433b8a9be48a4a53a01d3d95f4565", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "value": "Converting outputs to QuPath JSON.:  52%" } }, - "b85b758d39c247b9b76d9f25c11b1f66": { + "be4bc91059944c03a353dbbf9fe83aeb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -38469,7 +38985,23 @@ "text_color": null } }, - "b860aa2f245c4479836b6664c1fbeab0": { + "be500d18fc1f4bfa8a572fb137967f31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bee09ea681244bfdb1e17964fd86ce3b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38522,7 +39054,25 @@ "width": null } }, - "b86782f6f8514051942ed2bab9088ed2": { + "bf4b4aed943645f993e78639568f1d87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bfb84208bd294bf0a557053c0241372a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38537,15 +39087,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_dd672073c20746ed99d05c572588ce6f", + "layout": "IPY_MODEL_f02b2d58121f42fbbe6415e8a172f1b5", "placeholder": "​", - "style": "IPY_MODEL_1f6a6f57060e425da6a3efdc19c423b2", + "style": "IPY_MODEL_341d2ca9b411414bbd31cb92e5891109", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.: 100%" + "value": " 0/9 [00:00<?, ?it/s]" } }, - "b87b207d94984923a25fde279d144d9a": { + "bfc2ab40b67347cb907fe38db31080e1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38560,86 +39110,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7421837a72f145c19e42660ab6d9b86a", + "layout": "IPY_MODEL_d2399abf03b447e9990d21beed5e849a", "placeholder": "​", - "style": "IPY_MODEL_70fe49d3a40942d298e2504e40da90bc", + "style": "IPY_MODEL_1b532744185242edb76ed6f27d13a381", "tabbable": null, "tooltip": null, - "value": " 663/699 [00:01<00:00, 360.70it/s]" - } - }, - "b882b0e063c045c5a46aef794493b4de": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b88508ebc5dc4ae8b8580c6a7c823781": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "value": "Converting outputs to QuPath JSON.:  81%" } }, - "b8c4862861714cb1bb160e7e94a61bc0": { + "c0273c527f2342e48179c73f1fb9f7dd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38692,47 +39171,25 @@ "width": null } }, - "b8decf0a9fb24d29aa2988e1f1347b5f": { + "c045b41eda0c46abbd020a9e64f17aef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "b8e9adbd4b3847be9c9c309e2153ee49": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ef2ac247bb39477f95d4f242d7091d82", - "IPY_MODEL_ff0b589903de4b8180bbd0c368575aa7", - "IPY_MODEL_91ff649d1d1840c18123da3d8b384fb6" - ], - "layout": "IPY_MODEL_88e8abe3eca34410a1941bbc595713c6", - "tabbable": null, - "tooltip": null + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "b8fd8c018d42415ca5d867c6d5527f7b": { + "c06795ca8ab947e195f5d4bad6dfee14": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38785,7 +39242,7 @@ "width": null } }, - "b90680aa1b824cc6b8ce8c6512d4d27d": { + "c095ede63d58457b832ab2769da77fd3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38834,11 +39291,29 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "b90d8c5687c54433bad6171f9de544db": { + "c10acf6386a34a8e8e75772d75686113": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c10ce057bd5243c6a88fba4b6d44cb1a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38853,57 +39328,38 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_2e6558c07cf94401815a790e9d03dcaf", + "layout": "IPY_MODEL_df0380764a3a424cb0625f3f12607ef2", "placeholder": "​", - "style": "IPY_MODEL_820ddcf258474b2789909b69fedfde3b", + "style": "IPY_MODEL_ad6c469b0937450e9b479a6158f1b37f", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  61%" + "value": "Converting outputs to QuPath JSON.:  73%" } }, - "b94a03dbfdc7464881d3d95a8deea5e1": { + "c12b307bc25c4cc4a2855bffc9c5e490": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_14c4c1d89dbe4de68035c60d5834acff", - "IPY_MODEL_c20529aa220d473dae1d370e432453d6", - "IPY_MODEL_46f4561da5f44b15a2f2ccd81e22474b" - ], - "layout": "IPY_MODEL_591c8fa5dd8740c4880a1fc9d020d148", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_08b77c7e63524316b42c0781a8840904", + "placeholder": "​", + "style": "IPY_MODEL_a9c772b8db6849e0917ba5787a1c964c", "tabbable": null, - "tooltip": null - } - }, - "b980250f39ad4e99a016bc8609dbbc0e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "tooltip": null, + "value": " 36/59 [00:00<00:00, 353.55it/s]" } }, - "ba05376918f94f348dcc480f6bce817a": { + "c19be2c73b2549bf83276ad2f7fa21df": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -38956,7 +39412,25 @@ "width": null } }, - "ba338c46b14f47668ae298f2cf3648ca": { + "c1a27d0687da4883bec110becf0d1f52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c1bf003b98ea4ee8ada5e5f4a348ebda": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -38971,55 +39445,73 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c6043c8957ef4a2aaee1dae93c485efb", + "layout": "IPY_MODEL_363d0b757e094298be6c6a40eb0b4c83", "placeholder": "​", - "style": "IPY_MODEL_7ee8719625d4475aa482c5280db4eeab", + "style": "IPY_MODEL_ed42279ca7274f0e9c342c5377f30bcb", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  93%" + "value": "Converting outputs to QuPath JSON.:  91%" } }, - "ba40add6533248abbc9da32332d9216c": { + "c1c427152bd44c81acc3d373e40ffbbe": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cd36700303a042768902ae689e70cfec", + "IPY_MODEL_453120223be94b3ca1d08fcfcce7a595", + "IPY_MODEL_393b20bcedb34a32bd150d6249707bdc" + ], + "layout": "IPY_MODEL_94681603c5d04894874724741aaa33bc", + "tabbable": null, + "tooltip": null + } + }, + "c1c6a8928bdd4914ad28dd262c1e0e3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "ba73e26ed5a943ac938e140c55843c02": { + "c201ce80042540b4be624d34a14bbf4a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_fdb6e5e0a4774be38d1f2e2d05037d91", - "IPY_MODEL_38c5fea0d65e4c48aa473f2b762dd8f9", - "IPY_MODEL_56d7f018ddae496abe2b614de1d71831" - ], - "layout": "IPY_MODEL_20e4029fe553444393f77ddd54abcb1d", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "ba78799094b347d78d70dbcd8fee7d85": { + "c203bde17bdb4938a92a704f63e2c1a7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39072,47 +39564,7 @@ "width": null } }, - "baaa56c7ee104ec59d9d586ec56a72d4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_379aee897c594d88abf2047172f5e823", - "IPY_MODEL_471fd00c254048959ba917062300abe4", - "IPY_MODEL_7f3f013e4dc14d80a97c057101e02673" - ], - "layout": "IPY_MODEL_fe0e8914ddaf467ba7196560bee6b788", - "tabbable": null, - "tooltip": null - } - }, - "bac2b131e0fe4428adf8000233c841cd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "bad6a6bb8e9547088a37c12128130fcb": { + "c20c394b7972432099e1ac5f2c67b11a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39165,7 +39617,7 @@ "width": null } }, - "bb01937712fe42938626bc597b28e65c": { + "c20ea0b88ddb40b4b195d8bf47a759ba": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -39181,33 +39633,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f31a7548c4184d51a9643115a87e6490", - "max": 199.0, + "layout": "IPY_MODEL_a85af86961cc4aebb044f66104761185", + "max": 19.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_480053998b7148deafbc6d956a9bb88a", + "style": "IPY_MODEL_c973fe5b30d949c483b8928d4df30dae", "tabbable": null, "tooltip": null, - "value": 199.0 - } - }, - "bb04a2592724400c93e6c968f22b30b2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 19.0 } }, - "bb118a11d49d42ccb562978a4c384d2e": { + "c22eb2b7dc84430ca844699b9b3bec57": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -39225,7 +39661,7 @@ "text_color": null } }, - "bb22831bc9fa4e1ba508da66a65e6248": { + "c25e5c8040bd466783e93e0360d2bf44": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -39243,48 +39679,59 @@ "text_color": null } }, - "bbe3b34d52d84712934297054f606fff": { + "c27ca95f366d4cea8bf408874a5d711b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_04ee0f633cf4430b86644f5e48d8128c", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_897e4bd5aea343d8bd32f50f41889917", + "tabbable": null, + "tooltip": null, + "value": 69.0 } }, - "bc61a09d90384286a1c6029f74dadf4a": { + "c28aac1883074095bcd1a4116cf4497e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_ac2e5f9254b5480cbe979aece5461b9e", - "placeholder": "​", - "style": "IPY_MODEL_6fa895fc623a4058b809bffb7eb68519", + "layout": "IPY_MODEL_f6c26b1e4cc546bf94af7cfea58e0f9c", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_8d55a1ae6fbc4bfab18d5625be079373", "tabbable": null, "tooltip": null, - "value": " 297/299 [00:00<00:00, 364.83it/s]" + "value": 49.0 } }, - "bc851c576c0b4acca0cebbf5bd59eab2": { + "c2e97b1b1d7047ca983c77663f99da42": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39337,64 +39784,60 @@ "width": null } }, - "bce88a5077414d8c9081384eecad3c4f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "bd18b76931b442279477932561eac8a9": { - "model_module": "@jupyter-widgets/controls", + "c3016b73acfa47978d29e3a91615efac": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "bd92dc4e293a46588004a9a1352214de": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_94a88227eb484887a751d951a09a7dca", - "placeholder": "​", - "style": "IPY_MODEL_57ef49ed4bb342de9c269a7b1ee5b8e5", - "tabbable": null, - "tooltip": null, - "value": " 366/399 [00:01<00:00, 357.33it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "bdb137f7a4a846c2b65249870ef077a1": { + "c31b7e861d8d434c942059cbc3aa8c46": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39443,11 +39886,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "bde3343143414690b98e52981d1e8a00": { + "c362d1e3e37e4187a2d162b1392ce90d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -39462,16 +39905,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_5bbb8ff7901d448eb0f10c47b06f2aa7", - "IPY_MODEL_1af8a41f5c224b1e84dc8f3622533e49", - "IPY_MODEL_73b020aab87b477f9258d472e64bc365" + "IPY_MODEL_eef249c202ee4cbeb7646bce26e0319d", + "IPY_MODEL_ba9158f846de4863bef5b2aced1b8b9c", + "IPY_MODEL_4c566f260cd74358803899641e909308" ], - "layout": "IPY_MODEL_3fd50bcca0f145c4b6c8bb0ce641de02", + "layout": "IPY_MODEL_7a829f82d7c1421cbb720a434f9151b5", "tabbable": null, "tooltip": null } }, - "bdedb6a47a414802bd6698cd66f68ffe": { + "c37961812de6410f8f4d1aa6569133e8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39524,7 +39967,7 @@ "width": null } }, - "bdedd0f78dc04a9092d61cd8e78bfb1b": { + "c38b8462ba7b443ea92227e7328df0fd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -39542,30 +39985,25 @@ "text_color": null } }, - "be76a31489ec454aa52489f09467f1b4": { + "c3af69049e2e4ed7a62a01913f109e6e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d296ccd6bf49443981d59d7e68532601", - "placeholder": "​", - "style": "IPY_MODEL_54531304ad2846d09aba8946da77c4a8", - "tabbable": null, - "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "be92533c011b48bea564987edff34fb3": { + "c428c7b2a924486191a6fdf6df696810": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -39583,131 +40021,95 @@ "text_color": null } }, - "be965ce8c8a94db38758b5661cee6f70": { - "model_module": "@jupyter-widgets/base", + "c43f7932862a44eabb362bb93a935920": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "be98edb504fd4e7197e1758e0f873097": { - "model_module": "@jupyter-widgets/base", + "c4739e4f68a64bed90b7aa8b4a7295c8": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dbd14503868a425692bfa7a7954d09ba", + "placeholder": "​", + "style": "IPY_MODEL_06e0d6c5ba154c32b21d3708c8e41a89", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" } }, - "bf3b64c6daf34adb94322fe66be5485c": { + "c495d0dedb764061a90da24cc6f0c550": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0f80f42d60484e3f8df239c941ebf463", + "placeholder": "​", + "style": "IPY_MODEL_33fb64d45f4346d3b3cc7ffc662f021b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" } }, - "bf4463cbac7d42b0a19933ba30bdf6e2": { + "c4ae7aef6b4344d2a097751d7aa41aae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b7d4ed5765e4aca8bb6141cc943eed9", + "IPY_MODEL_e048452aad634e41a1873392f34e9599", + "IPY_MODEL_1f94c34da1234a3796318665b1a050ed" + ], + "layout": "IPY_MODEL_9984f32d9dd64aec962488033710b053", + "tabbable": null, + "tooltip": null + } + }, + "c4b1311267c547d49a44b43cabca5f8c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39760,7 +40162,7 @@ "width": null } }, - "bf456be96f914092b288ed4e48c561cc": { + "c4b6b898846b4fdbbdf55c1d23641015": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -39775,15 +40177,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_064f561913a64aa18e47a14c7d705634", + "layout": "IPY_MODEL_68eb60fc9da1475592a83cd04a5031f9", "placeholder": "​", - "style": "IPY_MODEL_0ab84b3feb0e4fb9b398271421a62892", + "style": "IPY_MODEL_9002601ca82340cd832f6c7b0117e3c5", "tabbable": null, "tooltip": null, - "value": " 36/69 [00:00<00:00, 352.33it/s]" + "value": " 771/799 [00:02<00:00, 362.93it/s]" + } + }, + "c4ce70f380c14c1b9c6d133b1a2370d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4385eac2a71c42dd89450f825481c940", + "IPY_MODEL_4fc6fbe0a5764a91bba7fa27bedd1bc6", + "IPY_MODEL_6de7f42dafb741e5a8402de2b4b91feb" + ], + "layout": "IPY_MODEL_1db4a1ec464b474882ea4462a65a0207", + "tabbable": null, + "tooltip": null } }, - "bf492ab8ac014baca398e925490bb137": { + "c4e6a3d86d3e472eae5dde2c7d5c33e3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39832,29 +40258,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "bf4bbe0b25dc4e10b62fe8bc681d0832": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "bf77029b1b3f4ffab6ec030eaefd0fc5": { + "c524e8e8d009453b82883312c7f6db7a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39903,11 +40311,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "bf942b0276b340fe97e503e5c27eb4cc": { + "c52f5fd51c52437ba271b3c4a7c66eef": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -39956,47 +40364,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "bfa9cee298b54ec6a62631fffac02d3c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "bfa9cf76b606481e8c8e2c2e59cde948": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "bfc68748100d4a7ea463cc6f96ab8087": { + "c53b12a5e77e42fe9ecfceb69fd60ce3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40045,35 +40417,34 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "bfc944d484a94e58bd83f79ca47ea60b": { + "c571657ec07346adacaa4c32f1ea4aec": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ba338c46b14f47668ae298f2cf3648ca", - "IPY_MODEL_0fd9e4cf02f640b28c1218a6c408a1eb", - "IPY_MODEL_d6424cac3fd944c4a898ed54b60eb73a" - ], - "layout": "IPY_MODEL_6d3b327094f54cb48f6be0adc8283f2e", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ad24b73e4e034dfb8d0723ab0dee29e7", + "placeholder": "​", + "style": "IPY_MODEL_ba0e5cc96a50429bbe81af86f5331268", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" } }, - "bfe66051460d4067b93fc18294eb6d9d": { + "c59d0110443e4dd393b0e56575c65457": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -40088,33 +40459,41 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_fbfe74b86bcb4805bf8b2bece1f9c2c3", + "layout": "IPY_MODEL_9d92573db7f74978aeff421e3a2205ed", "placeholder": "​", - "style": "IPY_MODEL_2de0edc89e0048bda7a1a1f4ef9914e0", + "style": "IPY_MODEL_e7ac81ff8f8f4e72b521f979fd70caaa", "tabbable": null, "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  95%" } }, - "bff4ea0a24ee422ca96c1da962266275": { + "c5d432a4377b4c0491e32157f5ede3cb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e2a732f2f4f147c591689b6e319fc62e", + "max": 69.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_99ecdb24af234e8793f4937602f3665c", + "tabbable": null, + "tooltip": null, + "value": 69.0 } }, - "c01615d310244dc793bf18a43f795ea1": { + "c5ecb7909c8d40269c90a9f4fe5b34b6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40163,11 +40542,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c04222edb66a41d89829c004a0a610ba": { + "c616b7e586454f82b9b2be849f4e26dd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40216,52 +40595,64 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c079814cdff147f29bc359e80c0d939a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2e77c5df0a71486c84a989a79338aeaa", - "placeholder": "​", - "style": "IPY_MODEL_20addb377519462bb870e2a0d73d2545", - "tabbable": null, - "tooltip": null, - "value": " 36/39 [00:00<00:00, 354.96it/s]" - } - }, - "c09575ba0b07438bb3236b145d560c6e": { - "model_module": "@jupyter-widgets/controls", + "c657a9b6ef2143e88e2882cfa7cfcd8c": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "c0b8ed31060546adbec7628e74034b36": { + "c65a35fa56134366aa5d0222a2cb839c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40314,7 +40705,7 @@ "width": null } }, - "c159c6407cff49d4b01c7854215df991": { + "c67002c2c2fd4b089cb1486f916ccec9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40363,11 +40754,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "c175f1bc85e342d08c1dd6191c573ad0": { + "c677aa821c394a3da2c9a8d555633c37": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -40382,113 +40773,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_47e2f57dad3c43518d3178fbc20e8bf1", + "layout": "IPY_MODEL_ee39a6894158481b9e62dcae6ebe9b22", "placeholder": "​", - "style": "IPY_MODEL_681f63faca654225afd68d7584bd114b", + "style": "IPY_MODEL_91a21eef705d4fd2b428e47ea6a31022", "tabbable": null, "tooltip": null, - "value": " 0/29 [00:00<?, ?it/s]" - } - }, - "c1cfd029710349e8bb2a6720ae411985": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_34a37b01cd294532a190c763be2a9da8", - "placeholder": "​", - "style": "IPY_MODEL_47ea17bfc0014d8796cce6ce9acde73b", - "tabbable": null, - "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" - } - }, - "c1d5610dee5a455094329f5deb02f19d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6c6a06ed639a422c8d8853ff59c4b1b7", - "placeholder": "​", - "style": "IPY_MODEL_f6503a830d434dd882251cd6c1f7ac35", - "tabbable": null, - "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" - } - }, - "c20529aa220d473dae1d370e432453d6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_39c042dcb8344985a71093a151c39b1c", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_98eb1189f08a4fd0a1ca39dd50787b21", - "tabbable": null, - "tooltip": null, - "value": 999.0 + "value": "Converting outputs to QuPath JSON.:  61%" } }, - "c21eb73ba424423e86846d7447dc2b49": { + "c6f29e89b2e745199cd9425ebcbbe3cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_48924959c23d4d958c4403bd38a9021a", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ab7ee20281f048f4b741aef6e2a4720d", - "tabbable": null, - "tooltip": null, - "value": 299.0 + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "c332cb2d0fd54601a8b7a7da97c30057": { + "c701fcf1276d48ea97a061a20923965f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40537,11 +40848,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c33c52c3471c4014aac152806596ceeb": { + "c72775ada44b461ab7fa9565fdc6df95": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40594,7 +40905,7 @@ "width": null } }, - "c3457131356c451c96a4118222ec5184": { + "c76331bbc2b049788ae8560b9fd55e05": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -40609,62 +40920,42 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_026f1affcc3f4093bef8fd601c5e9a78", - "IPY_MODEL_ffcac9706b364ca2894cfc605bd022a9", - "IPY_MODEL_f97c1575a84540a0abfcc35889af58fc" + "IPY_MODEL_03665d92883945c1813c348ad9c23bc9", + "IPY_MODEL_20f126d0e20f4d94b8112e0b5e42fba8", + "IPY_MODEL_ce553c3eb99b41b186678afbf983a9fd" ], - "layout": "IPY_MODEL_b18f0cf4f37545aeabbfd819430fc1c1", + "layout": "IPY_MODEL_03bf9748f94e40ec90195f6644bca4fa", "tabbable": null, "tooltip": null } }, - "c34f858766a54c92be832fc10138950f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b5c7bbcce984435b1cf4c7029aec5c8", - "placeholder": "​", - "style": "IPY_MODEL_b882b0e063c045c5a46aef794493b4de", - "tabbable": null, - "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" - } - }, - "c3b352168ac64b7da2c4d78a0fc9e3ca": { + "c79c3be719a04acfa77bc4c68e28e613": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_5be3715daf394859a1394ae797100c33", - "placeholder": "​", - "style": "IPY_MODEL_c94cdfbd65db4c9a98898a5de81a7a72", + "layout": "IPY_MODEL_e3a64d4b2cd941ee96f15bbfb55e8c54", + "max": 39.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_982a7911c5c04321a7c403bb3a7b9f96", "tabbable": null, "tooltip": null, - "value": " 778/799 [00:02<00:00, 365.71it/s]" + "value": 39.0 } }, - "c3c065a140994fc6ba7159dd86bc86a1": { + "c7ea9135f6c843089e877d5afb5cccc8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -40679,39 +40970,68 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_cf1211799c9f4ac1819a38141b6a6b4c", + "layout": "IPY_MODEL_6715d57bc74a413a8b3eaa2ef2b87dba", "placeholder": "​", - "style": "IPY_MODEL_b980250f39ad4e99a016bc8609dbbc0e", + "style": "IPY_MODEL_40a8d9c0248b4e449b75f4a8b63bd10e", "tabbable": null, "tooltip": null, - "value": " 185/199 [00:00<00:00, 331.82it/s]" + "value": "Converting outputs to QuPath JSON.:  61%" } }, - "c3c7fd263831473a8499892f20bc17d4": { - "model_module": "@jupyter-widgets/controls", + "c8059fda20914291a75cc4ab842f6406": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6615bf33ecc44a3da71c0b8e04ed8e6a", - "IPY_MODEL_5609fd0412844df48ad4d91d90137947", - "IPY_MODEL_23544f3341004d698f38b4deb7bc262f" - ], - "layout": "IPY_MODEL_6c0e153016a94e5a8300a31fad2acea5", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "c3d0c68500644bae8d230838bc33bc9f": { + "c842ccf7da0e4030b16b302aef76719c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40760,11 +41080,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "c3d1a25262e345c784d032f453a9354d": { + "c88eee9aa73944b19d561248372b2fc8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40813,11 +41133,37 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c3f3bc3d118948e6807827c79cb1e194": { + "c8d288224f454e9db253a567893fe151": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_23b47b57d93947fd8c2644f14c39645b", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_756dbf15767f4d0598abcc9cb70f4b75", + "tabbable": null, + "tooltip": null, + "value": 699.0 + } + }, + "c8d5ef092d1d4603bda06b82071593ca": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40866,11 +41212,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "c40be986db794cd58b1b129f5abc33fb": { + "c8e922f3f5b641c8bce261d1b6062231": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40923,23 +41269,30 @@ "width": null } }, - "c41a6a91c55047bdbf640b77fc219514": { + "c8ef1c6dcee744ad84c94c48775e95f7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_396fde55ae5049598649c8ae2bddc37f", + "placeholder": "​", + "style": "IPY_MODEL_b4aa2ca5638b4c19b45abc9c5fc14fda", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" } }, - "c435008f3f544ad2b2494ea4170ff841": { + "c8f528ad011b4bceb1af3db800487ba3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -40992,7 +41345,74 @@ "width": null } }, - "c44ee9e2b04a4fd4916ccfd57ce4c005": { + "c8ff767e6a6d4b9cb1e2117558a1c911": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2dd25c677b4a4b7c9e28fb07ac22afa8", + "placeholder": "​", + "style": "IPY_MODEL_aaf5c3e8883f4c0faf7cf6d1f702f0f4", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  73%" + } + }, + "c921c87c7bd443e5becb5d4c0dc16cba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c922748953f446f48477412df7b093ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c67002c2c2fd4b089cb1486f916ccec9", + "max": 49.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6495b65e6e714f148a39632ce70a5b36", + "tabbable": null, + "tooltip": null, + "value": 49.0 + } + }, + "c973fe5b30d949c483b8928d4df30dae": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -41008,31 +41428,139 @@ "description_width": "" } }, - "c468ce2f3f1d4246986e60c4c72b86ae": { + "c98457e46a5d4643b0a8452123210f52": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c9a9a4ba171741e7bf0cc39b57eabb17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_70354077febd42db84a54d2bf0fc088f", - "IPY_MODEL_23d407b0c7f74a0c85f8d771e72b3e4b", - "IPY_MODEL_7e42c9deb4a04e2b8e5a2fac4026125d" - ], - "layout": "IPY_MODEL_752ad6e08aeb4421af878c91a4a38e5d", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7f309413defb45bb966bf925a2d16ef4", + "placeholder": "​", + "style": "IPY_MODEL_1abd526f7a964f82b5169926d97b7128", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "c9cba4fb0c944f2ca7e6cbea08c85815": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ca0111b7c36d4e4ca558ce7cc1d3e3e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_873ffd5da8b949738a6f6bc01a08964c", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_51026c4262f44fe8ac18df399729f0f2", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "ca46d5b4b9f54df79bcb2845bed3aca8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1b15cd7aafa8471d922c367abaad9d55", + "max": 29.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_70df042231194fbe82ead72f6b9f2e60", + "tabbable": null, + "tooltip": null, + "value": 29.0 + } + }, + "ca4ac9a2f5c643d2b16f01cba836bb86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_611a93bc2af04c36b77c8f99abdba83f", + "placeholder": "​", + "style": "IPY_MODEL_c3af69049e2e4ed7a62a01913f109e6e", + "tabbable": null, + "tooltip": null, + "value": " 0/19 [00:00<?, ?it/s]" } }, - "c469f539c05241afaa7884fa3a7b7f60": { + "ca63e6ec056c4aa481e9895ffec8aece": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41085,47 +41613,113 @@ "width": null } }, - "c5005137026143fba21d826016c63a74": { - "model_module": "@jupyter-widgets/controls", + "ca93f86926934301974942581dc5a8f7": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ad9a82eb73344ff5bad6273bd3a47485", - "IPY_MODEL_7ac5a584492f495e974cf19baf7a1aeb", - "IPY_MODEL_79afd59b049d4f68a33a08106aeb2c48" - ], - "layout": "IPY_MODEL_52b006d485404abb9fc87e2998bea48f", - "tabbable": null, - "tooltip": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "c5845f14cd234dd88eb917236dc1ea7e": { - "model_module": "@jupyter-widgets/controls", + "ca9af381bfc94c53aa88ca25837197d6": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "c6043c8957ef4a2aaee1dae93c485efb": { + "caf0796924964acb90582ae00f5c08a5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41178,7 +41772,7 @@ "width": null } }, - "c6186a9115e840bc813315a474bcb455": { + "cb0f6075ac614de19e87d0c4d55a5ecb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41231,7 +41825,111 @@ "width": null } }, - "c61c49647d074eafbd5c1537449a6300": { + "cb25640fd0154a4d827daec1dbf7ec27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_af746d2e44ac4f3e85da91000e5637d4", + "max": 99.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_79a40931a67a41399ce56fc2a2b7ac89", + "tabbable": null, + "tooltip": null, + "value": 99.0 + } + }, + "cb55b181a2ef4d43a46b1ffcb8b4bdbf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cb6e24d8a07d49b7aa6e4275131dceae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e0141f92f21c4f5891f19a9e5038f90b", + "IPY_MODEL_ad3316882f9a4bb2938b634b5eaae4be", + "IPY_MODEL_8fa39122b79f4c2ab144890149bac228" + ], + "layout": "IPY_MODEL_d94f9bfafdc44a45832805c9467bcc90", + "tabbable": null, + "tooltip": null + } + }, + "cb8319dbbdda4d9b87ca200f04c8831c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cb877600828f4dd5ab04c06420361ef1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cba998b96e4f48468e6eea4fcae8c1ad": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41280,11 +41978,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "c63f98624a854b9fa5db5fbaf96bdcf4": { + "cbd01f9e92e04f2fa3a0add1d4474ff9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41337,49 +42035,7 @@ "width": null } }, - "c674d4ec6c604723aad0af9ae612c8a8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c68e2ef7a47c419391782502effd9fbc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_438825657f4449708138c78415a3e239", - "IPY_MODEL_22392eb6be534bfda8c55756fe6f84ba", - "IPY_MODEL_b7eba7cfdcf7448c93712428f4fa57dc" - ], - "layout": "IPY_MODEL_2e92a5fc089c47d6923d68205e464c19", - "tabbable": null, - "tooltip": null - } - }, - "c6a5910106054e43a5c14f3e688b1297": { + "cbe03234c932448e8af72c157bfe2670": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -41394,33 +42050,39 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_b619b1f451714ae39ee040335567b356", + "layout": "IPY_MODEL_e025e75bc1424647bbd4fb04e8a5a0c0", "placeholder": "​", - "style": "IPY_MODEL_8e8f1de56f6647fbb3b5e7b86bf0a295", + "style": "IPY_MODEL_3fd7b789706d482c8684f49b74e26645", "tabbable": null, "tooltip": null, - "value": " 36/39 [00:00<00:00, 359.45it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "c6a5eb1881f941b8a7abf0ab2e5b31a4": { + "cbf046394c764635801e3e2d509ffe01": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f9051fa31e80442c8391fab3d2284a29", + "IPY_MODEL_39a90639d94446d18d9b2080c488c55e", + "IPY_MODEL_7eb4a998e8fa48d696ee4de69e090856" + ], + "layout": "IPY_MODEL_b19509231b4f404e99b700fa4222d73a", + "tabbable": null, + "tooltip": null } }, - "c6ca16b56fb84b379b715bfe58d42734": { + "cc00eab9c91e4f519f399f6444bc3813": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41473,7 +42135,7 @@ "width": null } }, - "c6e0e8835ce34e21a3a4ddf1e0bd3c92": { + "cc27f756a8e34122a05dd186ee8f17b4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41526,7 +42188,7 @@ "width": null } }, - "c6ec5a672f2d4b289c1d6319fb96229c": { + "cc6f4ec9dd164fc7bdb8b702cb8de8ba": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -41541,15 +42203,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7d7bce6493db49089fffafc473535096", + "layout": "IPY_MODEL_0e418415487743fc92d75f83c3f16a4b", "placeholder": "​", - "style": "IPY_MODEL_75e0a5581429468dbb12e4f0523baf1e", + "style": "IPY_MODEL_9aeb3efbdaa24aadb2577b5738df3118", "tabbable": null, "tooltip": null, - "value": " 0/19 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  98%" } }, - "c707f497aec24165a474eb94658f6fc6": { + "cc83b4ec96674f2b8af46552fcedd93a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -41567,60 +42229,140 @@ "text_color": null } }, - "c738d79f3d734fe6ba01ac5d9e67d82e": { - "model_module": "@jupyter-widgets/base", + "cc84ab39a0134034830163b78cf9dff0": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "FloatProgressModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b31e3578fa894e8e904e1157619b8f9f", + "max": 19.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_342cf62186f34af0aff6b7b096df814d", + "tabbable": null, + "tooltip": null, + "value": 19.0 + } + }, + "cc9dd0c316dc4fe983eddd4dbef18729": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cd15bcfba3794c6f8fe2dc68d5a4b0dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7353f29152ef4e619142ca03867eb216", + "IPY_MODEL_0cf89b4042ee44f89d3e53c4e6671756", + "IPY_MODEL_afbadadb9c7040e583e17e3de4cc4d84" + ], + "layout": "IPY_MODEL_f6dcdd6bb38d4abeaf265f7245b80c41", + "tabbable": null, + "tooltip": null + } + }, + "cd226cc365dd4eccb39f625c8c03326d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9f65b68e5ba34a669072d06e5a3c84d8", + "IPY_MODEL_b6e6896f050b4ab0b73041502a4bc634", + "IPY_MODEL_9cc272d377ce408ea3031d099f2a28eb" + ], + "layout": "IPY_MODEL_246331bf94644fb7a7bcffac32433bbb", + "tabbable": null, + "tooltip": null + } + }, + "cd36700303a042768902ae689e70cfec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6932fdc9d9184aab96f40553cd268888", + "placeholder": "​", + "style": "IPY_MODEL_23cc90104e2649a0986b899e3974e9bc", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  81%" + } + }, + "ce327262338e4a7aa9c1ccd0ff047916": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "c77982866f444d27a8a2ea4f78e7e52d": { + "ce43d772afb5428db34ae169dd81b13f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -41636,17 +42378,154 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_40b2e835983b41fb9019401c0cbfe733", - "max": 69.0, + "layout": "IPY_MODEL_543e8a4b06ec47a199fe311302e6fdba", + "max": 499.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_76afe945b755482abc45b5e568995a6c", + "style": "IPY_MODEL_48eefbd8bed542dc8d598b294fb4e40b", "tabbable": null, "tooltip": null, - "value": 69.0 + "value": 499.0 + } + }, + "ce553c3eb99b41b186678afbf983a9fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d08b5666856d464e9eeaf090dff5e640", + "placeholder": "​", + "style": "IPY_MODEL_ffef49a7ff1a41a4b48c5382e0336f04", + "tabbable": null, + "tooltip": null, + "value": " 0/29 [00:00<?, ?it/s]" + } + }, + "ce55b4346d934300b7e8f21ed5c19d03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_02597743ea5f499a8259286469b67915", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_166610b9a0504e9bbd32e9a1554c15da", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "ce6542c58d6443049406b95884863a2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fdd36602a7484bc7bb923e33c6cd0494", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_da07ce2dcc304a3f9d15e1c9062db95b", + "tabbable": null, + "tooltip": null, + "value": 79.0 + } + }, + "ce869bac5f45494b879e026a3bd151b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5f10baf4878c4921b828d169f62a07a9", + "placeholder": "​", + "style": "IPY_MODEL_1a4e03a2097f45d49dc3cfacffdcdcc9", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  61%" + } + }, + "cec5af9fa80247e98501b47d2c827981": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0fb58817bee248f2887227e04a10e2c5", + "placeholder": "​", + "style": "IPY_MODEL_3ca7bc0a6a654d979b4531e9e7054a9b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  91%" + } + }, + "cece0c2c564b45c99a80874f42eb277a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "c77e8912fea94fe48c143e507b5882a2": { + "ced3faa091c2469cbbec4a93c24d75f2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41699,7 +42578,7 @@ "width": null } }, - "c7b23113d4dd49cbac62b15e6b6b4c4d": { + "cf765084dad944c38c10ce353dce6ccf": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41752,30 +42631,7 @@ "width": null } }, - "c803853185e04f32b8898930aed802a0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_598b6ac16039453495eae42adabdfc72", - "placeholder": "​", - "style": "IPY_MODEL_adbfcdc5027c4ba798eb04931bd5e539", - "tabbable": null, - "tooltip": null, - "value": " 37/39 [00:00<00:00, 360.46it/s]" - } - }, - "c809df67f0f34d61932887bce3873785": { + "cfa98cf631fb467fb44af939ea163fa3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -41790,15 +42646,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_be98edb504fd4e7197e1758e0f873097", + "layout": "IPY_MODEL_37c799e1455849f391c1dbec1e9b9911", "placeholder": "​", - "style": "IPY_MODEL_bf4bbe0b25dc4e10b62fe8bc681d0832", + "style": "IPY_MODEL_f8dbf0c04e3d43f6a225dfa66f1cbdb9", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" + "value": "Converting outputs to QuPath JSON.:  74%" } }, - "c827f36c27a748fb81618a1d472d47ad": { + "cfb39d3fa8bd4f38aea2de288a4d93fc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41847,55 +42703,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c830aa04c7bc42c6acc672400ef68a90": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9ea39809e1ef4d01adf80f76422ba7d0", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_2ecfa31322e4498d9bdec04ab535b826", - "tabbable": null, - "tooltip": null, - "value": 999.0 - } - }, - "c883da9f1be14cc7b0994683eb3b6426": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c8c0e1f905b24acdbfa568cdf6ee23d6": { + "cfb43e4412694e9eb8a3f79fdf54e909": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -41944,35 +42756,34 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c8c46930c8114b418e073703a77d938f": { + "cfdd5e0d62f042c585b3c8b4ad673755": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e6594f8025eb406a943bb1e8af05ac00", - "IPY_MODEL_6915182708974687bc9a94f20011c6fc", - "IPY_MODEL_0ec6c1a9fa2a4df48758b1978a5a2fd4" - ], - "layout": "IPY_MODEL_f5972963a4fa4aaba90a273cf6d6c1e6", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_552e637432da49fe91cfc854e17dfe05", + "placeholder": "​", + "style": "IPY_MODEL_75f7c3a2ad1b4c66af6bdbc7569dd562", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "c8f3a5a0ecb24b4cbeff56656bb55f5c": { + "cffaceef4a504348bc269dfe245819e2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42021,11 +42832,37 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "c910b59dbd4e48f19a1c0961edfebad0": { + "d0053b1b867b45e7bf082a6805e26b93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_354921b909f34c399e4630cc798e2fea", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_50aecebdcb3a4071850937a19d4d5f4e", + "tabbable": null, + "tooltip": null, + "value": 9.0 + } + }, + "d01b9c6e22564874b055dcf22995909b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -42043,7 +42880,7 @@ "text_color": null } }, - "c9353fd9741940e889fdf60256660075": { + "d01d58d95c064216a7b3770f1da7d1c6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42092,79 +42929,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, - "width": null - } - }, - "c93a404c543d45a3b916e20eb761958a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "c94cdfbd65db4c9a98898a5de81a7a72": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "c9a6a71bfcfd4a75bb716c66ecd4b731": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ca0d3acfcff7449bb13429b36b0075f9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "visibility": "hidden", + "width": null } }, - "ca1248100bea43b1b7758f88369fff6f": { + "d08b5666856d464e9eeaf090dff5e640": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42217,7 +42986,7 @@ "width": null } }, - "ca5ece859f934bc9a25c0452368699cb": { + "d094d6862a6a4b32a70369c867dc21a7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -42233,7 +43002,7 @@ "description_width": "" } }, - "ca6ad57cfb5941159f5f1c6b055c5183": { + "d0b41e8c5b6a4f23b6c104c307736114": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42282,11 +43051,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "ca90ea44457344ebaeac61889a8d37f9": { + "d0f1dc6dd7874991a453cfb2cb76e508": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42339,100 +43108,7 @@ "width": null } }, - "cac5a08da220495296d54d267dc6e766": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_bf4463cbac7d42b0a19933ba30bdf6e2", - "placeholder": "​", - "style": "IPY_MODEL_0638947f16b941a39beb81ecb130627f", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  52%" - } - }, - "cac9c307cd2049a5924027fdbeec1a59": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_234835fc04c8441ea0afa11669ca3eee", - "max": 59.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_e1d99bf069ad436fa518ce03ee782d19", - "tabbable": null, - "tooltip": null, - "value": 59.0 - } - }, - "cbcd4929cb02433ea2c8ddc1cac80849": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "cc625e16f1c64d55a0d24ea0984f4d81": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_829902796e8447b6acf6ab15b5c29da8", - "max": 89.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_1ebe8286cec04816be72266652031bea", - "tabbable": null, - "tooltip": null, - "value": 89.0 - } - }, - "cc7500408b274601a1c97553d24c9900": { + "d176d26c1dfe4751a1b445e904475864": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42481,11 +43157,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "cc840cc144ca42c48191a10a6b063c19": { + "d18f6ac289ef4feaa12e9a15b078f60c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42538,7 +43214,7 @@ "width": null } }, - "cd11f22e25c846faa451cdad41307736": { + "d1d7d6dc779142d7906d8c2537b469c6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -42553,54 +43229,68 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_584bc0ae47744194895f073406ef9ae1", + "layout": "IPY_MODEL_295c626c6e4347e8b91c309531cb9b91", "placeholder": "​", - "style": "IPY_MODEL_3b0331d33a3646329714a68beaf02f9c", + "style": "IPY_MODEL_8aa98fcd15574e298f63640511291eef", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  52%" + "value": " 366/399 [00:01<00:00, 359.55it/s]" } }, - "cd23969b19544ac798b5505542a1b869": { - "model_module": "@jupyter-widgets/controls", + "d2399abf03b447e9990d21beed5e849a": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "cd4ce0cefe9a40889d773a60ceb7f1fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a4f115a5e1434f97955e0ff7264f8afa", - "placeholder": "​", - "style": "IPY_MODEL_3d7e9659a6924121a9f24c8517430a0b", - "tabbable": null, - "tooltip": null, - "value": " 37/39 [00:00<00:00, 360.22it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "cdb80c4ecc0a4a26aaa7e7b207a8a0fb": { + "d2b985e214fd43ed815e5c8e5fcbe54d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -42615,51 +43305,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_a6d07bdeb8914e1ca87a5a78ce2dcc9f", + "layout": "IPY_MODEL_1ce013f55b0d45d78b3293578964e2de", "placeholder": "​", - "style": "IPY_MODEL_fb9674d226bb40b08c8298d5ce890e00", + "style": "IPY_MODEL_98bdd8aeda3e426bbdd7d1b9093fbdc1", "tabbable": null, "tooltip": null, - "value": " 664/699 [00:01<00:00, 363.41it/s]" - } - }, - "cddcb3dbed6f4acabdf059adde3e8f58": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ce4f691af9a5482a85053f82ccc34097": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 36/69 [00:00<00:00, 350.63it/s]" } }, - "ce60bfb1c1a842e7b793f3562da27f9b": { + "d2ddb887eed049ebb0ab1affe12ea42e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -42674,41 +43328,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_5aad76ecfafd4c83b448e4354f7c6f42", + "layout": "IPY_MODEL_0220b9c42e2b448ea030289b9f44cd72", "placeholder": "​", - "style": "IPY_MODEL_1e55dde614fe458d843e223be3c29836", - "tabbable": null, - "tooltip": null, - "value": " 36/59 [00:00<00:00, 351.87it/s]" - } - }, - "ce629a218e934721a444d3b9775ad415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f60813e1af0e455a91a87f1be8d113ce", - "max": 799.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_fc3a225ed50b4428852f0b94fa4a5066", + "style": "IPY_MODEL_36d162ea214f42e48ca91c237defbfc6", "tabbable": null, "tooltip": null, - "value": 799.0 + "value": "Converting outputs to QuPath JSON.:  96%" } }, - "cebf00b01b754b50978d3e6b980d98b4": { + "d327c6ddffaf4d00ba2af3aa0acc0971": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -42723,16 +43351,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_830304cced404723afbaeb3a9c1ca6ba", - "IPY_MODEL_63c18b60c8b340ed8ea6b0e878cf2c69", - "IPY_MODEL_9d1b19421f184307b1b8d776ef202cf6" + "IPY_MODEL_30e266582f974a3e930f9e56f2395317", + "IPY_MODEL_1f75704140cc422bb31491822c43c016", + "IPY_MODEL_5645cdf3b34b4392a1d35079df931019" ], - "layout": "IPY_MODEL_3f0db553b10748598540cde60822e4f1", + "layout": "IPY_MODEL_08f2eb43ec5744e4a0cf47e083e8d02c", "tabbable": null, "tooltip": null } }, - "cedce37f6c804bc587aacc4247b7172e": { + "d327eaf2e15f4a298e81d9a7dd514726": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42785,7 +43413,7 @@ "width": null } }, - "cf1211799c9f4ac1819a38141b6a6b4c": { + "d33a4ea743e547aaa576bc4042d73bd2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -42838,107 +43466,7 @@ "width": null } }, - "cf1a7d94e72841658cd8b9b9a641400e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_952c36ed6d154fd9bc2778f7d7a157a1", - "IPY_MODEL_194cd83a23854561931c7f0c17fe6dba", - "IPY_MODEL_750888b11d054b8abf80aba23ff3b7d3" - ], - "layout": "IPY_MODEL_a08a766751ea409fae236604550a3568", - "tabbable": null, - "tooltip": null - } - }, - "cf2dd5279b0f42dcbb04a738db897ae7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "cf3b4a67086448cebe38bc0df9b57135": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_288fb6b917c54da3a47b962f1c563580", - "IPY_MODEL_a336db13ecb1496f889be30676adc46c", - "IPY_MODEL_9068eeed80a84a5e993cde7355727880" - ], - "layout": "IPY_MODEL_255b617c965b4b66a67b74ce249e7643", - "tabbable": null, - "tooltip": null - } - }, - "cf8d72605023472e93d5fafcb932a082": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "cfa71870608b4ee39b049c352412631e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d0341cebf53b49658928e1655458a47a": { + "d3635dfaf62b4a8c9e57873ff9288933": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -42954,17 +43482,17 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_3004d918d6194963b440047a854d88db", + "layout": "IPY_MODEL_9676ed1964754239a89e1d2fa069d79a", "max": 39.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_42beb3b6bf184a8b9efc062bb0900394", + "style": "IPY_MODEL_f780a85649ec47699f7140baa4652d45", "tabbable": null, "tooltip": null, "value": 39.0 } }, - "d0378c9c2cc049c98bd4ff706f607836": { + "d3898e3187bf4657b9e4fd9afa7ccc5a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43017,98 +43545,108 @@ "width": null } }, - "d0a6d8f78e6942078f7c54f5c1032dea": { + "d39418e9914e4a8fa76cd325562fcf83": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "d0a9f7554f944deebad0e0f494e0b340": { + "d3f2c6a8fc8e4a10acb082c97ab84d2f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_05ae8b0f921d49dcacef411f7595984c", - "max": 39.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_fdbe2276e07f44be967abd7c5011727f", + "layout": "IPY_MODEL_59fc372b0c7d47c6a1ad2bb5aafda9e5", + "placeholder": "​", + "style": "IPY_MODEL_231757bf988b424d9cbfe5d97da99630", "tabbable": null, "tooltip": null, - "value": 39.0 + "value": "Converting outputs to AnnotationStore.:  98%" } }, - "d0c171049d8248c5bfcdb5ae6eff2133": { + "d40abf57cebd453e97820cfa59293dda": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4c80b515bdb44d03958857081b7ff066", - "placeholder": "​", - "style": "IPY_MODEL_aa9fd23d74804b7699edb91ca672e49c", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b072f1110efe447c90112dc0a98a55cb", + "IPY_MODEL_5ff96f4a3a5444bb9b543597d2b7519c", + "IPY_MODEL_24d6ba13377444a3bafa63f99d322c2f" + ], + "layout": "IPY_MODEL_ca9af381bfc94c53aa88ca25837197d6", "tabbable": null, - "tooltip": null, - "value": " 368/399 [00:01<00:00, 364.54it/s]" + "tooltip": null } }, - "d0cd5a3f9a354b62b37c9c000e6c3454": { + "d4a59925d41f4714afe016dec372cae4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_fb15edefaacd4f979ac5da5786c68525", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_15562d5515c54685a0418ac312a70993", - "tabbable": null, - "tooltip": null, - "value": 999.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d4fc06e666b649b98d1dd2342638a689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "d0d6bde4d189485294b8de5496d5badb": { + "d50e3513bd4747178debc94d4cf7541f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43157,73 +43695,117 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "d0f8a3ab51954f1391a21336ef2ed4e3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_08b2544827604ac88f95a23a1587e481", - "max": 79.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_7947d8d88c46427286df33834c3e2dd7", - "tabbable": null, - "tooltip": null, - "value": 79.0 - } - }, - "d12c7f9fe8f949c5a413058f75fe9159": { - "model_module": "@jupyter-widgets/controls", + "d66f792529a1444199f52bc3c124b78a": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "d12c898e7e1844788d3d748ad2bd8167": { - "model_module": "@jupyter-widgets/controls", + "d675401634b24c11be48ebdd652ebd85": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "d134da8a49084494b6f03e8ffe269e5a": { + "d74dd6f6eada4adba7d67d89248681d8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43276,7 +43858,7 @@ "width": null } }, - "d1b7b0961a1f485e9e7b06cdcd9e38fb": { + "d772f36f1ef44ba9953b55f6e134c017": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43329,7 +43911,53 @@ "width": null } }, - "d200bdfc11a547a9b3f6b6bb42e203b1": { + "d7760ab9078e42f0b6da1798ac958216": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3bcedaf0d88e430681282dab48bc18c2", + "placeholder": "​", + "style": "IPY_MODEL_1c12006a3dc14f73b4cc0284d4e1a902", + "tabbable": null, + "tooltip": null, + "value": " 72/79 [00:00<00:00, 275.59it/s]" + } + }, + "d77ee350aa984be6a497883e1f64a501": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c8059fda20914291a75cc4ab842f6406", + "placeholder": "​", + "style": "IPY_MODEL_23b7b638353145eeb23230747a0e18c9", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  99%" + } + }, + "d7f04cbb53ca4475830eea8769609bac": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43382,7 +44010,7 @@ "width": null } }, - "d26745479b864b0d84dff122455f8a28": { + "d826a2c7e5b04783ba7fb089403f8ddb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -43400,7 +44028,31 @@ "text_color": null } }, - "d296ccd6bf49443981d59d7e68532601": { + "d8baba81a7db4e5bb40b757c58935229": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c59d0110443e4dd393b0e56575c65457", + "IPY_MODEL_ead251cae6bc4301b42ac54b82befdf2", + "IPY_MODEL_550dfcb586d24a81937f730e4e75a39a" + ], + "layout": "IPY_MODEL_4dab31ace5474d6795dcabf8775e6dc7", + "tabbable": null, + "tooltip": null + } + }, + "d8d70da08bd74e428dadb0f8336edf87": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43453,23 +44105,7 @@ "width": null } }, - "d306a770b70d48ffb43ea52e248b885f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "d3358f971f0d48f88a5d44c91d3fb7a6": { + "d94f9bfafdc44a45832805c9467bcc90": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43518,11 +44154,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "d3400de3aa544ec5b1f4cc5c2e3cb0dd": { + "d958316f5210497daf8211068f41e12f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43571,68 +44207,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "d3eac37fd5874895be2f4ccea40f6cad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d43583f614804c7b9a15b16fc5d39c0c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "d4a21d30e2e742bdbc11e4b2d113052d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2b1ce2ace64948fe9ebf69eae5e0230f", - "placeholder": "​", - "style": "IPY_MODEL_d6e57e57cacc45ce8202c1459dd6f4db", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" - } - }, - "d4c01029140741b78012d16261101438": { + "d965f240b86847c9915c050c9bb38e0c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43685,30 +44264,7 @@ "width": null } }, - "d4c51be1057342028ab5eaa9b27d2113": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_0320460434d44245b2d484162e67183c", - "placeholder": "​", - "style": "IPY_MODEL_a661b4edaa614a9cb46f7306f1d46a1c", - "tabbable": null, - "tooltip": null, - "value": " 36/49 [00:00<00:00, 352.89it/s]" - } - }, - "d52f7fe0ac544f58b726245383cea7fb": { + "d9a4a04c80cb45c1b73fc55737f96e2f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43761,75 +44317,7 @@ "width": null } }, - "d55dd11d79a54468980f37f40d4d37c1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d5e34eb5c8f248b995600255374e1cb2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_cd11f22e25c846faa451cdad41307736", - "IPY_MODEL_9b6c83606a7c4d85a8c9b22505d783e1", - "IPY_MODEL_febe18d581124ae08879d49b0597307b" - ], - "layout": "IPY_MODEL_71ca441c651843b5ab369965e9fff8aa", - "tabbable": null, - "tooltip": null - } - }, - "d5ec943cb5124a8aaa8424a839224d71": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1f0ecc10f2924d7ca0e7f1b104b9ed8f", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ba40add6533248abbc9da32332d9216c", - "tabbable": null, - "tooltip": null, - "value": 299.0 - } - }, - "d5fb1762b5754525b2dfdefa48b7826a": { + "d9fac7fca87c4d339e4b3c5a0cfc89cb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -43882,76 +44370,63 @@ "width": null } }, - "d600dbd8924f4d409c5e5a110d276ee5": { + "da07ce2dcc304a3f9d15e1c9062db95b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_09b6451b6d2a470a99ecf69281636987", - "placeholder": "​", - "style": "IPY_MODEL_710c80d0beee4809beba178b2fe4d62c", - "tabbable": null, - "tooltip": null, - "value": " 595/599 [00:01<00:00, 370.35it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "d6327d5992a946208d63034400da112d": { + "da10211b30a94c14b4b35b2de142b061": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9d6ddcb3aa0c486983263fe5b2c7cc37", - "placeholder": "​", - "style": "IPY_MODEL_696da8126c1841168596b216aaf22aca", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f34484907c1f4949b2b5b28d88480e48", + "IPY_MODEL_78919eaaede04982b64631c67dc473b0", + "IPY_MODEL_4afe69415fce46a08b67c509d8c9bf79" + ], + "layout": "IPY_MODEL_ad09e32a6bc24250a8fd390dbc31d8da", "tabbable": null, - "tooltip": null, - "value": " 36/59 [00:00<00:00, 350.11it/s]" + "tooltip": null } }, - "d6424cac3fd944c4a898ed54b60eb73a": { + "dac229b9174046319fd89cce825d168e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4a927ddb4ad34b4d8d266a9e01e26162", - "placeholder": "​", - "style": "IPY_MODEL_06971c04a2ae4553bf2088ce320a6a02", - "tabbable": null, - "tooltip": null, - "value": " 372/399 [00:01<00:00, 370.44it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "d64dda5714dc445489d9627e65283507": { + "daea84d699c949f89e5c0bda39fb03c4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -43969,7 +44444,7 @@ "text_color": null } }, - "d65ca456eec34b87992aa27dc021c7b0": { + "daf3a28c1ca94ab88a54ec5d9403bd88": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -43984,39 +44459,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_4e704ee25e654584b271ff9b52b07d3f", - "IPY_MODEL_3cc5eaf75896480f8dff11ae8a727ed9", - "IPY_MODEL_e4255e2fd3c9487092e58ccb4f053e2f" + "IPY_MODEL_12a8f7431a7b4a1884f2f8afce587b78", + "IPY_MODEL_e67d7d61741d43d68a4b06d9cbdbd042", + "IPY_MODEL_fc28a032e6c249c1ae6c87400cdbdd21" ], - "layout": "IPY_MODEL_6a9ed65510764abb955653db0e7ee27b", + "layout": "IPY_MODEL_189893f87cfe49ff801a805a0ae06f07", "tabbable": null, "tooltip": null } }, - "d6830f03091b4122bf8a35adb6ef3b8e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_28feb5aac0de4bb490a80c66d22b8daf", - "placeholder": "​", - "style": "IPY_MODEL_355304b3dc444dd3a780d3a03dd83d43", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" - } - }, - "d6d68e4b062d48e596a0c483fd5fda07": { + "dafc978020bc4609b21e5c6c0263d4ff": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -44034,7 +44486,7 @@ "text_color": null } }, - "d6e57e57cacc45ce8202c1459dd6f4db": { + "db0ef9660b694b2aab5c9bcb64831229": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -44052,48 +44504,23 @@ "text_color": null } }, - "d784ada454e9411dab47048443652156": { + "db2b379d38a74a7996a712bb339ba6c4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "d7896b8022424b25b876bfaa8d644595": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a436284c4732400e9b8c8f443966b7fb", - "placeholder": "​", - "style": "IPY_MODEL_f699477158e14088862a109d5dc070e0", - "tabbable": null, - "tooltip": null, - "value": " 369/399 [00:01<00:00, 349.31it/s]" + "bar_color": null, + "description_width": "" } }, - "d7b5bc789ea846109c2966954f666e5c": { + "db6e25f9010d4810ae6fd7e7e919c5eb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44142,34 +44569,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "d7d7efe850c24bb0905c4466d5a21ea3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ea9ab88e425b4b0584b8eed507e04407", - "placeholder": "​", - "style": "IPY_MODEL_2b7e2f2529d3499f9b631e8623105d46", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  52%" - } - }, - "d7f0556fc6ad4758b8a7cda07ba539f4": { + "dbafc86815ca45719c9e6a7fe2696045": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -44184,16 +44588,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_8034dffc34894238b3dec4bc38dd602c", - "IPY_MODEL_24beb2defa5a4780ba4dc286afbac5e3", - "IPY_MODEL_1749fb2f460f4b1d926e6a554d8645d3" + "IPY_MODEL_dc7e66f7b4444b9ba6e9c5046abc761a", + "IPY_MODEL_0d450d0fcddf475eb9a4055a9e08ae1a", + "IPY_MODEL_15d20b7f73704e788ca23d835b6e4d8f" ], - "layout": "IPY_MODEL_f47254cfc0e647f7adfd45769bf361b4", + "layout": "IPY_MODEL_0f695329870540f3bcf2fb1cb665d34d", "tabbable": null, "tooltip": null } }, - "d7ffdc53aa764cab94c829dcce0a5f90": { + "dbd14503868a425692bfa7a7954d09ba": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44242,11 +44646,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "d8091fc330484f93ae0428ae85d8afbb": { + "dc2609d48bbd4286a3bddb732b5e7b5b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44299,60 +44703,30 @@ "width": null } }, - "d8734993d9e94afd95784de851ea82da": { - "model_module": "@jupyter-widgets/base", + "dc7e66f7b4444b9ba6e9c5046abc761a": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0ef57969f17642eeb71d761870343c1b", + "placeholder": "​", + "style": "IPY_MODEL_c9cba4fb0c944f2ca7e6cbea08c85815", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.: 100%" } }, - "d8b3bbfe035547f8b5583462b73d54b8": { + "dc83120dbdfd431a98a34c91e0ac4e1f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44405,33 +44779,25 @@ "width": null } }, - "d8b9fcda56134502b34c74e949c6d3e2": { + "dd9ac98c3fe144c6bacd968b4eee5976": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3185d1df4262486583b2cce2550716ef", - "max": 899.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_a59245fd27c84e1fa9f32f9568ba2884", - "tabbable": null, - "tooltip": null, - "value": 899.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "d8fcc39f231c4f45a0dae262217c173c": { + "ddbe56278c5149c0b22a3a7ab874ece7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -44446,38 +44812,41 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_45b0e4c66bc1441bb94932e73f7efb79", + "layout": "IPY_MODEL_4f30ef2766674efabca40e7456344b11", "placeholder": "​", - "style": "IPY_MODEL_e0a49e409fe64e798ab2d139cfb1e515", + "style": "IPY_MODEL_af5369c6c54940b0874511dd412f6668", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  97%" + "value": " 0/9 [00:00<?, ?it/s]" } }, - "d90671b9538c4f328aa0c02f47852a76": { + "ddc17f330d344f758cecaf98b60c029c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_bf492ab8ac014baca398e925490bb137", - "placeholder": "​", - "style": "IPY_MODEL_dd99074dc14c4ea4a5ed8508d18818fc", + "layout": "IPY_MODEL_b92c0f1fc2dc426daf7902b55afeb2a9", + "max": 499.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_33943fd46bbb4eb89e232842e54cdb49", "tabbable": null, "tooltip": null, - "value": " 183/199 [00:00<00:00, 361.93it/s]" + "value": 499.0 } }, - "d9af00f60d5446acb1d9c1cc0cfe770a": { + "ddf2e8f1d62a47a8892d10936956ee96": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44509,77 +44878,28 @@ "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null - } - }, - "d9ebbe51225a409096250907c4c2dbf5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_8b28cd8da30042dd967bf6d6251cd42e", - "max": 89.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_fedfea87bb13469d99ed1b507605937c", - "tabbable": null, - "tooltip": null, - "value": 89.0 - } - }, - "d9f6193af70e4e5ca8a48e246903e57e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2384ab9a24d54e6ba660d724d28817ad", - "placeholder": "​", - "style": "IPY_MODEL_f25a9d81b91e4bb298179a53216a074b", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  62%" + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "da02205a6765423997b76576f7338f55": { + "de180b912fe24f76a078b152855b9abe": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44632,7 +44952,7 @@ "width": null } }, - "da119b753ebc4fab9670940cd90206dc": { + "de1a1c817fbb4acfb3e4678bb3a01159": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -44647,16 +44967,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_82a647356d4e49f1a8e1b5406a0a5083", - "IPY_MODEL_f97da0eb1ce3419a9767ea5aa0cbed1d", - "IPY_MODEL_04f8f3ecb7ab4726a414c4953afd14f3" + "IPY_MODEL_1151fb176277438b91d2e5b44a2ac6ba", + "IPY_MODEL_a3a1eab2326544f59877d63c7e4732ef", + "IPY_MODEL_0b7ab4273a604b0d9948178b5eed6864" ], - "layout": "IPY_MODEL_ec334d842cc2459085c5386e63df7c7e", + "layout": "IPY_MODEL_253847aa90ac489a9871939127d1d593", "tabbable": null, "tooltip": null } }, - "da1789b52e594f8bad8427cd64a63db9": { + "de5677865f72474f8ac090ffe895ed78": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44709,7 +45029,7 @@ "width": null } }, - "da2bf1956cc545ca8cc0d568b915d4b4": { + "de8eeab28d654f6ba239e20e24d166e3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44762,7 +45082,7 @@ "width": null } }, - "da46a2589b244ea59a9ec83fa6a984a2": { + "decdcdc5b559405889a6a0238bb43484": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -44777,15 +45097,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f1060dbf5cb34ba9bda97649bacb34b6", + "layout": "IPY_MODEL_295c6767a5784dc29346fe8d13a65c5d", "placeholder": "​", - "style": "IPY_MODEL_e23ec0460d91438b89749a365520c79d", + "style": "IPY_MODEL_aaf9204a0cb84ab68e2c9d5ac08c9c23", "tabbable": null, "tooltip": null, - "value": " 482/499 [00:01<00:00, 368.24it/s]" + "value": "Converting outputs to QuPath JSON.:   0%" + } + }, + "ded69506bd014ce6a228da04832b18bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "dab13f6588d94e1ea06facae48a345a6": { + "df0380764a3a424cb0625f3f12607ef2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -44838,7 +45176,7 @@ "width": null } }, - "db0dcff9dd144d069a54398862e9c984": { + "df0a219fbdca497f9dd3064e76abfbf9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -44853,33 +45191,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_2b45c72793a7403ea28982b692d23f36", + "layout": "IPY_MODEL_d675401634b24c11be48ebdd652ebd85", "placeholder": "​", - "style": "IPY_MODEL_2259bbe9ce08411a90c41377cc330c48", + "style": "IPY_MODEL_3a37645b000a4c53af10590124714c55", "tabbable": null, "tooltip": null, - "value": " 294/299 [00:00<00:00, 337.64it/s]" - } - }, - "db506087065141bd9360f9d96b38e047": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 693/699 [00:01<00:00, 357.28it/s]" } }, - "db9eb05a179a4dc5bf699ba7982c2815": { + "df35e0940f1649aaa22c9ef23f9f5013": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -44897,25 +45217,60 @@ "text_color": null } }, - "db9fdab7cda940ab827d78240efeb06c": { - "model_module": "@jupyter-widgets/controls", + "df381c6c534249e0b0cc286ccfa871a9": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "dbfee872796e4aaaae3ad4b8394fc5c8": { + "df54fd77f4194ba988ce5fc11d25d071": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -44930,91 +45285,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9cc5dae3a64c4eadbb102b500f243165", + "layout": "IPY_MODEL_629f25a30f104f4eadc2694bcd5fd9c2", "placeholder": "​", - "style": "IPY_MODEL_654c7c69cb6141c987f854aed167344d", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  75%" - } - }, - "dc0a4d403d8b41058913fcde3e7c441f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8a50b8decf89476dacacb5953b63da39", - "IPY_MODEL_070410c8505741cb9d891b61db4b1d67", - "IPY_MODEL_cdb80c4ecc0a4a26aaa7e7b207a8a0fb" - ], - "layout": "IPY_MODEL_2db07d5df0234a4cb27f2e7124271ada", - "tabbable": null, - "tooltip": null - } - }, - "dc4a5a362ab946b9b8124de81578769a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_1f3903e21d95428c97d968f475397059", - "max": 59.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_534afcd9dbed4095bfed7c1a8d2188ab", + "style": "IPY_MODEL_cb55b181a2ef4d43a46b1ffcb8b4bdbf", "tabbable": null, "tooltip": null, - "value": 59.0 + "value": "Converting outputs to QuPath JSON.:  99%" } }, - "dc51427dd8fb4662adce820a83d7e7cf": { + "df68ed583e76420e9be461973fa1a024": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_102f1848b58d41f892867c43637f8b4e", - "max": 999.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_f782ba5ac68343be9098e24cd21c1755", - "tabbable": null, - "tooltip": null, - "value": 999.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "dc9cc67c03584932bb357cd6a440babc": { + "df73d65092e140f29f7d202808ae0960": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -45032,7 +45329,7 @@ "text_color": null } }, - "dcdeb72a91644e7b9323f3e1c7c9bb5a": { + "df94faa2f36f4bc5a786b833c42f8e6e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45085,49 +45382,7 @@ "width": null } }, - "dcfd30625b0d4bcc846d80ed17da009f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8adda907b62942fda7c7558e4baf9a94", - "IPY_MODEL_5189b615168f4e809030de24721404dd", - "IPY_MODEL_d4c51be1057342028ab5eaa9b27d2113" - ], - "layout": "IPY_MODEL_89ea9978425b4528b483a06a93762e8b", - "tabbable": null, - "tooltip": null - } - }, - "dd21b7e9f2204483a81155c8c942a14c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dd672073c20746ed99d05c572588ce6f": { + "dfd5a036491646359ec43a7b5530eec9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45176,47 +45431,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "dd99074dc14c4ea4a5ed8508d18818fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ddba2ca557dc40dca530338f5dd7d648": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ddbe68e1a1064b2d8c3a9d8a267a67c8": { + "dfdb2b109c3a413ea87fcc4b2de5260e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -45231,16 +45450,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_38b3ebd4a29a485f8c3c97a953467b35", - "IPY_MODEL_401bfe59ea1b43f081fb0fb8a0d2b5ff", - "IPY_MODEL_f01624c031444575992cdfccf1adc495" + "IPY_MODEL_276d413b7cb74825a4e97ab60cce062d", + "IPY_MODEL_ddc17f330d344f758cecaf98b60c029c", + "IPY_MODEL_2c3efed89a724685b68bd2de27ed7c5f" ], - "layout": "IPY_MODEL_7f06dba9e4614c7fa0a1281402b452ce", + "layout": "IPY_MODEL_6a8578ea1efc448f99a3c6bb34fe5335", "tabbable": null, "tooltip": null } }, - "ddc6cfa799264926b85f97ad463641ce": { + "dff76055b38648dbb9a8a1459e130dbd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45293,33 +45512,30 @@ "width": null } }, - "ddf2ca4ebb8741399cdcd4dc0c972dc3": { + "e0141f92f21c4f5891f19a9e5038f90b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", + "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_91ce479998ce4fc3915fa56338763eae", - "max": 299.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_7e98fef5de29464fbe91fc48112fafe6", + "layout": "IPY_MODEL_f0b3153b52e143e7896890a92eb9a940", + "placeholder": "​", + "style": "IPY_MODEL_48a25f680c724bb7826a6721f61a118b", "tabbable": null, "tooltip": null, - "value": 299.0 + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "de9959fb09ac4cccad6320ad384fb596": { + "e025e75bc1424647bbd4fb04e8a5a0c0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45372,63 +45588,51 @@ "width": null } }, - "deae5739c6514cabad9f0e09b6584099": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "df0b97971d1b4da784d13950b890ade1": { + "e03f4b993d48472d96009e70eabd38cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "df3524274cd44265a1ddbb836776e1bd": { + "e048452aad634e41a1873392f34e9599": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_41e3306dc3e1434383b09f4837ad3d87", - "IPY_MODEL_58a917f7215c4506b3c7e138ce9ebe16", - "IPY_MODEL_411e610baad644b98be37857503e8deb" - ], - "layout": "IPY_MODEL_782e9f59991440fb8f2bb58d0540321b", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72fa5be009b1428681afd6ea2d3aa600", + "max": 299.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_646d6c110e8a4247bc42de6c14671658", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": 299.0 } }, - "df6fab5a0c22465b8e1ff3ab2829117a": { + "e0514e0deae14410a629b153d324211d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45477,37 +45681,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "e01c4b3ba4ea4da5849828f855afbb7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f474844b5d6a47279cf29bccb489eae4", - "max": 599.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_b5bc22f2c50b46debf6fc7ba099f98b0", - "tabbable": null, - "tooltip": null, - "value": 599.0 - } - }, - "e0a49e409fe64e798ab2d139cfb1e515": { + "e099c30b6d654a64a71ea81f4920b98c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -45525,23 +45703,60 @@ "text_color": null } }, - "e0bb0891085947018543e0b25fe6a5dd": { - "model_module": "@jupyter-widgets/controls", + "e0b7cf37ed1f4a94a6990f8f693bdaeb": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "e0bd5a7cfd4a4569920b77d5d1d3344f": { + "e0d4e0babd9f4f328a5c223c8e10d03e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -45559,7 +45774,7 @@ "text_color": null } }, - "e1436fcb37b4445d913bf68df979444c": { + "e0e97cf252534880ac8984e3e97deb16": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -45575,40 +45790,176 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_a33a001b159349fab9741fd08f1e74dc", - "max": 89.0, + "layout": "IPY_MODEL_a24f990ff14f4406ab54f6456289bfea", + "max": 899.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_242d249d623e4070998cfac6f5a7134b", + "style": "IPY_MODEL_6231e3194f02432ca94921954887e9d2", "tabbable": null, "tooltip": null, - "value": 89.0 + "value": 899.0 } }, - "e1507bee1c2e451ba1c83c5ec8ad1d67": { - "model_module": "@jupyter-widgets/controls", + "e10498b5f963419e94298780644cae20": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_530a0ee2ccf1401086c4cc131935356c", - "placeholder": "​", - "style": "IPY_MODEL_c674d4ec6c604723aad0af9ae612c8a8", - "tabbable": null, - "tooltip": null, - "value": " 73/79 [00:00<00:00, 364.87it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1058597caa7456f91b9a0374fbcbb9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "e11011e3cbcd44cb98785d093cfc181a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "e1c8bd82777d41fd980fd06a4bf78855": { + "e1165605afa542aca4d73fe573eb7702": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -45626,23 +45977,7 @@ "text_color": null } }, - "e1d99bf069ad436fa518ce03ee782d19": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e217203ba78544ad9e74b8ef8a85b907": { + "e1196b89ce0443179a86528ce26e7798": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -45657,15 +45992,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c77e8912fea94fe48c143e507b5882a2", + "layout": "IPY_MODEL_ba1bd3a71271471b9dafd286189557b5", "placeholder": "​", - "style": "IPY_MODEL_bd18b76931b442279477932561eac8a9", + "style": "IPY_MODEL_b92350319fc34353ae51b0173513add9", "tabbable": null, "tooltip": null, - "value": " 36/69 [00:00<00:00, 354.12it/s]" + "value": "Converting outputs to AnnotationStore.:  81%" } }, - "e231ca64eb4a4161bd34c8ec0ce9cf95": { + "e14297571c0e4af8a43b9c98f1e9628a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -45683,25 +46018,23 @@ "text_color": null } }, - "e23ec0460d91438b89749a365520c79d": { + "e1785606f8534b599f40b8e0e66e210c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "e24818dc9a7146d99f8348d040d3bb48": { + "e1ce9b0a0e714b80aedbdd4895c22503": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45750,47 +46083,64 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "e24ac04487814b3794160710ae12f57e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "e26b0fff5a9b4bfcbc7bbb87709b7332": { - "model_module": "@jupyter-widgets/controls", + "e1d73b3a193a4f31a2b6ce3a9d8de812": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "e2a7e797571a442aa6856ae6fae6e8c6": { + "e1df6f2066f34e3587170990416186bc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45843,7 +46193,7 @@ "width": null } }, - "e2d8483a206d47aaa5e6bad0f8d44e54": { + "e20c34ef318f4ea181a8b75c41909da9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -45892,11 +46242,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "e32d08044d8d43dc84641a3567ae8c00": { + "e28bf1986bb044b5b1f74c8f7596c174": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -45911,147 +46261,243 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_0099e0eed0af4be88b3d64f9e7069ca0", - "IPY_MODEL_4f50e952c8ee4dfb8727e51c61e0c095", - "IPY_MODEL_19892871612e45f6ac1c74d736c4cd2a" + "IPY_MODEL_f5c175a07bdd4786a211fc2019885ec8", + "IPY_MODEL_16096e81cf354cf58b0cd9e80a944d70", + "IPY_MODEL_17c0e221ace64612a2cdaf899887c83d" ], - "layout": "IPY_MODEL_93182494b09f422e987faef2c4484f13", + "layout": "IPY_MODEL_bb49e18206e14affaa7d5a4d78d3cf4d", "tabbable": null, "tooltip": null } }, - "e383b2024372464abe591908ce466a8d": { - "model_module": "@jupyter-widgets/controls", + "e2a732f2f4f147c591689b6e319fc62e": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "e384fa48257444e2aea55d925d67e2a4": { - "model_module": "@jupyter-widgets/controls", + "e2d52439f8e74571bfdb9117a6deaeb8": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_0c6502ee8c2c42b7ba21f18ca572eac0", - "placeholder": "​", - "style": "IPY_MODEL_a340a170e0214eda8adb7d7e13f46c29", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  81%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "e38c530f121746cb8a0bff30f7eff6e4": { + "e2f14e49a5ca45e2b73680a3de3dba8b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_90be65850b384b7ea507a284a2978b86", - "placeholder": "​", - "style": "IPY_MODEL_bff4ea0a24ee422ca96c1da962266275", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_63b460c9ff13425db7615334360dd916", + "IPY_MODEL_103a7a1aa9094d1bb78c6b9ec7ade33c", + "IPY_MODEL_b32093fb46334dfe899ce0f1b29053b3" + ], + "layout": "IPY_MODEL_df94faa2f36f4bc5a786b833c42f8e6e", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  61%" + "tooltip": null } }, - "e3bed6d60cf248a7b2113d6c27fb7e0f": { + "e2f6700c2eb14a6fbdae9951720a03e1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7f6f33376b1c49e788ac42fda6bdaed0", - "placeholder": "​", - "style": "IPY_MODEL_4674e0570d2240518bca3a5d9727bcee", + "layout": "IPY_MODEL_f9b5d4c1e4e444428f03f25c613fbdfd", + "max": 399.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_d094d6862a6a4b32a70369c867dc21a7", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  93%" + "value": 399.0 } }, - "e3c9be1c6d584b52aded832d6defd824": { - "model_module": "@jupyter-widgets/controls", + "e3a64d4b2cd941ee96f15bbfb55e8c54": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3a279b0dabba46cbb4a5c98f0ab0dbda", - "placeholder": "​", - "style": "IPY_MODEL_837ebb58052b4b5ca947beed81390d5a", - "tabbable": null, - "tooltip": null, - "value": " 997/999 [00:02<00:00, 364.16it/s]" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "e3d3e60602cd4b009782826748f9bdf7": { + "e3ae51175f9a49e2ba0985a8ee8d19b4": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_0870533661634ff0aba3af61c7d1f45b", - "placeholder": "​", - "style": "IPY_MODEL_0072758cb5a441a189c874088e2e4f9f", - "tabbable": null, - "tooltip": null, - "value": " 294/299 [00:00<00:00, 362.88it/s]" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "e40fe9987f85442296584419162dd149": { + "e3b07a7b99774f01a19bc7a3b8af11ac": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -46066,15 +46512,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_de9959fb09ac4cccad6320ad384fb596", + "layout": "IPY_MODEL_120dcd4a339f4a129d800208a181a8c1", "placeholder": "​", - "style": "IPY_MODEL_26adc41a09eb4024b14e199b23ee1268", + "style": "IPY_MODEL_8cf2b527f4b5458c95a9ebc0c115cdd4", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  95%" + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "e4255e2fd3c9487092e58ccb4f053e2f": { + "e3cda54caf9048408cb11ad5e3c6b19c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -46089,15 +46535,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_d8734993d9e94afd95784de851ea82da", + "layout": "IPY_MODEL_d7f04cbb53ca4475830eea8769609bac", "placeholder": "​", - "style": "IPY_MODEL_bdedd0f78dc04a9092d61cd8e78bfb1b", + "style": "IPY_MODEL_2846bfb4a0a24a8b9693f1e4234d68a7", "tabbable": null, "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "value": "Converting outputs to AnnotationStore.:  95%" } }, - "e4496b6b73d04e97ae3c28b8a03e85a3": { + "e3f58d2864e64688a129cd315423e642": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -46112,15 +46558,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9ff75787e6594279980931eccff786d5", + "layout": "IPY_MODEL_7421c9b289f74f3d9420ad30d50b0f6f", "placeholder": "​", - "style": "IPY_MODEL_57207c637ae4438c8db164c201510156", + "style": "IPY_MODEL_4d37f011910d469a913ee85b040efbae", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  73%" + "value": "Converting outputs to QuPath JSON.:  81%" } }, - "e475f0eabf8d4677a3962363685f4b4d": { + "e418c289c55d4e5682b19f61757f4965": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -46136,30 +46582,7 @@ "description_width": "" } }, - "e487871e3b3a4357b3f3d3f5fc58c837": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ae4f0036524f4a2badd0c345344a8fba", - "placeholder": "​", - "style": "IPY_MODEL_502b1a5c327e4b7988044c6fa14c9856", - "tabbable": null, - "tooltip": null, - "value": " 297/299 [00:00<00:00, 337.41it/s]" - } - }, - "e4b754781f6a4496828d6ab199a52e38": { + "e432b1f158334b06b2fba61305ee70e4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46212,30 +46635,23 @@ "width": null } }, - "e4b9e8510735418b98f75fffef37a5db": { + "e4401709c0c347a3881f5199c38186a9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_4307e9357abb49408c2ed54e1ba18eed", - "placeholder": "​", - "style": "IPY_MODEL_86b75f8cad5a46d7b97da5b62b2b89bb", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "e4f00fc898ac4023b7ff5b6a84d59c44": { + "e44b30a72b774bc5905ff7bc4ab17629": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46288,7 +46704,7 @@ "width": null } }, - "e5404053ec2a45bc9ccaf5b92e178632": { + "e46cd31731cd4b8e9e584c6cac759d68": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46337,57 +46753,27 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "e5abefda2b3f4d6098a926782d4fa807": { + "e49168c656684fa7b8db3751a62edd24": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_73f0959e57604fdcb6042ddd4d37ac7b", - "placeholder": "​", - "style": "IPY_MODEL_a5bb1cdab18b4fdc996a5f2118d037a2", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" - } - }, - "e5d527029e744ec6b36b963d68e2c649": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b33ef3e8d72e4847b01a501a1ee5ae32", - "placeholder": "​", - "style": "IPY_MODEL_c910b59dbd4e48f19a1c0961edfebad0", - "tabbable": null, - "tooltip": null, - "value": " 297/299 [00:00<00:00, 367.29it/s]" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "e6594f8025eb406a943bb1e8af05ac00": { + "e4aaa8cf48074189a13ac527448ed165": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -46402,57 +46788,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_82e2592a59b447fd83029863de4344a4", + "layout": "IPY_MODEL_fb6f627f2bcd46ee8e8a8216374feb4a", "placeholder": "​", - "style": "IPY_MODEL_67c50f30b4184b90bcb9d8d8da59ab00", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  98%" - } - }, - "e65de43cf3d845f5bd10fc9300d1c6ff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b6b69847001047279339b2394de2f13c", - "max": 79.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_57305e3d08fa4b88b8002663ec22ce03", + "style": "IPY_MODEL_56b164d2c3c441f4ab03fb13397543cc", "tabbable": null, "tooltip": null, - "value": 79.0 - } - }, - "e6b5834bbff443c1868868bd4f2da9c3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": "Converting outputs to AnnotationStore.:  96%" } }, - "e6c34a76e2174f35880a463faf8e5f36": { + "e4df00b8a9b14f55abeb6a5e710702c6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -46467,16 +46811,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_e384fa48257444e2aea55d925d67e2a4", - "IPY_MODEL_42a2de20706e40bb8b771300802429da", - "IPY_MODEL_61eb86b98b4b4462b7b5a119f742b342" + "IPY_MODEL_e75ea3d81dec45db9779ecdf9a53af51", + "IPY_MODEL_019811250c8c4265a15441274b93401d", + "IPY_MODEL_3a73a963e2ea4d8182e2bd86827e56e6" ], - "layout": "IPY_MODEL_07b2a8bef0984a42a8b9bd4f68671314", + "layout": "IPY_MODEL_56c21fff30bd4f40bb1c8364cc8dc203", "tabbable": null, "tooltip": null } }, - "e6c48de32f8348ff8b82a4c271e979c3": { + "e4fe52a54a7243a7b6ba9ae5cba42f83": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46529,7 +46873,60 @@ "width": null } }, - "e6da76fcbbce45558f7d698926f56490": { + "e517229c687345eebf8e21929bf28940": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "e56ce3624ce042a2a5b44218a8b7e609": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46582,25 +46979,30 @@ "width": null } }, - "e6fcb0ec556241c59d66ea22eff8e79d": { + "e575291ad7e9474db23155ec302dc218": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7a0d9f508cc64ea585f7b96d6cafdf7f", + "placeholder": "​", + "style": "IPY_MODEL_98c6ea1e637a4ffdae72eb035046ca77", + "tabbable": null, + "tooltip": null, + "value": " 184/199 [00:00<00:00, 363.60it/s]" } }, - "e7478027f5ad4cd1bbc0960ace565444": { + "e58d293a7316427682613c97223ac6dc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46649,55 +47051,80 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "e755273fe7414af393da0e637c45cb6c": { - "model_module": "@jupyter-widgets/controls", + "e5997fd3333440b7a99fbce974f2da06": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "LayoutModel", "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "LayoutModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5bc1d89e46b14893a48308eda7ca8327", - "max": 499.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_420ca366d3f84b8da696529b09e0fb7f", - "tabbable": null, - "tooltip": null, - "value": 499.0 + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "e86dd5462de24a36b290ae8edf850afd": { + "e5cf868570664eb9aa2051b4e84ce23f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "bar_color": null, + "description_width": "" } }, - "e86ec14407794006a23d0ee3c05432dc": { + "e5e87323eefe48338843e25757748279": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46750,7 +47177,7 @@ "width": null } }, - "e87e5e1f902f41dcb9337631b9dd253a": { + "e5eebb51cad54655ac58f2f9dd88f6b1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -46768,62 +47195,86 @@ "text_color": null } }, - "e8916415b5ef40c68f39362bb2fa14c3": { + "e67d7d61741d43d68a4b06d9cbdbd042": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d176d26c1dfe4751a1b445e904475864", + "max": 699.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_a238ec9a71f14a97b5895681d20b1688", + "tabbable": null, + "tooltip": null, + "value": 699.0 } }, - "e8ad29bc62e24720a81201de0fedd77c": { - "model_module": "@jupyter-widgets/controls", + "e6a774658f844c45bac440678d5c11a7": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e913215a765d411080f03f4b8e81a3c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_ed2d821545ac409885568652e88b8e0a", - "placeholder": "​", - "style": "IPY_MODEL_bfa9cee298b54ec6a62631fffac02d3c", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null } }, - "e93cc4a88cad4dbd8383789e40ea66f0": { + "e6c16a3b5ae94f509c3d116e22bee998": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -46838,32 +47289,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_148576e0fb2141a0808464ed94b127fd", - "IPY_MODEL_d0cd5a3f9a354b62b37c9c000e6c3454", - "IPY_MODEL_e3c9be1c6d584b52aded832d6defd824" + "IPY_MODEL_843d4058bb49470ab9604abbce518aea", + "IPY_MODEL_ce43d772afb5428db34ae169dd81b13f", + "IPY_MODEL_9827aebad82d48bd8b8b880e277572fe" ], - "layout": "IPY_MODEL_fa616fa92f694f8baf973e3e0216ade2", + "layout": "IPY_MODEL_284d8701b3b94d8e80ffedc6b3956dba", "tabbable": null, "tooltip": null } }, - "e9574faea46b46caac536226111891e3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "e99de2c5cff54076b8f33791a6e0b19c": { + "e71d5f6bfbfd4405997fdfb34b886c27": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -46912,11 +47347,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "e9b55a0769c74814a9026ecbe81be643": { + "e72b9468b28f453abe0184fb63e223b2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -46932,31 +47367,66 @@ "description_width": "" } }, - "e9ed2d3b26914df18a247d134a39d762": { + "e75ea3d81dec45db9779ecdf9a53af51": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_2582ee3ecb8f40a4a915e20cf76d3034", - "IPY_MODEL_edcaefe370114f90be5a428a348cd4d6", - "IPY_MODEL_12fe941e2aff47c6af6415035cbe59f7" - ], - "layout": "IPY_MODEL_978a701e7e5b42f78ad268e2ea7e3e36", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_54890dcac06444998ce00fd1824c5b35", + "placeholder": "​", + "style": "IPY_MODEL_6ffc473f5ec445f1b9f2bc8251ba5dee", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:  95%" + } + }, + "e7969cf6d54747829e4ba25c13bdcb47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "ea47ff2930e148d3b73975bbc39c56ed": { + "e7ac81ff8f8f4e72b521f979fd70caaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e7b42f30113e493e8d7209a7ac32fbdd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47009,7 +47479,7 @@ "width": null } }, - "ea5e890d80d74f688eb8f80994f47716": { + "e7e85c069ce349e3828dd145557a811d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47062,23 +47532,7 @@ "width": null } }, - "ea671a54605c4fd09b00a497010b515d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ea9ab88e425b4b0584b8eed507e04407": { + "e8a497971a7e4b718250060bfd7b4ed9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47127,11 +47581,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "ea9d152434c44c8e8f6bd7aced190103": { + "e8ad65f2e8014f23af1a3743e70624ea": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47184,7 +47638,7 @@ "width": null } }, - "eaa4d7ec8a9e49c7bc4bff6253aa5620": { + "e8ed18d0e06d4908807807175a91e75d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47237,7 +47691,7 @@ "width": null } }, - "eac9dad51c714b8fa278d66f6aadc660": { + "e8f243a6103b46e3b7a8bd38428abc7d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -47252,15 +47706,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_0936de0747cb4882ab7e6f256d7aa4eb", + "layout": "IPY_MODEL_adb8302d715242ae99ac7a9cf0e8d4db", "placeholder": "​", - "style": "IPY_MODEL_e1c8bd82777d41fd980fd06a4bf78855", + "style": "IPY_MODEL_7526d925e31d40f680e88fe17803ac2b", "tabbable": null, "tooltip": null, - "value": " 782/799 [00:02<00:00, 372.79it/s]" + "value": "Converting outputs to AnnotationStore.: 100%" } }, - "ead10f9e718748628b5767cb4fa7f2f0": { + "e8f726c52a5c4f35ad20a65ae1fd7882": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -47275,39 +47729,31 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c8f3a5a0ecb24b4cbeff56656bb55f5c", + "layout": "IPY_MODEL_c203bde17bdb4938a92a704f63e2c1a7", "placeholder": "​", - "style": "IPY_MODEL_bb22831bc9fa4e1ba508da66a65e6248", + "style": "IPY_MODEL_b703b5b4b1d04219aad63a6d40539eb1", "tabbable": null, "tooltip": null, - "value": " 36/59 [00:00<00:00, 355.45it/s]" + "value": " 35/69 [00:00<00:00, 348.45it/s]" } }, - "ead2cdd756d94dc1a61fe64e12eb1ef7": { + "e901e93125bb4f24b4df6099a964dabb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f1aece31cca34d15a9a93b9170d4b625", - "IPY_MODEL_27888a19cb4949a5955db0810887d01c", - "IPY_MODEL_a1930905d7944c0abc37bab11d78cb62" - ], - "layout": "IPY_MODEL_370b92e85a114488afa68e2ed2e2eb67", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "ead4f63dba604c7d921e0673959a38b3": { + "e91a10aca0704569bb19ef67cec91fa5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47360,25 +47806,7 @@ "width": null } }, - "ebd16efb451e4bf8845891e94faa9b56": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "ebfc2591c3ff485e803aee787d8ed593": { + "e92568352b194e9f8501a0e9ef4d85e7": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47431,49 +47859,7 @@ "width": null } }, - "ec0e4b7f69cd46db845078b2c870c8fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ec127cbcbcd34525a3314895422c4a52": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b860aa2f245c4479836b6664c1fbeab0", - "max": 19.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_ca0d3acfcff7449bb13429b36b0075f9", - "tabbable": null, - "tooltip": null, - "value": 19.0 - } - }, - "ec334d842cc2459085c5386e63df7c7e": { + "e9729f9de3d0485a9f428bdecac3e89d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47522,11 +47908,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "ec34fa7c1738470ca8918e8677230b63": { + "e98c04a84dd2409bb998dafb2755c106": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47579,31 +47965,53 @@ "width": null } }, - "ec43535fa727495ea79cd60300bf312a": { + "ea4aaf1ab21d49d6903a112e51e8c606": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_61d65093718847e4be786be5d6afbeb8", - "IPY_MODEL_b4e67d26b8574f92be05b3b64e87c54b", - "IPY_MODEL_b17bc236385d4dd68417114366161ecb" - ], - "layout": "IPY_MODEL_923a8f8e39e944b28f48d80793a06540", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3003cebab11f4fe98273b3abf4e2fec8", + "placeholder": "​", + "style": "IPY_MODEL_adbb08f0f45c4394ba8fe7f00e9d9a70", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 887/899 [00:02<00:00, 363.91it/s]" + } + }, + "ea70cd5b26e54df29b9a55e658a69e93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e0b7cf37ed1f4a94a6990f8f693bdaeb", + "placeholder": "​", + "style": "IPY_MODEL_742edab5440f46f2ad4ea31bf7c82326", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  96%" } }, - "ed0994b856054eddb92f8604e0cec538": { + "ea8954dcf9cf4fa593726ee10684bcbe": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -47618,39 +48026,32 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_b643570874b24c3a9be931ef4a85da3f", - "IPY_MODEL_5c735f833cca42faa4e621addb0cbe62", - "IPY_MODEL_41799e8ed28f4b68a731b96a18ac2380" + "IPY_MODEL_c10ce057bd5243c6a88fba4b6d44cb1a", + "IPY_MODEL_aec00a07c9ae451aaa35345da3858731", + "IPY_MODEL_ae411931c684402d961cf461eec8c4c2" ], - "layout": "IPY_MODEL_d3400de3aa544ec5b1f4cc5c2e3cb0dd", + "layout": "IPY_MODEL_3c7d2f074a744b5abed0237d4d1a2a96", "tabbable": null, "tooltip": null } }, - "ed0e4971bd794b4bb3060657b66b8fff": { + "eabd515abc4f4c6b83862bddbdeead45": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_d134da8a49084494b6f03e8ffe269e5a", - "placeholder": "​", - "style": "IPY_MODEL_db9fdab7cda940ab827d78240efeb06c", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "ed2d821545ac409885568652e88b8e0a": { + "eabd5e7ec89241859936896cdc5169d4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47699,29 +48100,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "edbc56fcfef44c16a94f76c9082fe44f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "edc8d6ee12a24ff0953ab319cebabee2": { + "eac431f7c30346d2a14ca7e19ef1c49f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -47736,15 +48119,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_81b10617b323434fa5dd09739c4c4d61", + "layout": "IPY_MODEL_50df0e34fdf74026ad91c9fbd72a01f2", "placeholder": "​", - "style": "IPY_MODEL_25239cb5cb2c40b3b9f88c91fa11bfcb", + "style": "IPY_MODEL_a8583d223fe341ebb31b2cff1b581f23", "tabbable": null, "tooltip": null, - "value": " 773/799 [00:02<00:00, 363.25it/s]" + "value": " 181/199 [00:00<00:00, 359.66it/s]" } }, - "edcaefe370114f90be5a428a348cd4d6": { + "ead251cae6bc4301b42ac54b82befdf2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -47760,17 +48143,35 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_9efbcffed0d640ec95650f6b44597dac", + "layout": "IPY_MODEL_649ab3fedc924c3fa7f20fbf096d82b7", "max": 599.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_994772e07dd54886860bd3ff52f44310", + "style": "IPY_MODEL_43ce248145864a488a9da7e7eae10de5", "tabbable": null, "tooltip": null, "value": 599.0 } }, - "ede85cad6ca14078b9c0f3f17c56b72b": { + "eafc334345514b188ef19bc19745ad65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "eb2a516af8ea4ed590acf13eb1395368": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47823,33 +48224,7 @@ "width": null } }, - "ee0f9c2fc55e47bc982180eee3863d3b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9a5b64d269de4e92b26f073ad1b9fbca", - "max": 89.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_0d1f00eccad145d18d77ffacd34fdcfc", - "tabbable": null, - "tooltip": null, - "value": 89.0 - } - }, - "ee14622cd15749439820c42a23e60fbd": { + "ebaf078a9cd844d6aae78de6910bb6be": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47902,7 +48277,7 @@ "width": null } }, - "ee4ec24bdf0946429e1c92a8855fbf3d": { + "ebcc786e775344e595d40c2b290d79ea": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -47955,7 +48330,31 @@ "width": null } }, - "ee9292d2cf6246b482f4477a43083366": { + "ebdf08a16ab64e0db85ae8b85538ef20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8b075f11215b42339e9c86d708a021f9", + "IPY_MODEL_edb7fc6b7b784b778541481f0509ffd0", + "IPY_MODEL_9f93da88675c4b93bd7bd6eb0a3664f6" + ], + "layout": "IPY_MODEL_87cbd710527241e9a11d41465c967c0b", + "tabbable": null, + "tooltip": null + } + }, + "ebebef6d182b40998d4c8cb3482dad65": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -47971,7 +48370,7 @@ "description_width": "" } }, - "ee94d2d7c18b4cb8810f14c855e1b2b3": { + "ec2ac49e2bf84fceace13542de95a3a9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", @@ -47987,7 +48386,49 @@ "description_width": "" } }, - "eeade946e22646f8bba9134ada76a58b": { + "ecad90018cdc46e0ad507d651eb19f1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7ba32272fc624659919e5f44086fe82e", + "IPY_MODEL_aff1ade3723842db845738d1e3bac7fc", + "IPY_MODEL_2e731324be0b4d16b8b6b4f9ebf21650" + ], + "layout": "IPY_MODEL_c88eee9aa73944b19d561248372b2fc8", + "tabbable": null, + "tooltip": null + } + }, + "ed3eedcbbbd04e33a88bc55959e4e30a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ed42279ca7274f0e9c342c5377f30bcb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -48005,7 +48446,75 @@ "text_color": null } }, - "eed9040d31db4bd1bec29339e53e3306": { + "edb7fc6b7b784b778541481f0509ffd0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_79130a2cb7014a19b946d2b50db39108", + "max": 199.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9268c7d1802d4930b5dcd10c57e99466", + "tabbable": null, + "tooltip": null, + "value": 199.0 + } + }, + "edece67fcf5d4de686a9eca080f9db0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "edf283d5063c494d8de6170bb093172f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8205d636cc4b4569beaf4119eaac714a", + "max": 59.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b7210993339b4e3e8696cc635194bd0e", + "tabbable": null, + "tooltip": null, + "value": 59.0 + } + }, + "ee2a530b7e5042b4ad01b4b832eb4e01": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48058,7 +48567,7 @@ "width": null } }, - "ef0f9b18e54546fd8ada11b2118939ae": { + "ee39a6894158481b9e62dcae6ebe9b22": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48107,155 +48616,108 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "ef2ac247bb39477f95d4f242d7091d82": { + "ee3d8fa788384c6383e9b7c3749b0bc5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_132a0fb522764f228fc5e2353294c6e4", - "placeholder": "​", - "style": "IPY_MODEL_61179f11be4d4ad3980c87be54abc0e5", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_91aaba070560491e88986044a99ee9cd", + "IPY_MODEL_6b87a941d4fc4135b2bfc1268da08483", + "IPY_MODEL_49e60d33553b4869bf8c77565aff4acc" + ], + "layout": "IPY_MODEL_c5ecb7909c8d40269c90a9f4fe5b34b6", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  99%" - } - }, - "ef552844b99341d79625224f4bd6e572": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "ef77acf3363d4105934d4c294dd6e405": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "tooltip": null } }, - "efa9f0a8274b4fcf9b5370fda250fa30": { + "ee621c769b2f4e2eb6ac1527bd12c681": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f68a8452062d43fa9bb52d364d20f142", + "IPY_MODEL_c79c3be719a04acfa77bc4c68e28e613", + "IPY_MODEL_a2c82c8c191a4ca196bdafdcfca18bc8" + ], + "layout": "IPY_MODEL_ae6719d3bae74c73b76f93727125029c", + "tabbable": null, + "tooltip": null } }, - "efd51c0a5a68438fa2197e5bafdbee2b": { + "ee6398d3aa9746cd81bf9b1b8cd48dad": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "FloatProgressModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "FloatProgressModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9dfde71c2f964bd2aba42d0cbe3e422f", + "max": 599.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_9352b342bdac447181d442f9d6721d34", + "tabbable": null, + "tooltip": null, + "value": 599.0 } }, - "efd8dadbee4b4526a15eaea1489d3dca": { + "eee4f68d4cec4ab99fee05e5a9ecf34a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f0939768625e4498b2138640b0565ba2", + "placeholder": "​", + "style": "IPY_MODEL_a1685e2f90824976b7d5e61f997edb7b", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to AnnotationStore.:   0%" } }, - "f01624c031444575992cdfccf1adc495": { + "eef249c202ee4cbeb7646bce26e0319d": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -48270,15 +48732,33 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_347e13716cac4865a6ff64467313aa11", + "layout": "IPY_MODEL_ddf2e8f1d62a47a8892d10936956ee96", "placeholder": "​", - "style": "IPY_MODEL_7c97f6da49da42e2841c10de0d670f26", + "style": "IPY_MODEL_a549d8845ade4a52a6ed2181419d5c65", "tabbable": null, "tooltip": null, - "value": " 0/9 [00:00<?, ?it/s]" + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "f01005a3aff94d30b42e4f404f1eebd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "f0163d82a0da4d8796c79376cb59ba60": { + "f02b2d58121f42fbbe6415e8a172f1b5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48327,73 +48807,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "f0208ba48bac41138021991cc6fab964": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2f521620627248e7a4763ba2fde8b384", - "placeholder": "​", - "style": "IPY_MODEL_b6b0d2ce759f4d43857b4b691e20afc7", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" - } - }, - "f038310c56d84ff98cd045fc75d74752": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5068dbbfa0de4c3ba0e259cd8333dc2b", - "placeholder": "​", - "style": "IPY_MODEL_2dd9ff6d11ad475da767edbca22fde12", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  82%" - } - }, - "f05c396f9638427b8ff97ae0cc1d304c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f0c8be8468434012b19d9f4969a16cad": { + "f0312c9d3c4149bb89f8d2e02ad458cd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -48411,7 +48829,7 @@ "text_color": null } }, - "f0dfe5c6ff1147f98d8a9dd72055bf62": { + "f065899c862944ddb82bc77b3352c825": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48464,7 +48882,7 @@ "width": null } }, - "f1060dbf5cb34ba9bda97649bacb34b6": { + "f0939768625e4498b2138640b0565ba2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48517,7 +48935,7 @@ "width": null } }, - "f10a4f9987574935b5881e29722076ed": { + "f0b3153b52e143e7896890a92eb9a940": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48570,126 +48988,25 @@ "width": null } }, - "f123cf87de6b4d6986dfcb05a9aed4c0": { + "f121f860b8db4236b9c00f3c5523e048": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_be965ce8c8a94db38758b5661cee6f70", - "max": 79.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_19a544bf339e4591b7dac54f64ee27a0", - "tabbable": null, - "tooltip": null, - "value": 79.0 - } - }, - "f131e376ab0b4b99bba21834c0badf63": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f5ad72f7153d4b99b6c1424b8c7080eb", - "IPY_MODEL_8d04f608e3b7419199e4900abbb061bb", - "IPY_MODEL_9f775967506145889b3f58b2f8077818" - ], - "layout": "IPY_MODEL_dcdeb72a91644e7b9323f3e1c7c9bb5a", - "tabbable": null, - "tooltip": null - } - }, - "f14d714c6c0d4fdb934a0c8b6add79f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_58c83d49675b46db82266c261c036f86", - "placeholder": "​", - "style": "IPY_MODEL_6d3ccec4c42b402b996aa16bc7b9e2d5", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  99%" - } - }, - "f16b839c197540b68f4a0909fc868037": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_5ec6217bd4bd4cd99aed4ef8f31f1cea", - "placeholder": "​", - "style": "IPY_MODEL_1e42e38b82d640d0b9bcaa8704520e26", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  73%" - } - }, - "f1aece31cca34d15a9a93b9170d4b625": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_26f6decc30544462b6b1487cbab83353", - "placeholder": "​", - "style": "IPY_MODEL_ddba2ca557dc40dca530338f5dd7d648", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  92%" + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "f1ce1746bd4c49c6b3f183d3c7add171": { + "f1296249c4714d8792decf672544a3fa": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -48704,62 +49021,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_f14d714c6c0d4fdb934a0c8b6add79f8", - "IPY_MODEL_250b9961e7384b11b02d9fcfca4002ec", - "IPY_MODEL_9788a286e84a4450acdeaf4a5ff306b6" + "IPY_MODEL_7c3959e149ab462ba6ea4f2630db92c2", + "IPY_MODEL_317fa0351c114464946bd2ad8126dbd8", + "IPY_MODEL_fdd22328882549868dc0e1b1ec17e95b" ], - "layout": "IPY_MODEL_24951e7781bd4944bff41af1367209fc", + "layout": "IPY_MODEL_9236d754207b4335a55419b9843478a5", "tabbable": null, "tooltip": null } }, - "f1e87e57b914424cbcfa344bfadcb60e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_3826cf494a024e14aba545a3a1f8a4ff", - "placeholder": "​", - "style": "IPY_MODEL_8c0be0ea0e614e60be0712b34b142bd8", - "tabbable": null, - "tooltip": null, - "value": " 185/199 [00:00<00:00, 365.13it/s]" - } - }, - "f22d03c204a342288dd7efe8a22d48ed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_40bcea7843324063a66654235af0b041", - "placeholder": "​", - "style": "IPY_MODEL_067ef8d9b43f475c8bafd8641e82b903", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  99%" - } - }, - "f236ca780b3a4051a5992f7b138766f9": { + "f12fad9e7f9d4bc5b1a5ce563e159fd6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48812,49 +49083,60 @@ "width": null } }, - "f24982c181324287b4cb2411ea291384": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b4d8f3506da145de8a68e64bb20c1302", - "IPY_MODEL_bb01937712fe42938626bc597b28e65c", - "IPY_MODEL_7f52da9b70204a2c964d3b7c9bb5f22c" - ], - "layout": "IPY_MODEL_bf77029b1b3f4ffab6ec030eaefd0fc5", - "tabbable": null, - "tooltip": null - } - }, - "f25a9d81b91e4bb298179a53216a074b": { - "model_module": "@jupyter-widgets/controls", + "f140bb901d594523a9a19f0d44efbe63": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "f26f7cd6572344afb1df3d7dfb92f478": { + "f1deb6418f914ca48ae1dfe14d2d4bff": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48907,7 +49189,7 @@ "width": null } }, - "f2885b35b3db481fb368939ef8d508ce": { + "f1eabed15865477c9ad9707b022376cb": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -48960,7 +49242,30 @@ "width": null } }, - "f31493e347064f87a4c9af4d899c8338": { + "f277a039789f4baa95d14e8bdb1f3cea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c4b1311267c547d49a44b43cabca5f8c", + "placeholder": "​", + "style": "IPY_MODEL_e099c30b6d654a64a71ea81f4920b98c", + "tabbable": null, + "tooltip": null, + "value": " 365/399 [00:01<00:00, 355.75it/s]" + } + }, + "f2ad6c21a37541efbd32362e2ac7397a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49013,7 +49318,7 @@ "width": null } }, - "f31a7548c4184d51a9643115a87e6490": { + "f2d74cb76e534abc949498140ab6f14f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49066,25 +49371,30 @@ "width": null } }, - "f360e6312e5a4403863bb5ab1ba58459": { + "f318ac7b52f142da9224ad61eca47a08": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8b55a273538645c4bdedb9d5a0faa07b", + "placeholder": "​", + "style": "IPY_MODEL_50a8d7b46f2e4a4fa0312c24edd5b9b6", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  81%" } }, - "f382db9ffd234b6f92338797a6a935da": { + "f343fc0ebf394065a3713794fbbca812": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49137,7 +49447,30 @@ "width": null } }, - "f3b1fddd95784c8e8d50ab319f0ba4e4": { + "f34484907c1f4949b2b5b28d88480e48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f1deb6418f914ca48ae1dfe14d2d4bff", + "placeholder": "​", + "style": "IPY_MODEL_6b1ed5d530bf4ba99034fd68289dac13", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  98%" + } + }, + "f46eca7df02f4203bc30550cccb05692": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -49155,7 +49488,23 @@ "text_color": null } }, - "f47254cfc0e647f7adfd45769bf361b4": { + "f4857f5d0e7a4fbfb835cce2051fdd90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f4cff59a64ea49b0ba529be7751669f5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49204,11 +49553,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "f474844b5d6a47279cf29bccb489eae4": { + "f4dc3d9672c44f58bd984593ad00e3fc": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49261,53 +49610,7 @@ "width": null } }, - "f49954c8368243b8978265281ec86c4d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_449b77da8cb04157b3a1da8bd069de3f", - "placeholder": "​", - "style": "IPY_MODEL_90dbd87ef8644cb6ad32b3cc8e1955b2", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  82%" - } - }, - "f4a024683a44416e984e25d202634705": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2943c575311a4d638cfcf9ae49e165af", - "placeholder": "​", - "style": "IPY_MODEL_acc62cb85534464da464081371d494dc", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" - } - }, - "f52a08b1ab0e4a889394c121bc328c23": { + "f595a18f4bc0439d9227fa120fb7ec8e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49356,11 +49659,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "f52e4c4680d3402fb7e0db7394ebed75": { + "f5c175a07bdd4786a211fc2019885ec8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -49375,15 +49678,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c33c52c3471c4014aac152806596ceeb", + "layout": "IPY_MODEL_74d2e8bc8f89480da859936e7cc65085", "placeholder": "​", - "style": "IPY_MODEL_1817cfe1c4d045f38e2e022bf07a9b33", + "style": "IPY_MODEL_a301c1c38aec48d0ba34e3ff572e93f5", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  96%" + "value": "Converting outputs to AnnotationStore.:  96%" } }, - "f568520fcad84f348539d16c081d6b59": { + "f617a520ed454e59bfca9162efc0c02b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -49398,15 +49701,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_7edcd082516745a38fdae77e062f1046", + "layout": "IPY_MODEL_130eecf034c249e6a7fd2db05201896b", "placeholder": "​", - "style": "IPY_MODEL_3be06b1781ea4ae891c8f28bc5252120", + "style": "IPY_MODEL_3ce0c2d6634e45dba31093ccdfba7606", "tabbable": null, "tooltip": null, - "value": " 965/999 [00:02<00:00, 367.32it/s]" + "value": " 889/899 [00:02<00:00, 315.93it/s]" } }, - "f5972963a4fa4aaba90a273cf6d6c1e6": { + "f62b2b5027da476ebefa97cea736234e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49455,11 +49758,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "f5ad72f7153d4b99b6c1424b8c7080eb": { + "f68a8452062d43fa9bb52d364d20f142": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -49474,15 +49777,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_4b5d39cb4bf24420a3590ed904673d3d", + "layout": "IPY_MODEL_d327eaf2e15f4a298e81d9a7dd514726", "placeholder": "​", - "style": "IPY_MODEL_4b299d4ab0424a17821e153a9bf463ee", + "style": "IPY_MODEL_d4fc06e666b649b98d1dd2342638a689", "tabbable": null, "tooltip": null, - "value": "Converting outputs to AnnotationStore.:  73%" + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "f5c1186dec3e4d24afea411ce9e31051": { + "f69c90dfc6394779b94bff937c454df5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -49497,39 +49800,31 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_890278b32a154b97894ee3a225e1c05f", + "layout": "IPY_MODEL_fbeb22546ed74abfa32cabbdfc530502", "placeholder": "​", - "style": "IPY_MODEL_8e26c83d6073406a852eac2034d65be6", + "style": "IPY_MODEL_bf4b4aed943645f993e78639568f1d87", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  82%" + "value": " 367/399 [00:01<00:00, 361.38it/s]" } }, - "f5d34dcb783c458fb360983cb881e41d": { + "f6bb84427fc1406bb599d3c13980a0f7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "ProgressStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "ProgressStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b86782f6f8514051942ed2bab9088ed2", - "IPY_MODEL_9c8f38be56c64ae4b038567f96db6500", - "IPY_MODEL_6c67410295884800a620f374d0d87830" - ], - "layout": "IPY_MODEL_9b1e34eb82bb4740b46ba721b4da8101", - "tabbable": null, - "tooltip": null + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" } }, - "f60661654b89466394e752e2c5aafd51": { + "f6c26b1e4cc546bf94af7cfea58e0f9c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49582,7 +49877,7 @@ "width": null } }, - "f60813e1af0e455a91a87f1be8d113ce": { + "f6ccac5711bf49f3983e35d3b4814e87": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49635,7 +49930,7 @@ "width": null } }, - "f6369d1079f0474aa29bf88fc2759164": { + "f6dcdd6bb38d4abeaf265f7245b80c41": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49684,70 +49979,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "f6503a830d434dd882251cd6c1f7ac35": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f699477158e14088862a109d5dc070e0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f6b6db4ea31f43b58e492efff1cec142": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_80e99db76e4b45d395684a813a3e4d22", - "placeholder": "​", - "style": "IPY_MODEL_d3eac37fd5874895be2f4ccea40f6cad", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" - } - }, - "f6bca00a5f5b4ff39af06e4db0ebc705": { + "f73cdb08a8394132ad51b2a78b945777": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49800,7 +50036,23 @@ "width": null } }, - "f708fdbc67674d22b9e64017ccd7571b": { + "f780a85649ec47699f7140baa4652d45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f7ae1100dbdc4027a186f8e8e97f9732": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -49853,123 +50105,110 @@ "width": null } }, - "f7179f3dd1ca4bfa88f3e5f07e45a1dd": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f724380a346142a29ed9d12e57b047af": { + "f862a37fdccb4249b59851554d9d90c2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f7829ae2c54e434f9a22005fc3dae290": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_fe16ea82eb63455bb85d4a926f4b8275", - "placeholder": "​", - "style": "IPY_MODEL_b62e99b4317c433faf9fd66bba58f136", + "layout": "IPY_MODEL_3e4cb3b7815d4ff5a31c91d9b895e667", + "max": 89.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c201ce80042540b4be624d34a14bbf4a", "tabbable": null, "tooltip": null, - "value": " 35/69 [00:00<00:00, 348.98it/s]" - } - }, - "f782ba5ac68343be9098e24cd21c1755": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "value": 89.0 } }, - "f85bf7cfc17d422ebacea7480fee420f": { + "f887f18477de4d3fa8e1945ce09cbbef": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_adff666cc0da41eb82076f798f8491af", - "placeholder": "​", - "style": "IPY_MODEL_48fdae60bb784400a806e96dd5cb1294", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a3ad9028956b445b85e67ee30a0ad787", + "IPY_MODEL_7d7fbe0cffde42a08acfd14d5278929a", + "IPY_MODEL_e8f726c52a5c4f35ad20a65ae1fd7882" + ], + "layout": "IPY_MODEL_16b8d3a44e474e1b8757f409b2a31546", "tabbable": null, - "tooltip": null, - "value": " 36/49 [00:00<00:00, 354.16it/s]" + "tooltip": null } }, - "f87278b7c22546cdbaae634fb57a8984": { - "model_module": "@jupyter-widgets/controls", + "f8aaa250159940d3894a21b184cb8131": { + "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "LayoutModel", "state": { - "_model_module": "@jupyter-widgets/controls", + "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null } }, - "f88dc163254c4eb5a3a1a351ce5c07bd": { + "f8dbf0c04e3d43f6a225dfa66f1cbdb9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -49987,25 +50226,30 @@ "text_color": null } }, - "f896916f00ea483388f1a885471b5edc": { + "f9051fa31e80442c8391fab3d2284a29": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2bf53299cd6148dcbfbeec2fe341b2f2", + "placeholder": "​", + "style": "IPY_MODEL_e0d4e0babd9f4f328a5c223c8e10d03e", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:   0%" } }, - "f8c19883440b464ea6907f88ecc20cb6": { + "f941248bd1ef4a09a9452d3c876b400f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50058,89 +50302,7 @@ "width": null } }, - "f8c2d3e5712d4833b35ff936ee65278f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "f8dcb2847ef1484ca610ae70720a8b85": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_b5ca46c46b7e40509783a90787d49d4b", - "IPY_MODEL_40e83a61461e46c3b706ba28f53ae68d", - "IPY_MODEL_eac9dad51c714b8fa278d66f6aadc660" - ], - "layout": "IPY_MODEL_8cb772963b0d4f9b97d1b497b81e5787", - "tabbable": null, - "tooltip": null - } - }, - "f8e5e573da5347f0bc4ab60584d96b11": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "f91b5415a4444a2b9838403c8d4a82bf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_4f2d86db11d94eb3892d396d95488b2c", - "IPY_MODEL_68744436f7954d1d90fa5e02877e5c44", - "IPY_MODEL_f568520fcad84f348539d16c081d6b59" - ], - "layout": "IPY_MODEL_3f36bab9c92040eb997e99f0ca05adaf", - "tabbable": null, - "tooltip": null - } - }, - "f93db39f5b0446a78c10220f2692d6ee": { + "f959e77699564d89a4a6fd64274e51d6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -50158,56 +50320,7 @@ "text_color": null } }, - "f97c1575a84540a0abfcc35889af58fc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_03cdefc6bcc3441c96d965034eb1c6f5", - "placeholder": "​", - "style": "IPY_MODEL_c6a5eb1881f941b8a7abf0ab2e5b31a4", - "tabbable": null, - "tooltip": null, - "value": " 591/599 [00:01<00:00, 363.08it/s]" - } - }, - "f97da0eb1ce3419a9767ea5aa0cbed1d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_b88508ebc5dc4ae8b8580c6a7c823781", - "max": 29.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_bac2b131e0fe4428adf8000233c841cd", - "tabbable": null, - "tooltip": null, - "value": 29.0 - } - }, - "fa616fa92f694f8baf973e3e0216ade2": { + "f96bca2f8e51474f8a81270510141c4a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50256,11 +50369,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "fac12ab2299f4eb49e2f2ad4ab157ae7": { + "f9b5d4c1e4e444428f03f25c613fbdfd": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50313,7 +50426,7 @@ "width": null } }, - "fb046d79c2604487b3f754060000488a": { + "f9d47283878e43719a8a3c6404e8a2a9": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50366,7 +50479,7 @@ "width": null } }, - "fb15edefaacd4f979ac5da5786c68525": { + "fa59a1d541c2405284c7296537655c5d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50419,7 +50532,7 @@ "width": null } }, - "fb3a17559779408db0db5cf5aaf39908": { + "fa6c21d777f942f7b55058e3fbeb23dd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -50434,103 +50547,61 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_742c8964f8e345d882b4df12f377dd46", + "layout": "IPY_MODEL_dff76055b38648dbb9a8a1459e130dbd", "placeholder": "​", - "style": "IPY_MODEL_38cc4a5c189b4f09bd10c8d6a0371964", + "style": "IPY_MODEL_76730fc61384421da65d47ea3758d466", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  97%" - } - }, - "fb53cda1dcbb4485a5f473d418e06873": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "fb8ce4e9e22a475eb46cd0bd06bef548": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "value": " 990/999 [00:02<00:00, 361.38it/s]" } }, - "fb9674d226bb40b08c8298d5ce890e00": { + "fa8d2922585e47989ae328b3db783c96": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "fbc2e2800f69459e9adc3a61700c71b5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_332a709915b74f3f834b9bb307d429d7", + "placeholder": "​", + "style": "IPY_MODEL_75786ef0047e4daabf4ad9c2b42786c0", + "tabbable": null, + "tooltip": null, + "value": " 0/9 [00:00<?, ?it/s]" } }, - "fbd8b39aab8b4aa197a53ab2f71c37b7": { + "facca1af79104c58abe31cecbae54578": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c06795ca8ab947e195f5d4bad6dfee14", + "placeholder": "​", + "style": "IPY_MODEL_8a1c97e6b1be41ed88ab99e243255ce7", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" } }, - "fbfe74b86bcb4805bf8b2bece1f9c2c3": { + "fae700a28be54601897911ae558e203c": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50583,70 +50654,7 @@ "width": null } }, - "fc0ecbcdd8804a4ca291c51e12bce4c6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9da369ada4dc421f8645b288fa83aa94", - "IPY_MODEL_16d282bd9e0642ebb9e2731ca6c78aa1", - "IPY_MODEL_d0c171049d8248c5bfcdb5ae6eff2133" - ], - "layout": "IPY_MODEL_6cef078f27b34534aad4200d93d0f910", - "tabbable": null, - "tooltip": null - } - }, - "fc3a225ed50b4428852f0b94fa4a5066": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fc553ccf6a0b427aa55c04996ced8786": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_86179bf42ffd4e2fbcdb69876bf2430b", - "placeholder": "​", - "style": "IPY_MODEL_a35d6c88b5a740008757e625a41371e2", - "tabbable": null, - "tooltip": null, - "value": "Converting outputs to AnnotationStore.:   0%" - } - }, - "fd0a818a3abe4d83b5db0d8cebfb7225": { + "faf3df790e944e92a904c6def6017ca5": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50699,139 +50707,92 @@ "width": null } }, - "fd3c7bb2465e454f8593489d99cc3047": { + "fb0537663fb14f6880ada7ecb8c32661": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "fd58898564e14f91a2de5ef353915ee7": { + "fb1628a7e1d54607a7ba57b21361aeb6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HBoxModel", + "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", + "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_72977439fc354dbe81b6f7e1c051b209", - "IPY_MODEL_29f90c5cc8e747a0ab22a7d7e6f1817b", - "IPY_MODEL_c079814cdff147f29bc359e80c0d939a" - ], - "layout": "IPY_MODEL_067db5ac65ff4bd989a502badf2ccead", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_8573f92cb07e4628a65c4bcac66b95b9", + "placeholder": "​", + "style": "IPY_MODEL_63e1db7c3ccd40638c87013ae59c31ed", "tabbable": null, - "tooltip": null + "tooltip": null, + "value": " 36/39 [00:00<00:00, 354.02it/s]" } }, - "fd645dbd466f4d53857b74abc5891616": { + "fb1c7afda849493986881acee2b7fda7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_c6186a9115e840bc813315a474bcb455", - "placeholder": "​", - "style": "IPY_MODEL_894a2956493e4c9d8223a99014b5ae4a", + "layout": "IPY_MODEL_0bae579ff56d432485df4d966054ba63", + "max": 9.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_88a30f9aebb84b3fb04956d9a4ca4032", "tabbable": null, "tooltip": null, - "value": " 481/499 [00:01<00:00, 361.66it/s]" + "value": 9.0 } }, - "fd77ef4f213f4512b115fefe337a1d5f": { + "fb2d4e6ff12443fda45af43367604f1a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fd7f07c8304e4edc81106a886df8d71c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "fd933da07e674cddb3bcfa7d6eed1d67": { + "fb6f627f2bcd46ee8e8a8216374feb4a": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50884,7 +50845,7 @@ "width": null } }, - "fdb22cf92086422f87a8e173bf688af4": { + "fb9e66c1eb244ec19b447e0261510d1e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -50937,46 +50898,55 @@ "width": null } }, - "fdb6e5e0a4774be38d1f2e2d05037d91": { + "fbb2934f82554655af4a00d42652960a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_9ad7aafb378f449f8cf7293f196a5510", - "placeholder": "​", - "style": "IPY_MODEL_cbcd4929cb02433ea2c8ddc1cac80849", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_76dc82edf3544e2389b85f42f4264905", + "IPY_MODEL_798f0ea056f8403ca07fb0e4162571f8", + "IPY_MODEL_452cb84b26dd4ba3a19725711abbc353" + ], + "layout": "IPY_MODEL_275a557e774148eea3ebb9a83d8df3d2", "tabbable": null, - "tooltip": null, - "value": "Converting outputs to QuPath JSON.:   0%" + "tooltip": null } }, - "fdbe2276e07f44be967abd7c5011727f": { + "fbcbb33574a24095b51d554f0ed7be27": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", + "model_name": "HBoxModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", + "_model_name": "HBoxModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5cf654eb85634875b8929bac771308ee", + "IPY_MODEL_326208c18c2748689eca14d506118164", + "IPY_MODEL_f69c90dfc6394779b94bff937c454df5" + ], + "layout": "IPY_MODEL_4763448e0e8b498fa37cb1bedd8b6b39", + "tabbable": null, + "tooltip": null } }, - "fdd0aa39b9ae426093657e1aa7180e8a": { + "fbe1765e09fb4d30ba000cfe8295e636": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51025,11 +50995,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "fde3ed00fb8744af93a13077c0fb90ca": { + "fbeb22546ed74abfa32cabbdfc530502": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51082,7 +51052,53 @@ "width": null } }, - "fe0e8914ddaf467ba7196560bee6b788": { + "fc28a032e6c249c1ae6c87400cdbdd21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6cbd64db129f4f0bb4a38afe64ab9fbc", + "placeholder": "​", + "style": "IPY_MODEL_96838a1e0d924d60932338d8c3b54981", + "tabbable": null, + "tooltip": null, + "value": " 667/699 [00:01<00:00, 341.36it/s]" + } + }, + "fc2e7719cc4c4c6388d6a49d718df8b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_aafdd9e4fccf4bbba3f79440240716e4", + "placeholder": "​", + "style": "IPY_MODEL_7bbec7ea432340de99f675f9d9c64d7f", + "tabbable": null, + "tooltip": null, + "value": "Converting outputs to QuPath JSON.:  92%" + } + }, + "fc641f37c79947199726203ca5d8c7f6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51131,11 +51147,11 @@ "padding": null, "right": null, "top": null, - "visibility": "hidden", + "visibility": null, "width": null } }, - "fe0f230185f2470c963a01e6393ced04": { + "fcf1eaa6c2e546b4a57fa17a69a60847": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", @@ -51153,7 +51169,31 @@ "text_color": null } }, - "fe16ea82eb63455bb85d4a926f4b8275": { + "fd032fa795b84d8db167fb8b963e5917": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_decdcdc5b559405889a6a0238bb43484", + "IPY_MODEL_ca0111b7c36d4e4ca558ce7cc1d3e3e5", + "IPY_MODEL_a71543e410a5411589b9af9cf97bc349" + ], + "layout": "IPY_MODEL_13f2f6e445544699b81eefc61eadc7b9", + "tabbable": null, + "tooltip": null + } + }, + "fd34101632d74ecfa8afefeb68ddd5e0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51206,60 +51246,48 @@ "width": null } }, - "fe3eb75225554eeba1353933ba8056c3": { - "model_module": "@jupyter-widgets/base", + "fd8c57e995c54376892a28a89c042405": { + "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "LayoutModel", + "model_name": "HTMLStyleModel", "state": { - "_model_module": "@jupyter-widgets/base", + "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", + "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": null + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fdd22328882549868dc0e1b1ec17e95b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2fd359be9a0342a4afc668ed1fc7fe14", + "placeholder": "​", + "style": "IPY_MODEL_45cef1a785544e2aaa16bc70ad5a2c11", + "tabbable": null, + "tooltip": null, + "value": " 993/999 [00:02<00:00, 363.23it/s]" } }, - "fe78982fb27943eda4f9448dd2cafeac": { + "fdd36602a7484bc7bb923e33c6cd0494": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51312,23 +51340,7 @@ "width": null } }, - "fe833ec08ef84467be5a41bc49e84336": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fe9a989ad2c64316bf1d9bd4fb2acf86": { + "fdf507c4776e4a4c95efa21a8b0d0eeb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -51343,56 +51355,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_6d340030ab4a4a5c99c2a10b79695418", + "layout": "IPY_MODEL_f8aaa250159940d3894a21b184cb8131", "placeholder": "​", - "style": "IPY_MODEL_afd2ef8a040b4348bc98a17b1ff49021", + "style": "IPY_MODEL_2d39479f14544b8c96076af536cce951", "tabbable": null, "tooltip": null, - "value": " 971/999 [00:02<00:00, 319.31it/s]" + "value": " 476/499 [00:01<00:00, 361.96it/s]" } }, - "feb30733b37147bbab8f0a130c92bd05": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "febe18d581124ae08879d49b0597307b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_a5f7a5c23d0f4a1facc5a14763124c8b", - "placeholder": "​", - "style": "IPY_MODEL_d64dda5714dc445489d9627e65283507", - "tabbable": null, - "tooltip": null, - "value": " 36/69 [00:00<00:00, 352.06it/s]" - } - }, - "fed10a9fc2e149869e098e315605f5c5": { + "fdfa0c935dd643df84b958d6dfd75629": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51441,11 +51412,11 @@ "padding": null, "right": null, "top": null, - "visibility": null, + "visibility": "hidden", "width": null } }, - "fede4f2d39114cada434c7f2a7fed07d": { + "fe821a7c58dd40079ae4d7692425a9c3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", @@ -51460,32 +51431,16 @@ "_view_name": "HBoxView", "box_style": "", "children": [ - "IPY_MODEL_290c3be5b2ff4f278a639007eb07ecb4", - "IPY_MODEL_01fe3f8bfc9441f3a6db7a92d65dcdab", - "IPY_MODEL_c6a5910106054e43a5c14f3e688b1297" + "IPY_MODEL_cfdd5e0d62f042c585b3c8b4ad673755", + "IPY_MODEL_9252c0846a074377b50045e8bf787f39", + "IPY_MODEL_90df3d1f323346d6bf071601bd83e2e5" ], - "layout": "IPY_MODEL_38006af591a445688fbb47c5d6e5922e", + "layout": "IPY_MODEL_26f5d57c9ab449f19e9c06d29906ef76", "tabbable": null, "tooltip": null } }, - "fedfea87bb13469d99ed1b507605937c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "fef876ee507e47a9839acc282b271da3": { + "fee27e89bf564c96af3e11528649ab64": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -51538,7 +51493,7 @@ "width": null } }, - "ff0b589903de4b8180bbd0c368575aa7": { + "ff067a33c7cd419783bba777c39763d1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -51554,40 +51509,43 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_97b2f9188b224719a6a73a98964a6c31", - "max": 599.0, + "layout": "IPY_MODEL_5011809e608743cdae38ec46ae1007ae", + "max": 99.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_aba0cb800126442a8fb0da38129ac004", + "style": "IPY_MODEL_53daf9a1d1064e99a505f18a271746e4", "tabbable": null, "tooltip": null, - "value": 599.0 + "value": 99.0 } }, - "ff2cbdf66e284671a9581f68bbb8a921": { + "ff4920731d62401a944991334e27cb0c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "ProgressView", + "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_43a7fa9e28d74fe6984d4bc3504f6d0f", - "placeholder": "​", - "style": "IPY_MODEL_e26b0fff5a9b4bfcbc7bbb87709b7332", + "layout": "IPY_MODEL_e8ad65f2e8014f23af1a3743e70624ea", + "max": 79.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_38c23be1adc94a149d3d9492d7969f04", "tabbable": null, "tooltip": null, - "value": "Converting outputs to QuPath JSON.:  92%" + "value": 79.0 } }, - "ffcac9706b364ca2894cfc605bd022a9": { + "ff8f54328c1644e3809a1284e38aa37a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", @@ -51603,14 +51561,73 @@ "bar_style": "", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_3ee76f44e6c4434cb060a79c2b7db9bf", - "max": 599.0, + "layout": "IPY_MODEL_7df84bda0ac74b1b8e9dd64bda80210d", + "max": 499.0, "min": 0.0, "orientation": "horizontal", - "style": "IPY_MODEL_d43583f614804c7b9a15b16fc5d39c0c", + "style": "IPY_MODEL_11f5024b723e44f3b8adceb04984fae2", "tabbable": null, "tooltip": null, - "value": 599.0 + "value": 499.0 + } + }, + "ff9c06f0a705471185d1649383026c93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6da5553a89574b298e471285c26b2a3b", + "placeholder": "​", + "style": "IPY_MODEL_9950f5a5e80f4d6eb753c7a7551852d0", + "tabbable": null, + "tooltip": null, + "value": " 36/59 [00:00<00:00, 359.08it/s]" + } + }, + "ffd39ee9b3474becafdda6a81004543f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "ffef49a7ff1a41a4b48c5382e0336f04": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } } }, From d623ae62570595e9ccbddfc9d8620fd66bd551e4 Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Fri, 28 Aug 2026 13:38:23 +0100 Subject: [PATCH 107/112] Added in benchmarking for comparing multitask functions --- ...multitask_functions_in_rust_v_python.ipynb | 545 ++++++++++++++++++ .../models/engine/multi_task_segmentor.py | 52 +- tiatoolbox/rust-library/multitask/src/lib.rs | 130 +---- 3 files changed, 614 insertions(+), 113 deletions(-) create mode 100644 benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb diff --git a/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb b/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb new file mode 100644 index 000000000..fa75a2f69 --- /dev/null +++ b/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb @@ -0,0 +1,545 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "aqPkpRk-pT5q" + }, + "source": [ + "# Benchmarking Misc in Rust\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This work focuses on converting code in tiatoolbox/models/engine/multi_task_segmentor.py from Python to Rust with the aim of reducing the time it takes to run the code. This Juypter notebook shows the speedup that certain functions are having being written in rust.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rust is a programming language that is proven to be faster than Python, especially for CPU bound operations and processing large amounts of data.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook compares the execution time of several function in two forms.\n", + "One the original python version\n", + "Two the modified function where some or all of the code has been moved to Rust\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It tests how long it runs in Python and in Rust using different sized inputs. Each input size has multiple tests and the average of all the tests is taken to minimise the impact of any outliers. The x axis shows the size of the input and the y axis shows the average time taken of each input of size x.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook will show which functions benefitted being moved into Rust.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "step1 = 100" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 2: Patch Predictions As Annotations\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DaskDelayedJSONStore written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from shapely.geometry import mapping\n", + "from shapely.geometry import shape as feature2geometry\n", + "\n", + "from tiatoolbox.utils.misc import make_valid_poly\n", + "\n", + "\n", + "class PyDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def build_single_qupath_feature(\n", + " self,\n", + " i: int,\n", + " class_dict: dict | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " class_colors: dict,\n", + " ) -> dict:\n", + " \"\"\"Build a single feature for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " class_colors (dict):\n", + " Maps classes to specific colors.\n", + "\n", + " Returns:\n", + " dict:\n", + " A fully constructed Feature dictionary instance for writing\n", + " to QuPath JSON.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + " geo_map = mapping(geom)\n", + "\n", + " props = {}\n", + " class_value = None\n", + " class_name = None\n", + "\n", + " for key, arr in self._processed_predictions.items():\n", + " value = arr[i].tolist() if hasattr(arr[i], \"tolist\") else arr[i]\n", + "\n", + " if key == \"type\":\n", + " # Handle None class name\n", + " if value is None:\n", + " # Assign default class 0\n", + " class_value = 0\n", + " class_name = class_dict.get(0, 0)\n", + " props[\"type\"] = class_name\n", + " continue\n", + "\n", + " # Safe class lookup\n", + " if class_dict is not None and value in class_dict:\n", + " class_name = class_dict[value]\n", + " else:\n", + " # Already a name or no mapping available\n", + " class_name = value\n", + "\n", + " props[\"type\"] = class_name\n", + " class_value = value\n", + " else:\n", + " if value is None:\n", + " continue\n", + " props[key] = np.array(value).tolist()\n", + "\n", + " # Classification block\n", + " if class_name is not None and class_value in class_colors:\n", + " color = class_colors[class_value]\n", + " props[\"classification\"] = {\n", + " \"name\": class_name,\n", + " \"color\": color,\n", + " }\n", + " props[\"class_value\"] = class_value\n", + "\n", + " return {\n", + " \"type\": \"Feature\",\n", + " \"id\": f\"object_{i}\",\n", + " \"geometry\": geo_map,\n", + " \"properties\": props,\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_name if class_name is not None else \"object\",\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RustDaskDelayedJSONStore with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from tiatoolbox import rmultitask\n", + "\n", + "\n", + "class RustDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def build_single_qupath_feature(\n", + " self,\n", + " i: int,\n", + " class_dict: dict | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " class_colors: dict,\n", + " ) -> dict:\n", + " \"\"\"Build a single feature for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " class_colors (dict):\n", + " Maps classes to specific colors.\n", + "\n", + " Returns:\n", + " dict:\n", + " A fully constructed Feature dictionary instance for writing\n", + " to QuPath JSON.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + " geo_map = mapping(geom)\n", + "\n", + " return rmultitask.build_single_qupath_feature(\n", + " geo_map, self._processed_predictions, i, class_dict, class_colors\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "def make_test_data(\n", + " num_patches: int,\n", + " num_classes: int,\n", + " rng: np.random.Generator,\n", + ") -> tuple[\n", + " np.ndarray,\n", + " dict[str, np.ndarray],\n", + " dict[int, str],\n", + " dict[int, list[int]],\n", + "]:\n", + " \"\"\"Generate test data for build single qupath feature.\"\"\"\n", + " # Example square polygons.\n", + " centres = rng.uniform(0, 10000, size=(num_patches, 2))\n", + "\n", + " square = np.array(\n", + " [\n", + " [-5.0, -5.0],\n", + " [5.0, -5.0],\n", + " [5.0, 5.0],\n", + " [-5.0, 5.0],\n", + " [-5.0, -5.0],\n", + " ]\n", + " )\n", + "\n", + " contours = np.array(\n", + " [centre + square for centre in centres],\n", + " dtype=object,\n", + " )\n", + "\n", + " class_probs = rng.random((num_patches, num_classes))\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + "\n", + " preds = np.argmax(class_probs, axis=1).astype(np.int32)\n", + "\n", + " processed_predictions = {\n", + " \"type\": preds,\n", + " \"prob\": np.max(class_probs, axis=1),\n", + " \"centroid\": centres,\n", + " }\n", + "\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + "\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + "\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " return (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " )\n", + "\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scale_factor = (0.5, 0.5)\n", + "origin = (0.0, 0.0)\n", + "\n", + "sizes = []\n", + "timings = []\n", + "\n", + "for num_patches in [10, 20, 50, 100, 200, 500, 1000]:\n", + " num_classes = min(num_patches, 100)\n", + "\n", + " (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " ) = make_test_data(\n", + " num_patches,\n", + " num_classes,\n", + " rng,\n", + " )\n", + "\n", + " python_store = PyDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " rust_store = RustDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " python_times = []\n", + " rust_times = []\n", + "\n", + " for _ in range(10):\n", + " # Python\n", + " start_time = time.time()\n", + "\n", + " python_objects = [\n", + " python_store.build_single_qupath_feature(\n", + " i,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " class_colours,\n", + " )\n", + " for i in range(num_patches)\n", + " ]\n", + "\n", + " python_times.append(time.time() - start_time)\n", + "\n", + " start_time = time.time()\n", + "\n", + " rust_objects = [\n", + " rust_store.build_single_qupath_feature(\n", + " i,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " class_colours,\n", + " )\n", + " for i in range(num_patches)\n", + " ]\n", + "\n", + " rust_times.append(time.time() - start_time)\n", + "\n", + " sizes.append(num_patches)\n", + "\n", + " timings.append(\n", + " [\n", + " np.mean(python_times),\n", + " np.mean(rust_times),\n", + " ]\n", + " )\n", + "\n", + "timings = np.asarray(timings)\n", + "\n", + "plt.plot(sizes, timings[:, 0], label=\"Python\", marker=\"o\")\n", + "plt.plot(sizes, timings[:, 1], label=\"Rust\", marker=\"x\")\n", + "plt.xlabel(\"Number of annotations\")\n", + "plt.ylabel(\"Time (seconds)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "interpreter": { + "hash": "a3ed8fb525a8bde66cc7655a5df08d8d0f8699a69b9eb5ccab28dc0a7837eec6" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tiatoolbox/models/engine/multi_task_segmentor.py b/tiatoolbox/models/engine/multi_task_segmentor.py index 3316b7153..fec5aebe9 100644 --- a/tiatoolbox/models/engine/multi_task_segmentor.py +++ b/tiatoolbox/models/engine/multi_task_segmentor.py @@ -136,7 +136,7 @@ from shapely.strtree import STRtree from tqdm.auto import tqdm -from tiatoolbox import logger, rmultitask +from tiatoolbox import logger from tiatoolbox.annotation import SQLiteStore from tiatoolbox.annotation.storage import Annotation from tiatoolbox.tools.patchextraction import PatchExtractor @@ -3572,9 +3572,53 @@ def _build_single_qupath_feature( ) geo_map = mapping(geom) - return rmultitask.build_single_qupath_feature( - np, geo_map, self._processed_predictions, i, class_dict, class_colors - ) + props = {} + class_value = None + class_name = None + + for key, arr in self._processed_predictions.items(): + value = arr[i].tolist() if hasattr(arr[i], "tolist") else arr[i] + + if key == "type": + # Handle None class name + if value is None: + # Assign default class 0 + class_value = 0 + class_name = class_dict.get(0, 0) + props["type"] = class_name + continue + + # Safe class lookup + if class_dict is not None and value in class_dict: + class_name = class_dict[value] + else: + # Already a name or no mapping available + class_name = value + + props["type"] = class_name + class_value = value + else: + if value is None: + continue + props[key] = np.array(value).tolist() + + # Classification block + if class_name is not None and class_value in class_colors: + color = class_colors[class_value] + props["classification"] = { + "name": class_name, + "color": color, + } + props["class_value"] = class_value + + return { + "type": "Feature", + "id": f"object_{i}", + "geometry": geo_map, + "properties": props, + "objectType": "annotation", + "name": class_name if class_name is not None else "object", + } def compute_annotations( self: DaskDelayedJSONStore, diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index 792e43374..f93193c1a 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,5 +1,6 @@ use pyo3::prelude::*; use pyo3::types::PyDict; +use pyo3::IntoPyObjectExt; #[derive(Clone)] enum StringOrFloat { @@ -13,18 +14,17 @@ fn add(a: i32, b: i32) -> i32 { } #[pyfunction] -fn build_single_qupath_feature( - py: Python<'_>, - np: &Bound<'_, PyAny>, +fn build_single_qupath_feature<'py>( + py: pyo3::Python<'py>, geo_map: &Bound<'_, PyAny>, - processed_predictions: &Bound<'_, PyDict>, + processed_predictions: &pyo3::Bound<'py, PyDict>, i: i32, - class_dict: &Bound<'_, PyDict>, + class_dict: &pyo3::Bound<'py, PyDict>, class_colours: &Bound<'_, PyDict>, ) -> PyResult> { let props = PyDict::new(py); - let mut class_value: Option = None; - let mut class_name: Option = None; + let mut class_value: Option> = None; + let mut class_name: Option> = None; for (key, arr) in processed_predictions.iter() { let item = arr.get_item(i)?; let value = if item.hasattr("tolist")? { @@ -34,116 +34,38 @@ fn build_single_qupath_feature( }; if key.eq("type")? { if value.is_none() { - class_value = Some(StringOrFloat::Float(0.0)); + class_value = Some(0_i64.into_bound_py_any(py)?); class_name = match class_dict.get_item(0)? { - Some(value) => { - if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } - } - None => Some(StringOrFloat::Float(0.0)), + Some(v) => Some(v), + None => Some(0_i64.into_bound_py_any(py)?), }; - match class_name.as_ref() { - Some(StringOrFloat::String(s)) => { - props.set_item("type", s)?; - } - Some(StringOrFloat::Float(i)) => { - props.set_item("type", i)?; - } - None => { - props.set_item("type", py.None())?; - } - } + props.set_item("type", &class_name)?; } else { if !class_dict.is_none() && class_dict.contains(&value)? { if let Some(item) = class_dict.get_item(&value)? { - class_name = if let Ok(s) = item.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = item.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } + class_name = Some(item.clone()); } } else { - class_name = if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - } + class_name = Some(value.clone()); } - match class_name.as_ref() { - Some(StringOrFloat::String(s)) => { - props.set_item("type", s)?; - } - Some(StringOrFloat::Float(i)) => { - props.set_item("type", i)?; - } - None => { - props.set_item("type", py.None())?; - } - } - class_value = if let Ok(s) = value.extract::() { - Some(StringOrFloat::String(s)) - } else if let Ok(f) = value.extract::() { - Some(StringOrFloat::Float(f)) - } else { - None - }; + props.set_item("type", &class_name)?; + class_value = Some(value.clone()); } } else if !value.is_none() { - props.set_item( - key, - np.call_method1("array", (value,))?.call_method0("tolist")?, - )?; + props.set_item(key, &value)?; } } - let class_colours_contains_class_value = match class_value { - Some(StringOrFloat::String(ref s)) => class_colours.contains(s)?, - Some(StringOrFloat::Float(i)) => class_colours.contains(i)?, - None => false, - }; let class_name_is_none = match class_name { Some(ref _s) => false, None => true, }; - if !class_name_is_none && class_colours_contains_class_value { - let color = match class_value { - Some(StringOrFloat::String(ref s)) => class_colours.get_item(s)?, - Some(StringOrFloat::Float(i)) => class_colours.get_item(i)?, - None => None, - }; + if !class_name_is_none && class_colours.contains(&class_value)? { + let color = class_colours.get_item(&class_value)?; let classification_dict = PyDict::new(py); - match class_name.as_ref() { - Some(StringOrFloat::String(s)) => { - classification_dict.set_item("name", s)?; - } - Some(StringOrFloat::Float(i)) => { - classification_dict.set_item("name", i)?; - } - None => { - classification_dict.set_item("name", py.None())?; - } - } + classification_dict.set_item("name", &class_name)?; classification_dict.set_item("color", color)?; props.set_item("classification", classification_dict)?; - match class_value.as_ref() { - Some(StringOrFloat::String(s)) => { - props.set_item("class_value", s)?; - } - Some(StringOrFloat::Float(i)) => { - props.set_item("class_value", i)?; - } - None => { - props.set_item("class_value", py.None())?; - } - } + props.set_item("class_value", class_value)?; } let single_qupath_feature = PyDict::new(py); single_qupath_feature.set_item("type", "Feature")?; @@ -154,17 +76,7 @@ fn build_single_qupath_feature( if class_name.is_none() { single_qupath_feature.set_item("name", "object")?; } else { - match class_name.as_ref() { - Some(StringOrFloat::String(s)) => { - single_qupath_feature.set_item("name", s)?; - } - Some(StringOrFloat::Float(i)) => { - single_qupath_feature.set_item("name", i)?; - } - None => { - single_qupath_feature.set_item("name", py.None())?; - } - } + single_qupath_feature.set_item("name", &class_name)?; } Ok(single_qupath_feature.unbind()) } From 80ac12e311bc70586f20bb057829bd3d8558b189 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Fri, 28 Aug 2026 13:45:04 +0100 Subject: [PATCH 108/112] Updated rmultitask to improve formatting --- tiatoolbox/rust-library/multitask/src/lib.rs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index f93193c1a..c5c8398ab 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,12 +1,6 @@ +use pyo3::IntoPyObjectExt; use pyo3::prelude::*; use pyo3::types::PyDict; -use pyo3::IntoPyObjectExt; - -#[derive(Clone)] -enum StringOrFloat { - String(String), - Float(f64), -} #[pyfunction] fn add(a: i32, b: i32) -> i32 { From 57eba227ff8bc0bc40a0247ccb761c82187c23bf Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 31 Aug 2026 15:42:00 +0100 Subject: [PATCH 109/112] Added compute_annotations to rmultitask --- ...multitask_functions_in_rust_v_python.ipynb | 21247 +++++++++++++++- tiatoolbox/rust-library/multitask/src/lib.rs | 213 +- 2 files changed, 21444 insertions(+), 16 deletions(-) diff --git a/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb b/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb index fa75a2f69..af549f869 100644 --- a/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb +++ b/benchmarks/comparing_multitask_functions_in_rust_v_python.ipynb @@ -3,7 +3,8 @@ { "cell_type": "markdown", "metadata": { - "id": "aqPkpRk-pT5q" + "id": "aqPkpRk-pT5q", + "jp-MarkdownHeadingCollapsed": true }, "source": [ "# Benchmarking Misc in Rust\n", @@ -52,22 +53,13 @@ "\n" ] }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "step1 = 100" - ] - }, { "cell_type": "markdown", "metadata": { "id": "b6S8vzFipT5w" }, "source": [ - "# Part 2: Patch Predictions As Annotations\n", + "# Part 1: Build Single QuPath Feature\n", "\n" ] }, @@ -81,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -234,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -339,12 +331,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -507,6 +499,21231 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 2:\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DaskDelayedJSONStore written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from tiatoolbox.annotation.storage import Annotation\n", + "\n", + "\n", + "class PyDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def build_single_annotation(\n", + " self,\n", + " i: int,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " ) -> Annotation:\n", + " \"\"\"Build a single annotation for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " Returns:\n", + " Annotation:\n", + " A fully constructed TIAToolbox `Annotation` instance.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + "\n", + " properties = {\n", + " prop: (\n", + " class_dict[self._processed_predictions[prop][i]]\n", + " if prop == \"type\" and class_dict is not None\n", + " else np.array(self._processed_predictions[prop][i]).tolist()\n", + " )\n", + " for prop in self._processed_predictions\n", + " }\n", + "\n", + " return Annotation(geom, properties)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RustDaskDelayedJSONStore with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class RustDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def build_single_annotation(\n", + " self,\n", + " i: int,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " ) -> Annotation:\n", + " \"\"\"Build a single annotation for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " Returns:\n", + " Annotation:\n", + " A fully constructed TIAToolbox `Annotation` instance.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + "\n", + " properties = rmultitask.build_single_annotation(\n", + " np, i, self._processed_predictions, class_dict\n", + " )\n", + "\n", + " return Annotation(geom, properties)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "def make_test_data(\n", + " num_patches: int,\n", + " num_classes: int,\n", + " rng: np.random.Generator,\n", + ") -> tuple[\n", + " np.ndarray,\n", + " dict[str, np.ndarray],\n", + " dict[int, str],\n", + " dict[int, list[int]],\n", + "]:\n", + " \"\"\"Generate test data for build single qupath feature.\"\"\"\n", + " # Example square polygons.\n", + " centres = rng.uniform(0, 10000, size=(num_patches, 2))\n", + "\n", + " square = np.array(\n", + " [\n", + " [-5.0, -5.0],\n", + " [5.0, -5.0],\n", + " [5.0, 5.0],\n", + " [-5.0, 5.0],\n", + " [-5.0, -5.0],\n", + " ]\n", + " )\n", + "\n", + " contours = np.array(\n", + " [centre + square for centre in centres],\n", + " dtype=object,\n", + " )\n", + "\n", + " class_probs = rng.random((num_patches, num_classes))\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + "\n", + " preds = np.argmax(class_probs, axis=1).astype(np.int32)\n", + "\n", + " processed_predictions = {\n", + " \"type\": preds,\n", + " \"prob\": np.max(class_probs, axis=1),\n", + " \"centroid\": centres,\n", + " }\n", + "\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + "\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + "\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " return (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " )\n", + "\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scale_factor = (0.5, 0.5)\n", + "origin = (0.0, 0.0)\n", + "\n", + "sizes = []\n", + "timings = []\n", + "\n", + "for num_patches in [10, 20, 50, 100, 200, 500, 1000]:\n", + " num_classes = min(num_patches, 100)\n", + "\n", + " (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " ) = make_test_data(\n", + " num_patches,\n", + " num_classes,\n", + " rng,\n", + " )\n", + "\n", + " python_store = PyDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " rust_store = RustDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " python_times = []\n", + " rust_times = []\n", + "\n", + " for _ in range(10):\n", + " # Python\n", + " start_time = time.time()\n", + "\n", + " python_objects = [\n", + " python_store.build_single_annotation(\n", + " i,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " )\n", + " for i in range(num_patches)\n", + " ]\n", + "\n", + " python_times.append(time.time() - start_time)\n", + "\n", + " start_time = time.time()\n", + "\n", + " rust_objects = [\n", + " rust_store.build_single_annotation(i, class_dict, origin, scale_factor)\n", + " for i in range(num_patches)\n", + " ]\n", + "\n", + " rust_times.append(time.time() - start_time)\n", + "\n", + " sizes.append(num_patches)\n", + "\n", + " timings.append(\n", + " [\n", + " np.mean(python_times),\n", + " np.mean(rust_times),\n", + " ]\n", + " )\n", + "\n", + "timings = np.asarray(timings)\n", + "\n", + "plt.plot(sizes, timings[:, 0], label=\"Python\", marker=\"o\")\n", + "plt.plot(sizes, timings[:, 1], label=\"Rust\", marker=\"x\")\n", + "plt.xlabel(\"Number of annotations\")\n", + "plt.ylabel(\"Time (seconds)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 3\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DaskDelayedJSONStore written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "from dask import delayed\n", + "from tqdm.auto import tqdm\n", + "\n", + "from tiatoolbox.annotation.storage import Annotation\n", + "from tiatoolbox.utils.misc import save_qupath_json, tqdm_dask_progress_bar\n", + "\n", + "\n", + "class PyDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def _build_single_qupath_feature(\n", + " self,\n", + " i: int,\n", + " class_dict: dict | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " class_colors: dict,\n", + " ) -> dict:\n", + " \"\"\"Build a single feature for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " class_colors (dict):\n", + " Maps classes to specific colors.\n", + "\n", + " Returns:\n", + " dict:\n", + " A fully constructed Feature dictionary instance for writing\n", + " to QuPath JSON.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + " geo_map = mapping(geom)\n", + "\n", + " props = {}\n", + " class_value = None\n", + " class_name = None\n", + "\n", + " for key, arr in self._processed_predictions.items():\n", + " value = arr[i].tolist() if hasattr(arr[i], \"tolist\") else arr[i]\n", + "\n", + " if key == \"type\":\n", + " # Handle None class name\n", + " if value is None:\n", + " # Assign default class 0\n", + " class_value = 0\n", + " class_name = class_dict.get(0, 0)\n", + " props[\"type\"] = class_name\n", + " continue\n", + "\n", + " # Safe class lookup\n", + " if class_dict is not None and value in class_dict:\n", + " class_name = class_dict[value]\n", + " else:\n", + " # Already a name or no mapping available\n", + " class_name = value\n", + "\n", + " props[\"type\"] = class_name\n", + " class_value = value\n", + " else:\n", + " if value is None:\n", + " continue\n", + " props[key] = np.array(value).tolist()\n", + "\n", + " # Classification block\n", + " if class_name is not None and class_value in class_colors:\n", + " color = class_colors[class_value]\n", + " props[\"classification\"] = {\n", + " \"name\": class_name,\n", + " \"color\": color,\n", + " }\n", + " props[\"class_value\"] = class_value\n", + "\n", + " return {\n", + " \"type\": \"Feature\",\n", + " \"id\": f\"object_{i}\",\n", + " \"geometry\": geo_map,\n", + " \"properties\": props,\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_name if class_name is not None else \"object\",\n", + " }\n", + "\n", + " def compute_qupath_json(\n", + " self,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float] = (0, 0),\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " save_path: Path | None = None,\n", + " batch_size: int = 100,\n", + " num_workers: int = 0,\n", + " *,\n", + " verbose: bool = True,\n", + " ) -> Path:\n", + " \"\"\"Compute annotations in batches and return/save QuPath JSON.\"\"\"\n", + " num_contours = len(self._contours)\n", + " features: list[dict] = []\n", + "\n", + " if class_dict is None:\n", + " type_arr = self._processed_predictions.get(\"type\")\n", + "\n", + " # Extract only valid class IDs/names\n", + " valid_ids = [v for v in type_arr if v is not None]\n", + "\n", + " if len(valid_ids) == 0:\n", + " # No class info at all → fallback\n", + " class_dict = {0: 0}\n", + " # Numeric class IDs\n", + " elif all(isinstance(v, (int, np.integer)) for v in valid_ids):\n", + " max_class = int(max(valid_ids))\n", + " class_dict = {i: i for i in range(max_class + 1)}\n", + " else:\n", + " # Already class names\n", + " unique_names = sorted(set(valid_ids))\n", + " class_dict = {name: name for name in unique_names}\n", + "\n", + " # Enumerate class_dict keys to assign stable integer color indices\n", + " class_keys = list(class_dict.keys())\n", + " num_classes = len(class_keys)\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + "\n", + " class_colors = {\n", + " key: [\n", + " int(cmap(i)[0] * 255),\n", + " int(cmap(i)[1] * 255),\n", + " int(cmap(i)[2] * 255),\n", + " ]\n", + " for i, key in enumerate(class_keys)\n", + " }\n", + "\n", + " # Batch processing (mirrors compute_annotations)\n", + " for batch_id in tqdm(\n", + " range(0, num_contours, batch_size),\n", + " leave=False,\n", + " desc=\"Calculating QuPath features in batches.\",\n", + " disable=not verbose,\n", + " ):\n", + " delayed_tasks = [\n", + " delayed(self._build_single_qupath_feature)(\n", + " i,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " class_colors,\n", + " )\n", + " for i in tqdm(\n", + " range(batch_id, min(batch_id + batch_size, num_contours)),\n", + " leave=False,\n", + " desc=\"Creating delayed tasks for QuPath JSON\",\n", + " disable=not verbose,\n", + " )\n", + " ]\n", + "\n", + " # Compute batch immediately\n", + " batch_features = tqdm_dask_progress_bar(\n", + " write_tasks=delayed_tasks,\n", + " desc=\"Computing QuPath features\",\n", + " verbose=verbose,\n", + " num_workers=num_workers,\n", + " )\n", + " features.extend(batch_features)\n", + "\n", + " qupath_json = {\"type\": \"FeatureCollection\", \"features\": features}\n", + "\n", + " if save_path is not None:\n", + " save_qupath_json(\n", + " save_path=save_path,\n", + " qupath_json=qupath_json,\n", + " )\n", + "\n", + " return qupath_json" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RustDaskDelayedJSONStore with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "class RustDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def _build_single_qupath_feature(\n", + " self,\n", + " i: int,\n", + " class_dict: dict | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " class_colors: dict,\n", + " ) -> dict:\n", + " \"\"\"Build a single feature for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " class_colors (dict):\n", + " Maps classes to specific colors.\n", + "\n", + " Returns:\n", + " dict:\n", + " A fully constructed Feature dictionary instance for writing\n", + " to QuPath JSON.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + " geo_map = mapping(geom)\n", + "\n", + " props = {}\n", + " class_value = None\n", + " class_name = None\n", + "\n", + " for key, arr in self._processed_predictions.items():\n", + " value = arr[i].tolist() if hasattr(arr[i], \"tolist\") else arr[i]\n", + "\n", + " if key == \"type\":\n", + " # Handle None class name\n", + " if value is None:\n", + " # Assign default class 0\n", + " class_value = 0\n", + " class_name = class_dict.get(0, 0)\n", + " props[\"type\"] = class_name\n", + " continue\n", + "\n", + " # Safe class lookup\n", + " if class_dict is not None and value in class_dict:\n", + " class_name = class_dict[value]\n", + " else:\n", + " # Already a name or no mapping available\n", + " class_name = value\n", + "\n", + " props[\"type\"] = class_name\n", + " class_value = value\n", + " else:\n", + " if value is None:\n", + " continue\n", + " props[key] = np.array(value).tolist()\n", + "\n", + " # Classification block\n", + " if class_name is not None and class_value in class_colors:\n", + " color = class_colors[class_value]\n", + " props[\"classification\"] = {\n", + " \"name\": class_name,\n", + " \"color\": color,\n", + " }\n", + " props[\"class_value\"] = class_value\n", + "\n", + " return {\n", + " \"type\": \"Feature\",\n", + " \"id\": f\"object_{i}\",\n", + " \"geometry\": geo_map,\n", + " \"properties\": props,\n", + " \"objectType\": \"annotation\",\n", + " \"name\": class_name if class_name is not None else \"object\",\n", + " }\n", + "\n", + " def compute_qupath_json(\n", + " self,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float] = (0, 0),\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " save_path: Path | None = None,\n", + " batch_size: int = 100,\n", + " num_workers: int = 0,\n", + " *,\n", + " verbose: bool = True,\n", + " ) -> Path:\n", + " \"\"\"Compute annotations in batches and return/save QuPath JSON.\"\"\"\n", + " if class_dict is None:\n", + " class_dict = {}\n", + " features = rmultitask.compute_qupath_json(\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " batch_size,\n", + " verbose,\n", + " num_workers,\n", + " len(self._contours),\n", + " self._processed_predictions.get(\"type\").tolist(),\n", + " plt,\n", + " self._build_single_qupath_feature,\n", + " delayed,\n", + " tqdm_dask_progress_bar,\n", + " )\n", + "\n", + " qupath_json = {\"type\": \"FeatureCollection\", \"features\": features}\n", + "\n", + " if save_path is not None:\n", + " save_qupath_json(\n", + " save_path=save_path,\n", + " qupath_json=qupath_json,\n", + " )\n", + "\n", + " return qupath_json" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "656305d0570240d3972765d45f63ad29", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Calculating QuPath features in batches.: 0%| | 0/1 [00:00 tuple[\n", + " np.ndarray,\n", + " dict[str, np.ndarray],\n", + " dict[int, str],\n", + " dict[int, list[int]],\n", + "]:\n", + " \"\"\"Generate test data for build single qupath feature.\"\"\"\n", + " # Example square polygons.\n", + " centres = rng.uniform(0, 10000, size=(num_patches, 2))\n", + "\n", + " square = np.array(\n", + " [\n", + " [-5.0, -5.0],\n", + " [5.0, -5.0],\n", + " [5.0, 5.0],\n", + " [-5.0, 5.0],\n", + " [-5.0, -5.0],\n", + " ]\n", + " )\n", + "\n", + " contours = np.array(\n", + " [centre + square for centre in centres],\n", + " dtype=object,\n", + " )\n", + "\n", + " class_probs = rng.random((num_patches, num_classes))\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + "\n", + " preds = np.argmax(class_probs, axis=1).astype(np.int32)\n", + "\n", + " processed_predictions = {\n", + " \"type\": preds,\n", + " \"prob\": np.max(class_probs, axis=1),\n", + " \"centroid\": centres,\n", + " }\n", + "\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + "\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + "\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " return (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " )\n", + "\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scale_factor = (0.5, 0.5)\n", + "origin = (0.0, 0.0)\n", + "\n", + "sizes = []\n", + "timings = []\n", + "\n", + "for num_patches in [10, 20, 50, 100, 200, 500, 1000]:\n", + " num_classes = min(num_patches, 100)\n", + "\n", + " (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " ) = make_test_data(\n", + " num_patches,\n", + " num_classes,\n", + " rng,\n", + " )\n", + "\n", + " python_store = PyDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " rust_store = RustDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " python_times = []\n", + " rust_times = []\n", + "\n", + " for _ in range(10):\n", + " # Python\n", + " start_time = time.time()\n", + "\n", + " python_objects = python_store.compute_qupath_json(\n", + " class_dict,\n", + " (0, 0),\n", + " (1, 1),\n", + " None,\n", + " 100,\n", + " 1,\n", + " )\n", + "\n", + " python_times.append(time.time() - start_time)\n", + "\n", + " start_time = time.time()\n", + "\n", + " rust_objects = rust_store.compute_qupath_json(\n", + " class_dict,\n", + " (0, 0),\n", + " (1, 1),\n", + " None,\n", + " 100,\n", + " 1,\n", + " )\n", + "\n", + " rust_times.append(time.time() - start_time)\n", + "\n", + " sizes.append(num_patches)\n", + "\n", + " timings.append(\n", + " [\n", + " np.mean(python_times),\n", + " np.mean(rust_times),\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timings = np.asarray(timings)\n", + "\n", + "plt.plot(sizes, timings[:, 0], label=\"Python\", marker=\"o\")\n", + "plt.plot(sizes, timings[:, 1], label=\"Rust\", marker=\"x\")\n", + "plt.xlabel(\"Number of annotations\")\n", + "plt.ylabel(\"Time (seconds)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6S8vzFipT5w" + }, + "source": [ + "# Part 4:\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DaskDelayedJSONStore written fully in python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from tiatoolbox.annotation import SQLiteStore\n", + "from tiatoolbox.annotation.storage import Annotation\n", + "\n", + "\n", + "class PyDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def _build_single_annotation(\n", + " self,\n", + " i: int,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " ) -> Annotation:\n", + " \"\"\"Build a single annotation for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " Returns:\n", + " Annotation:\n", + " A fully constructed TIAToolbox `Annotation` instance.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + "\n", + " properties = {\n", + " prop: (\n", + " class_dict[self._processed_predictions[prop][i]]\n", + " if prop == \"type\" and class_dict is not None\n", + " else np.array(self._processed_predictions[prop][i]).tolist()\n", + " )\n", + " for prop in self._processed_predictions\n", + " }\n", + "\n", + " return Annotation(geom, properties)\n", + "\n", + " def compute_annotations(\n", + " self,\n", + " store: SQLiteStore,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float] = (0, 0),\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " batch_size: int = 100,\n", + " num_workers: int = 0,\n", + " *,\n", + " verbose: bool = True,\n", + " ) -> SQLiteStore:\n", + " \"\"\"Compute annotations in batches and write them to a SQLiteStore.\n", + "\n", + " This method creates Dask Delayed tasks in batches to reduce scheduler\n", + " overhead. Each batch is computed and written immediately using\n", + " ``store.append_many()``.\n", + "\n", + " Args:\n", + " store (SQLiteStore):\n", + " A TIAToolbox SQLiteStore instance used to write annotations.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + "\n", + " origin (tuple[float, float], optional):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + " Defaults to ``(0, 0)``.\n", + "\n", + " scale_factor (tuple[float, float], optional):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + " Defaults to ``(1, 1)``.\n", + "\n", + " batch_size (int, optional):\n", + " Number of annotations to compute per batch. Larger batches\n", + " reduce Dask scheduler overhead. Defaults to ``100``.\n", + "\n", + " num_workers (int, optional):\n", + " Number of Dask workers to use. ``0`` means auto-detect.\n", + " Passed through to the progress bar helper. Defaults to ``0``.\n", + "\n", + " verbose (bool, optional):\n", + " Whether to display progress bars. Defaults to ``True``.\n", + "\n", + " Returns:\n", + " SQLiteStore:\n", + " The same store instance, after all annotations have been written.\n", + "\n", + " \"\"\"\n", + " num_contours = len(self._contours)\n", + " for batch_id in tqdm(\n", + " range(0, num_contours, batch_size),\n", + " leave=False,\n", + " desc=\"Calculating annotations in batches.\",\n", + " disable=not verbose,\n", + " ):\n", + " delayed_tasks = [\n", + " delayed(self._build_single_annotation)(\n", + " i,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " )\n", + " for i in tqdm(\n", + " range(batch_id, min(batch_id + batch_size, num_contours)),\n", + " leave=False,\n", + " desc=\"Creating list of delayed tasks for writing annotations\",\n", + " disable=not verbose,\n", + " )\n", + " ]\n", + "\n", + " store.append_many(\n", + " tqdm_dask_progress_bar(\n", + " write_tasks=delayed_tasks,\n", + " desc=\"Saving annotations\",\n", + " verbose=verbose,\n", + " num_workers=num_workers,\n", + " )\n", + " )\n", + " return store" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### RustDaskDelayedJSONStore with some code written in rust\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "class RustDaskDelayedJSONStore:\n", + " \"\"\"Compute and write TIAToolbox annotations using batched Dask Delayed tasks.\n", + "\n", + " This class parallelizes annotation construction using Dask Delayed while\n", + " avoiding serialization overhead by storing contours and prediction arrays\n", + " as instance attributes. Annotations are computed in batches and written\n", + " directly to a TIAToolbox `SQLiteStore` via `append_many()`.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " contours: np.ndarray,\n", + " processed_predictions: dict,\n", + " ) -> None:\n", + " \"\"\"Initialize :class:`DaskDelayedAnnotationStore`.\n", + "\n", + " Args:\n", + " contours (np.ndarray):\n", + " A sequence of polygon contours. Each element is an array-like\n", + " of shape ``(N_i, 2)`` representing the coordinates of a single\n", + " object contour.\n", + "\n", + " processed_predictions (dict):\n", + " A dictionary of per-object prediction fields. Each key maps to\n", + " an array-like of length ``len(contours)``. Example keys include\n", + " ``\"type\"``, ``\"prob\"``, ``\"centroid\"``, etc. May also contain\n", + " a global field ``\"geom_type\"``.\n", + "\n", + " \"\"\"\n", + " self._contours = contours\n", + " self._processed_predictions = processed_predictions\n", + "\n", + " def _build_single_annotation(\n", + " self,\n", + " i: int,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float],\n", + " scale_factor: tuple[float, float],\n", + " ) -> Annotation:\n", + " \"\"\"Build a single annotation for index ``i``.\n", + "\n", + " This method performs:\n", + " - geometry creation\n", + " - coordinate scaling and translation\n", + " - per-object property extraction\n", + " - optional class label mapping\n", + "\n", + " Args:\n", + " i (int):\n", + " Index of the object to convert into an annotation.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + " If ``None``, raw integer class IDs are used.\n", + "\n", + " origin (tuple[float, float]):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + "\n", + " scale_factor (tuple[float, float]):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + "\n", + " Returns:\n", + " Annotation:\n", + " A fully constructed TIAToolbox `Annotation` instance.\n", + "\n", + " \"\"\"\n", + " geom = make_valid_poly(\n", + " feature2geometry(\n", + " {\n", + " \"type\": self._processed_predictions.get(\"geom_type\", \"Polygon\"),\n", + " \"coordinates\": scale_factor * np.array([self._contours[i]]),\n", + " }\n", + " ),\n", + " tuple(origin),\n", + " )\n", + "\n", + " properties = {\n", + " prop: (\n", + " class_dict[self._processed_predictions[prop][i]]\n", + " if prop == \"type\" and class_dict is not None\n", + " else np.array(self._processed_predictions[prop][i]).tolist()\n", + " )\n", + " for prop in self._processed_predictions\n", + " }\n", + "\n", + " return Annotation(geom, properties)\n", + "\n", + " def compute_annotations(\n", + " self,\n", + " store: SQLiteStore,\n", + " class_dict: dict[int, str] | None,\n", + " origin: tuple[float, float] = (0, 0),\n", + " scale_factor: tuple[float, float] = (1, 1),\n", + " batch_size: int = 100,\n", + " num_workers: int = 0,\n", + " *,\n", + " verbose: bool = True,\n", + " ) -> SQLiteStore:\n", + " \"\"\"Compute annotations in batches and write them to a SQLiteStore.\n", + "\n", + " This method creates Dask Delayed tasks in batches to reduce scheduler\n", + " overhead. Each batch is computed and written immediately using\n", + " ``store.append_many()``.\n", + "\n", + " Args:\n", + " store (SQLiteStore):\n", + " A TIAToolbox SQLiteStore instance used to write annotations.\n", + "\n", + " class_dict (dict[int, str] | None):\n", + " Optional mapping from integer class IDs to string labels.\n", + "\n", + " origin (tuple[float, float], optional):\n", + " Translation offset ``(x, y)`` applied after scaling.\n", + " Defaults to ``(0, 0)``.\n", + "\n", + " scale_factor (tuple[float, float], optional):\n", + " Scaling factors ``(sx, sy)`` applied to contour coordinates.\n", + " Defaults to ``(1, 1)``.\n", + "\n", + " batch_size (int, optional):\n", + " Number of annotations to compute per batch. Larger batches\n", + " reduce Dask scheduler overhead. Defaults to ``100``.\n", + "\n", + " num_workers (int, optional):\n", + " Number of Dask workers to use. ``0`` means auto-detect.\n", + " Passed through to the progress bar helper. Defaults to ``0``.\n", + "\n", + " verbose (bool, optional):\n", + " Whether to display progress bars. Defaults to ``True``.\n", + "\n", + " Returns:\n", + " SQLiteStore:\n", + " The same store instance, after all annotations have been written.\n", + "\n", + " \"\"\"\n", + " return rmultitask.compute_annotations(\n", + " store,\n", + " class_dict,\n", + " origin,\n", + " scale_factor,\n", + " batch_size,\n", + " num_workers,\n", + " verbose,\n", + " len(self._contours),\n", + " self._build_single_annotation,\n", + " delayed,\n", + " tqdm_dask_progress_bar,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison of speed it takes to run code in rust vs python\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "88aeec175d9544ff815903d9531f98b2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Calculating annotations in batches.: 0%| | 0/1 [00:00 tuple[\n", + " np.ndarray,\n", + " dict[str, np.ndarray],\n", + " dict[int, str],\n", + " dict[int, list[int]],\n", + "]:\n", + " \"\"\"Generate test data for build single qupath feature.\"\"\"\n", + " # Example square polygons.\n", + " centres = rng.uniform(0, 10000, size=(num_patches, 2))\n", + "\n", + " square = np.array(\n", + " [\n", + " [-5.0, -5.0],\n", + " [5.0, -5.0],\n", + " [5.0, 5.0],\n", + " [-5.0, 5.0],\n", + " [-5.0, -5.0],\n", + " ]\n", + " )\n", + "\n", + " contours = np.array(\n", + " [centre + square for centre in centres],\n", + " dtype=object,\n", + " )\n", + "\n", + " class_probs = rng.random((num_patches, num_classes))\n", + " class_probs /= class_probs.sum(axis=1, keepdims=True)\n", + "\n", + " preds = np.argmax(class_probs, axis=1).astype(np.int32)\n", + "\n", + " processed_predictions = {\n", + " \"type\": preds,\n", + " \"prob\": np.max(class_probs, axis=1),\n", + " \"centroid\": centres,\n", + " }\n", + "\n", + " class_dict = {index: f\"class_{index}\" for index in range(num_classes)}\n", + "\n", + " cmap = plt.colormaps[\"tab20\"].resampled(num_classes)\n", + "\n", + " class_colours = {\n", + " class_idx: [\n", + " int(cmap(class_idx)[0] * 255),\n", + " int(cmap(class_idx)[1] * 255),\n", + " int(cmap(class_idx)[2] * 255),\n", + " ]\n", + " for class_idx in class_dict\n", + " }\n", + "\n", + " return (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " )\n", + "\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scale_factor = (0.5, 0.5)\n", + "origin = (0.0, 0.0)\n", + "\n", + "sizes = []\n", + "timings = []\n", + "\n", + "for num_patches in [10, 20, 50, 100, 200, 500, 1000]:\n", + " num_classes = min(num_patches, 100)\n", + "\n", + " (\n", + " contours,\n", + " processed_predictions,\n", + " class_dict,\n", + " class_colours,\n", + " ) = make_test_data(\n", + " num_patches,\n", + " num_classes,\n", + " rng,\n", + " )\n", + "\n", + " python_store = PyDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " rust_store = RustDaskDelayedJSONStore(\n", + " contours,\n", + " processed_predictions,\n", + " )\n", + "\n", + " python_times = []\n", + " rust_times = []\n", + "\n", + " for _ in range(10):\n", + " # Python\n", + " store = SQLiteStore()\n", + " start_time = time.time()\n", + "\n", + " python_objects = python_store.compute_annotations(\n", + " store,\n", + " class_dict,\n", + " (0, 0),\n", + " (1, 1),\n", + " 100,\n", + " 1,\n", + " )\n", + "\n", + " python_times.append(time.time() - start_time)\n", + " store = SQLiteStore()\n", + " start_time = time.time()\n", + "\n", + " rust_objects = rust_store.compute_annotations(\n", + " store,\n", + " class_dict,\n", + " (0, 0),\n", + " (1, 1),\n", + " 100,\n", + " 1,\n", + " )\n", + "\n", + " rust_times.append(time.time() - start_time)\n", + "\n", + " sizes.append(num_patches)\n", + "\n", + " timings.append(\n", + " [\n", + " np.mean(python_times),\n", + " np.mean(rust_times),\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timings = np.asarray(timings)\n", + "\n", + "plt.plot(sizes, timings[:, 0], label=\"Python\", marker=\"o\")\n", + "plt.plot(sizes, timings[:, 1], label=\"Rust\", marker=\"x\")\n", + "plt.xlabel(\"Number of annotations\")\n", + "plt.ylabel(\"Time (seconds)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(python_objects)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(rust_objects)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index c5c8398ab..97f644783 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,6 +1,15 @@ use pyo3::IntoPyObjectExt; use pyo3::prelude::*; -use pyo3::types::PyDict; +use pyo3::types::{PyDict, PyList}; +use pyo3::types::PyInt; +use std::collections::HashMap; + + +#[derive(Clone)] +enum StringOrFloat { + String(String), + Float(f64), +} #[pyfunction] fn add(a: i32, b: i32) -> i32 { @@ -75,9 +84,211 @@ fn build_single_qupath_feature<'py>( Ok(single_qupath_feature.unbind()) } +#[pyfunction] +fn build_single_annotation( + py: Python<'_>, + np: &Bound<'_, PyAny>, + i: i32, + processed_predictions: &Bound<'_, PyDict>, + class_dict: &Bound<'_, PyDict>, +) -> PyResult> { + let class_dict_is_none = class_dict.is_none(); + let properties = PyDict::new(py); + let np_array = np.getattr("array")?; + for (prop, arr) in processed_predictions.iter() { + if prop.eq("type")? && !class_dict_is_none { + properties.set_item(prop, class_dict.get_item(arr.get_item(i)?)?)?; + } else { + properties.set_item(prop, np_array.call1((arr.get_item(i)?,))?.call_method0("tolist")?)?; + } + } + Ok(properties.unbind()) +} + +#[pyfunction] +fn compute_qupath_json( + py: Python<'_>, + class_dict: &Bound<'_, PyDict>, + origin: (f64, f64), + scale_factor: (f64, f64), + batch_size: i32, + verbose: bool, + num_workers: i32, + num_contours: i32, + type_arr: &Bound<'_, PyList>, + plt: &Bound<'_, PyAny>, + py_build_single_qupath_feature: &Bound<'_, PyAny>, + delayed: &Bound<'_, PyAny>, + tqdm_dask_progress_bar: &Bound<'_, PyAny> +) -> PyResult> { + let builtins = py.import("builtins")?; + let features = PyList::empty(py); + if class_dict.len() == 0 { + let valid_ids = PyList::empty(py); + let mut valid_ids_contain_all_ints = true; + for v in type_arr.iter() { + if !v.is_none() { + valid_ids.append(&v)?; + if !v.is_instance_of::() { + valid_ids_contain_all_ints = false; + } + } + } + if valid_ids.len() == 0 { + class_dict.set_item(0, 0)?; + } else if valid_ids_contain_all_ints { + let max_class: i64 = builtins + .getattr("max")? + .call1((&valid_ids,))? + .extract()?; + for i in 0..max_class + 1 { + class_dict.set_item(i, i)?; + } + } else { + let unique_names = builtins + .getattr("sorted")? + .call1((builtins + .getattr("set")? + .call1((&valid_ids,))?, + ))?; + for name in unique_names.try_iter() { + class_dict.set_item(&name, &name)?; + } + } + } + let class_keys = class_dict.keys(); + let num_classes = class_keys.len(); + + + let colormaps = plt.getattr("colormaps")?; + let tab20 = colormaps.get_item("tab20")?; + let cmap = tab20 + .call_method1("resampled", (num_classes,))?; + + let class_colors = PyDict::new(py); + + for (i, key) in class_keys.iter().enumerate() { + let rgba = cmap.call1((i,))?; + + let r: f64 = rgba.get_item(0)?.extract()?; + let g: f64 = rgba.get_item(1)?.extract()?; + let b: f64 = rgba.get_item(2)?.extract()?; + + let color = vec![ + (r * 255.0) as i64, + (g * 255.0) as i64, + (b * 255.0) as i64, + ]; + + class_colors.set_item(key, color)?; + } + for batch_id in (0..num_contours).step_by(batch_size as usize) { + let delayed_tasks = PyList::empty(py); + for i in batch_id..std::cmp::min(batch_id+batch_size, num_contours) { + delayed_tasks.append(delayed + .call1((py_build_single_qupath_feature,))? + .call1(( + i, + class_dict, + origin, + scale_factor, + &class_colors, + ))?)?; + } + let kwargs = PyDict::new(py); + kwargs.set_item("write_tasks", delayed_tasks)?; + kwargs.set_item("desc", "Computing QuPath features")?; + kwargs.set_item("verbose", verbose)?; + kwargs.set_item("num_workers", num_workers)?; + let feature = tqdm_dask_progress_bar.call((), Some(&kwargs))?; + for f in feature.try_iter()? { + features.append(f?)?; + } + } + Ok(features.unbind()) +} + +#[pyfunction] +fn compute_annotations( + py: Python<'_>, + store: &Bound<'_, PyAny>, + class_dict: &Bound<'_, PyDict>, + origin: (f64, f64), + scale_factor: (f64, f64), + batch_size: i32, + num_workers: i32, + verbose: bool, + num_contours: i32, + py_build_single_annotation: &Bound<'_, PyAny>, + delayed: &Bound<'_, PyAny>, + tqdm_dask_progress_bar: &Bound<'_, PyAny> +) -> PyResult> { + /*Compute annotations in batches and write them to a SQLiteStore. + + This method creates Dask Delayed tasks in batches to reduce scheduler + overhead. Each batch is computed and written immediately using + ``store.append_many()``. + + Args: + store (SQLiteStore): + A TIAToolbox SQLiteStore instance used to write annotations. + + class_dict (dict[int, str] | None): + Optional mapping from integer class IDs to string labels. + + origin (tuple[float, float], optional): + Translation offset ``(x, y)`` applied after scaling. + Defaults to ``(0, 0)``. + + scale_factor (tuple[float, float], optional): + Scaling factors ``(sx, sy)`` applied to contour coordinates. + Defaults to ``(1, 1)``. + + batch_size (int, optional): + Number of annotations to compute per batch. Larger batches + reduce Dask scheduler overhead. Defaults to ``100``. + + num_workers (int, optional): + Number of Dask workers to use. ``0`` means auto-detect. + Passed through to the progress bar helper. Defaults to ``0``. + + verbose (bool, optional): + Whether to display progress bars. Defaults to ``True``. + + Returns: + SQLiteStore: + The same store instance, after all annotations have been written. + + */ + for batch_id in (0..num_contours).step_by(batch_size as usize) { + let delayed_tasks = PyList::empty(py); + for i in batch_id..std::cmp::min(batch_id+batch_size, num_contours) { + delayed_tasks.append(delayed + .call1((py_build_single_annotation,))? + .call1(( + i, + class_dict, + origin, + scale_factor, + ))?)?; + } + let kwargs = PyDict::new(py); + kwargs.set_item("write_tasks", delayed_tasks)?; + kwargs.set_item("desc", "Saving annotations")?; + kwargs.set_item("verbose", verbose)?; + kwargs.set_item("num_workers", num_workers)?; + let feature = tqdm_dask_progress_bar.call((), Some(&kwargs))?; + store.call_method1("append_many", (feature, ))?; + } + Ok(store.into()) +} + #[pymodule] fn rmultitask(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(add, m)?)?; m.add_function(wrap_pyfunction!(build_single_qupath_feature, m)?)?; + m.add_function(wrap_pyfunction!(build_single_annotation, m)?)?; + m.add_function(wrap_pyfunction!(compute_qupath_json, m)?)?; + m.add_function(wrap_pyfunction!(compute_annotations, m)?)?; Ok(()) } From b3c3a6c6eebd74837e76e396428f8b14e10b56bd Mon Sep 17 00:00:00 2001 From: Hannah Wood Date: Mon, 31 Aug 2026 15:57:49 +0100 Subject: [PATCH 110/112] Updated formatting --- tiatoolbox/rust-library/multitask/src/lib.rs | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index 97f644783..95c36dffd 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -4,13 +4,6 @@ use pyo3::types::{PyDict, PyList}; use pyo3::types::PyInt; use std::collections::HashMap; - -#[derive(Clone)] -enum StringOrFloat { - String(String), - Float(f64), -} - #[pyfunction] fn add(a: i32, b: i32) -> i32 { a + b @@ -151,7 +144,7 @@ fn compute_qupath_json( .getattr("set")? .call1((&valid_ids,))?, ))?; - for name in unique_names.try_iter() { + while let Ok(name) = unique_names.try_iter() { class_dict.set_item(&name, &name)?; } } From fef4a2e0f51ee39a758efd697839feb125cd2738 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Mon, 31 Aug 2026 15:58:51 +0100 Subject: [PATCH 111/112] Updated formatting for rmultitask --- tiatoolbox/rust-library/multitask/src/lib.rs | 49 ++++++++------------ 1 file changed, 19 insertions(+), 30 deletions(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index 95c36dffd..cf07035a5 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -1,7 +1,7 @@ use pyo3::IntoPyObjectExt; use pyo3::prelude::*; -use pyo3::types::{PyDict, PyList}; use pyo3::types::PyInt; +use pyo3::types::{PyDict, PyList}; use std::collections::HashMap; #[pyfunction] @@ -92,7 +92,12 @@ fn build_single_annotation( if prop.eq("type")? && !class_dict_is_none { properties.set_item(prop, class_dict.get_item(arr.get_item(i)?)?)?; } else { - properties.set_item(prop, np_array.call1((arr.get_item(i)?,))?.call_method0("tolist")?)?; + properties.set_item( + prop, + np_array + .call1((arr.get_item(i)?,))? + .call_method0("tolist")?, + )?; } } Ok(properties.unbind()) @@ -112,7 +117,7 @@ fn compute_qupath_json( plt: &Bound<'_, PyAny>, py_build_single_qupath_feature: &Bound<'_, PyAny>, delayed: &Bound<'_, PyAny>, - tqdm_dask_progress_bar: &Bound<'_, PyAny> + tqdm_dask_progress_bar: &Bound<'_, PyAny>, ) -> PyResult> { let builtins = py.import("builtins")?; let features = PyList::empty(py); @@ -130,20 +135,14 @@ fn compute_qupath_json( if valid_ids.len() == 0 { class_dict.set_item(0, 0)?; } else if valid_ids_contain_all_ints { - let max_class: i64 = builtins - .getattr("max")? - .call1((&valid_ids,))? - .extract()?; + let max_class: i64 = builtins.getattr("max")?.call1((&valid_ids,))?.extract()?; for i in 0..max_class + 1 { class_dict.set_item(i, i)?; } } else { let unique_names = builtins - .getattr("sorted")? - .call1((builtins - .getattr("set")? - .call1((&valid_ids,))?, - ))?; + .getattr("sorted")? + .call1((builtins.getattr("set")?.call1((&valid_ids,))?,))?; while let Ok(name) = unique_names.try_iter() { class_dict.set_item(&name, &name)?; } @@ -152,11 +151,9 @@ fn compute_qupath_json( let class_keys = class_dict.keys(); let num_classes = class_keys.len(); - let colormaps = plt.getattr("colormaps")?; let tab20 = colormaps.get_item("tab20")?; - let cmap = tab20 - .call_method1("resampled", (num_classes,))?; + let cmap = tab20.call_method1("resampled", (num_classes,))?; let class_colors = PyDict::new(py); @@ -167,20 +164,14 @@ fn compute_qupath_json( let g: f64 = rgba.get_item(1)?.extract()?; let b: f64 = rgba.get_item(2)?.extract()?; - let color = vec![ - (r * 255.0) as i64, - (g * 255.0) as i64, - (b * 255.0) as i64, - ]; + let color = vec![(r * 255.0) as i64, (g * 255.0) as i64, (b * 255.0) as i64]; class_colors.set_item(key, color)?; } for batch_id in (0..num_contours).step_by(batch_size as usize) { let delayed_tasks = PyList::empty(py); - for i in batch_id..std::cmp::min(batch_id+batch_size, num_contours) { - delayed_tasks.append(delayed - .call1((py_build_single_qupath_feature,))? - .call1(( + for i in batch_id..std::cmp::min(batch_id + batch_size, num_contours) { + delayed_tasks.append(delayed.call1((py_build_single_qupath_feature,))?.call1(( i, class_dict, origin, @@ -214,7 +205,7 @@ fn compute_annotations( num_contours: i32, py_build_single_annotation: &Bound<'_, PyAny>, delayed: &Bound<'_, PyAny>, - tqdm_dask_progress_bar: &Bound<'_, PyAny> + tqdm_dask_progress_bar: &Bound<'_, PyAny>, ) -> PyResult> { /*Compute annotations in batches and write them to a SQLiteStore. @@ -255,10 +246,8 @@ fn compute_annotations( */ for batch_id in (0..num_contours).step_by(batch_size as usize) { let delayed_tasks = PyList::empty(py); - for i in batch_id..std::cmp::min(batch_id+batch_size, num_contours) { - delayed_tasks.append(delayed - .call1((py_build_single_annotation,))? - .call1(( + for i in batch_id..std::cmp::min(batch_id + batch_size, num_contours) { + delayed_tasks.append(delayed.call1((py_build_single_annotation,))?.call1(( i, class_dict, origin, @@ -271,7 +260,7 @@ fn compute_annotations( kwargs.set_item("verbose", verbose)?; kwargs.set_item("num_workers", num_workers)?; let feature = tqdm_dask_progress_bar.call((), Some(&kwargs))?; - store.call_method1("append_many", (feature, ))?; + store.call_method1("append_many", (feature,))?; } Ok(store.into()) } From 0d2ad81270534608351a602f5fb0d5f918769ad1 Mon Sep 17 00:00:00 2001 From: hannah275 Date: Mon, 31 Aug 2026 16:00:18 +0100 Subject: [PATCH 112/112] Removed unused import --- tiatoolbox/rust-library/multitask/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/tiatoolbox/rust-library/multitask/src/lib.rs b/tiatoolbox/rust-library/multitask/src/lib.rs index cf07035a5..6e108318a 100644 --- a/tiatoolbox/rust-library/multitask/src/lib.rs +++ b/tiatoolbox/rust-library/multitask/src/lib.rs @@ -2,7 +2,6 @@ use pyo3::IntoPyObjectExt; use pyo3::prelude::*; use pyo3::types::PyInt; use pyo3::types::{PyDict, PyList}; -use std::collections::HashMap; #[pyfunction] fn add(a: i32, b: i32) -> i32 {