diff --git a/README.md b/README.md
index 6737b54a06..23445afb1a 100644
--- a/README.md
+++ b/README.md
@@ -86,6 +86,7 @@ repo](https://github.com/rapidsai/notebooks-contrib).
 | Category | Algorithm | Notes |
 | --- | --- | --- |
 | **Clustering** |  Density-Based Spatial Clustering of Applications with Noise (DBSCAN) | Multi-node multi-GPU via Dask |
+|  | Hierarchical Density-Based Spatial Clustering of Applications with Noise (HDBSCAN)  | Experimental |
 |  | K-Means | Multi-node multi-GPU via Dask |
 |  | Single-Linkage Agglomerative Clustering | |
 | **Dimensionality Reduction** | Principal Components Analysis (PCA) | Multi-node multi-GPU via Dask|
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 1da22c3fa6..55f0d9a985 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -225,6 +225,8 @@ if(BUILD_CUML_CPP_LIBRARY)
     src/glm/glm.cu
     src/genetic/genetic.cu
     src/genetic/node.cu
+    src/hdbscan/hdbscan.cu
+    src/hdbscan/condensed_hierarchy.cu
     src/holtwinters/holtwinters.cu
     src/kmeans/kmeans.cu
     src/knn/knn.cu
diff --git a/cpp/include/cuml/cluster/hdbscan.hpp b/cpp/include/cuml/cluster/hdbscan.hpp
new file mode 100644
index 0000000000..965cf58bb2
--- /dev/null
+++ b/cpp/include/cuml/cluster/hdbscan.hpp
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <raft/linalg/distance_type.h>
+#include <raft/handle.hpp>
+
+#include <rmm/device_uvector.hpp>
+
+#include <cstddef>
+
+namespace ML {
+namespace HDBSCAN {
+namespace Common {
+
+/**
+ * The Condensed hierarchicy is represented by an edge list with
+ * parents as the source vertices, children as the destination,
+ * with attributes for the cluster size and lambda value.
+ *
+ * @tparam value_idx
+ * @tparam value_t
+ */
+template <typename value_idx, typename value_t>
+class CondensedHierarchy {
+ public:
+  /**
+   * Constructs an empty condensed hierarchy object which requires
+   * condense() to be called in order to populate the state.
+   * @param handle_
+   * @param n_leaves_
+   */
+  CondensedHierarchy(const raft::handle_t &handle_, size_t n_leaves_);
+
+  /**
+   * Constructs a condensed hierarchy object with existing arrays
+   * which already contain a condensed hierarchy.
+   * @param handle_
+   * @param n_leaves_
+   * @param n_edges_
+   * @param parents_
+   * @param children_
+   * @param lambdas_
+   * @param sizes_
+   */
+  CondensedHierarchy(const raft::handle_t &handle_, size_t n_leaves_,
+                     int n_edges_, value_idx *parents_, value_idx *children_,
+                     value_t *lambdas_, value_idx *sizes_);
+
+  /**
+   * Constructs a condensed hierarchy object by moving
+   * rmm::device_uvector. Used to construct cluster trees
+   * @param handle_
+   * @param n_leaves_
+   * @param n_edges_
+   * @param n_clusters_
+   * @param parents_
+   * @param children_
+   * @param lambdas_
+   * @param sizes_
+   */
+  CondensedHierarchy(const raft::handle_t &handle_, size_t n_leaves_,
+                     int n_edges_, int n_clusters_,
+                     rmm::device_uvector<value_idx> &&parents_,
+                     rmm::device_uvector<value_idx> &&children_,
+                     rmm::device_uvector<value_t> &&lambdas_,
+                     rmm::device_uvector<value_idx> &&sizes_);
+  /**
+   * To maintain a high level of parallelism, the output from
+   * Condense::build_condensed_hierarchy() is sparse (the cluster
+   * nodes inside any collapsed subtrees will be 0).
+   *
+   * This function converts the sparse form to a dense form and renumbers
+   * the cluster nodes into a topological sort order. The renumbering
+   * reverses the values in the parent array since root has the largest value
+   * in the single-linkage tree. Then, it makes the combined parent and
+   * children arrays monotonic. Finally all of the arrays of the dendrogram
+   * are sorted by parent->children->sizes (e.g. topological). The root node
+   * will always have an id of 0 and the largest cluster size.
+   *
+   * Ths single-linkage tree dendrogram is a binary tree and parents/children
+   * can be found with simple indexing arithmetic but the condensed tree no
+   * longer has this property and so the tree now relies on either
+   * special indexing or the topological ordering for efficient traversal.
+   */
+  void condense(value_idx *full_parents, value_idx *full_children,
+                value_t *full_lambdas, value_idx *full_sizes,
+                value_idx size = -1);
+
+  value_idx get_cluster_tree_edges();
+
+  value_idx *get_parents() { return parents.data(); }
+  value_idx *get_children() { return children.data(); }
+  value_t *get_lambdas() { return lambdas.data(); }
+  value_idx *get_sizes() { return sizes.data(); }
+  value_idx get_n_edges() { return n_edges; }
+  int get_n_clusters() { return n_clusters; }
+  value_idx get_n_leaves() const { return n_leaves; }
+
+ private:
+  const raft::handle_t &handle;
+
+  rmm::device_uvector<value_idx> parents;
+  rmm::device_uvector<value_idx> children;
+  rmm::device_uvector<value_t> lambdas;
+  rmm::device_uvector<value_idx> sizes;
+
+  size_t n_edges;
+  size_t n_leaves;
+  int n_clusters;
+  value_idx root_cluster;
+};
+
+enum CLUSTER_SELECTION_METHOD { EOM = 0, LEAF = 1 };
+
+class RobustSingleLinkageParams {
+ public:
+  int k = 5;
+  int min_samples = 5;
+  int min_cluster_size = 5;
+  int max_cluster_size = 0;
+
+  float cluster_selection_epsilon = 0.0;
+
+  bool allow_single_cluster = false;
+
+  float alpha = 1.0;
+};
+
+class HDBSCANParams : public RobustSingleLinkageParams {
+ public:
+  CLUSTER_SELECTION_METHOD cluster_selection_method =
+    CLUSTER_SELECTION_METHOD::EOM;
+};
+
+/**
+ * Container object for output information common between
+ * robust single linkage variants.
+ * @tparam value_idx
+ * @tparam value_t
+ */
+template <typename value_idx, typename value_t>
+class robust_single_linkage_output {
+ public:
+  /**
+   * Construct output object with empty device arrays of
+   * known size.
+   * @param handle_ raft handle for ordering cuda operations
+   * @param n_leaves_  number of data points
+   * @param labels_ labels array on device (size n_leaves)
+   * @param children_ dendrogram src/dst array (size n_leaves - 1, 2)
+   * @param sizes_ dendrogram cluster sizes array (size n_leaves - 1)
+   * @param deltas_ dendrogram distances array (size n_leaves - 1)
+   * @param mst_src_ min spanning tree source array (size n_leaves - 1)
+   * @param mst_dst_ min spanning tree destination array (size n_leaves - 1)
+   * @param mst_weights_ min spanninng tree distances array (size n_leaves - 1)
+   */
+  robust_single_linkage_output(const raft::handle_t &handle_, int n_leaves_,
+                               value_idx *labels_, value_idx *children_,
+                               value_idx *sizes_, value_t *deltas_,
+                               value_idx *mst_src_, value_idx *mst_dst_,
+                               value_t *mst_weights_)
+    : handle(handle_),
+      n_leaves(n_leaves_),
+      n_clusters(0),
+      labels(labels_),
+      children(children_),
+      sizes(sizes_),
+      deltas(deltas_),
+      mst_src(mst_src_),
+      mst_dst(mst_dst_),
+      mst_weights(mst_weights_) {}
+
+  int get_n_leaves() const { return n_leaves; }
+  int get_n_clusters() const { return n_clusters; }
+  value_idx *get_labels() { return labels; }
+  value_idx *get_children() { return children; }
+  value_idx *get_sizes() { return sizes; }
+  value_t *get_deltas() { return deltas; }
+  value_idx *get_mst_src() { return mst_src; }
+  value_idx *get_mst_dst() { return mst_dst; }
+  value_t *get_mst_weights() { return mst_weights; }
+
+  /**
+   * The number of clusters is set by the algorithm once it is known.
+   * @param n_clusters_ number of resulting clusters
+   */
+  void set_n_clusters(int n_clusters_) { n_clusters = n_clusters_; }
+
+ protected:
+  const raft::handle_t &get_handle() { return handle; }
+
+  const raft::handle_t &handle;
+
+  int n_leaves;
+  int n_clusters;
+
+  value_idx *labels;  // size n_leaves
+
+  // Dendrogram
+  value_idx *children;  // size n_leaves * 2
+  value_idx *sizes;     // size n_leaves
+  value_t *deltas;      // size n_leaves
+
+  // MST (size n_leaves - 1).
+  value_idx *mst_src;
+  value_idx *mst_dst;
+  value_t *mst_weights;
+};
+
+/**
+ * Plain old container object to consolidate output
+ * arrays. This object is intentionally kept simple
+ * and straightforward in order to ease its use
+ * in the Python layer. For this reason, the MST
+ * arrays and renumbered dendrogram array, as well
+ * as its aggregated distances/cluster sizes, are
+ * kept separate. The condensed hierarchy is computed
+ * and populated in a separate object because its size
+ * is not known ahead of time. An RMM device vector is
+ * held privately and stabilities initialized explicitly
+ * since that size is also not known ahead of time.
+ * @tparam value_idx
+ * @tparam value_t
+ */
+template <typename value_idx, typename value_t>
+class hdbscan_output : public robust_single_linkage_output<value_idx, value_t> {
+ public:
+  hdbscan_output(const raft::handle_t &handle_, int n_leaves_,
+                 value_idx *labels_, value_t *probabilities_,
+                 value_idx *children_, value_idx *sizes_, value_t *deltas_,
+                 value_idx *mst_src_, value_idx *mst_dst_,
+                 value_t *mst_weights_)
+    : robust_single_linkage_output<value_idx, value_t>(
+        handle_, n_leaves_, labels_, children_, sizes_, deltas_, mst_src_,
+        mst_dst_, mst_weights_),
+      probabilities(probabilities_),
+      stabilities(0, handle_.get_stream()),
+      condensed_tree(handle_, n_leaves_) {}
+
+  // Using getters here, making the members private and forcing
+  // consistent state with the constructor. This should make
+  // it much easier to use / debug.
+  value_t *get_probabilities() { return probabilities; }
+  value_t *get_stabilities() {
+    ASSERT(stabilities.size() > 0, "stabilities needs to be initialized");
+    return stabilities.data();
+  }
+
+  /**
+   * Once n_clusters is known, the stabilities array
+   * can be initialized.
+   * @param n_clusters_
+   */
+  void set_n_clusters(int n_clusters_) {
+    robust_single_linkage_output<value_idx, value_t>::set_n_clusters(
+      n_clusters_);
+    stabilities.resize(
+      n_clusters_,
+      robust_single_linkage_output<value_idx, value_t>::get_handle()
+        .get_stream());
+  }
+
+  CondensedHierarchy<value_idx, value_t> &get_condensed_tree() {
+    return condensed_tree;
+  }
+
+ private:
+  value_t *probabilities;  // size n_leaves
+
+  // Size not known ahead of time. Initialize
+  // with `initialize_stabilities()` method.
+  rmm::device_uvector<value_t> stabilities;
+
+  // Use condensed hierarchy to wrap
+  // condensed tree outputs since we do not
+  // know the size ahead of time.
+  CondensedHierarchy<value_idx, value_t> condensed_tree;
+};
+
+template class CondensedHierarchy<int, float>;
+
+};  // namespace Common
+};  // namespace HDBSCAN
+
+/**
+ * Executes HDBSCAN clustering on an mxn-dimensional input array, X.
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] X array (size m, n) on device in row-major format
+ * @param m number of rows in X
+ * @param n number of columns in X
+ * @param metric distance metric to use
+ * @param params struct of configuration hyper-parameters
+ * @param out struct of output data and arrays on device
+ */
+void hdbscan(const raft::handle_t &handle, const float *X, size_t m, size_t n,
+             raft::distance::DistanceType metric,
+             HDBSCAN::Common::HDBSCANParams &params,
+             HDBSCAN::Common::hdbscan_output<int, float> &out);
+}  // END namespace ML
\ No newline at end of file
diff --git a/cpp/include/cuml/cluster/linkage.hpp b/cpp/include/cuml/cluster/linkage.hpp
index 64284be729..7a778ea5da 100644
--- a/cpp/include/cuml/cluster/linkage.hpp
+++ b/cpp/include/cuml/cluster/linkage.hpp
@@ -18,6 +18,7 @@
 
 #include <raft/linalg/distance_type.h>
 #include <raft/sparse/hierarchy/common.h>
+#include <raft/handle.hpp>
 
 namespace raft {
 class handle_t;
diff --git a/cpp/src/hdbscan/condensed_hierarchy.cu b/cpp/src/hdbscan/condensed_hierarchy.cu
new file mode 100644
index 0000000000..c262828afb
--- /dev/null
+++ b/cpp/src/hdbscan/condensed_hierarchy.cu
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <raft/label/classlabels.cuh>
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+#include <cuml/common/logger.hpp>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <thrust/execution_policy.h>
+#include <thrust/reduce.h>
+#include <thrust/transform_reduce.h>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace Common {
+
+struct TupleComp {
+  template <typename one, typename two>
+  __host__ __device__ bool operator()(const one &t1, const two &t2) {
+    // sort first by each parent,
+    if (thrust::get<0>(t1) < thrust::get<0>(t2)) return true;
+    if (thrust::get<0>(t1) > thrust::get<0>(t2)) return false;
+
+    // within each parent, sort by each child,
+    if (thrust::get<1>(t1) < thrust::get<1>(t2)) return true;
+    if (thrust::get<1>(t1) > thrust::get<1>(t2)) return false;
+
+    // then sort by value in descending order
+    return thrust::get<2>(t1) < thrust::get<2>(t2);
+  }
+};
+
+template <typename value_idx, typename value_t>
+CondensedHierarchy<value_idx, value_t>::CondensedHierarchy(
+  const raft::handle_t &handle_, size_t n_leaves_)
+  : handle(handle_),
+    n_leaves(n_leaves_),
+    parents(0, handle.get_stream()),
+    children(0, handle.get_stream()),
+    lambdas(0, handle.get_stream()),
+    sizes(0, handle.get_stream()) {}
+
+template <typename value_idx, typename value_t>
+CondensedHierarchy<value_idx, value_t>::CondensedHierarchy(
+  const raft::handle_t &handle_, size_t n_leaves_, int n_edges_,
+  value_idx *parents_, value_idx *children_, value_t *lambdas_,
+  value_idx *sizes_)
+  : handle(handle_),
+    n_leaves(n_leaves_),
+    n_edges(n_edges_),
+    parents(0, handle.get_stream()),
+    children(0, handle.get_stream()),
+    lambdas(0, handle.get_stream()),
+    sizes(0, handle.get_stream()) {
+  parents.resize(n_edges_, handle.get_stream());
+  children.resize(n_edges_, handle.get_stream());
+  lambdas.resize(n_edges_, handle.get_stream());
+  sizes.resize(n_edges_, handle.get_stream());
+
+  raft::copy(parents.begin(), parents_, n_edges_, handle.get_stream());
+  raft::copy(children.begin(), children_, n_edges_, handle.get_stream());
+  raft::copy(lambdas.begin(), lambdas_, n_edges_, handle.get_stream());
+  raft::copy(sizes.begin(), sizes_, n_edges_, handle.get_stream());
+
+  auto parents_ptr = thrust::device_pointer_cast(parents.data());
+
+  auto parents_min_max =
+    thrust::minmax_element(thrust::cuda::par.on(handle.get_stream()),
+                           parents_ptr, parents_ptr + n_edges);
+  auto min_cluster = *parents_min_max.first;
+  auto max_cluster = *parents_min_max.second;
+
+  n_clusters = max_cluster - min_cluster + 1;
+
+  auto sort_keys = thrust::make_zip_iterator(
+    thrust::make_tuple(parents.begin(), children.begin(), sizes.begin()));
+  auto sort_values =
+    thrust::make_zip_iterator(thrust::make_tuple(lambdas.begin()));
+
+  thrust::sort_by_key(thrust::cuda::par.on(handle.get_stream()), sort_keys,
+                      sort_keys + n_edges, sort_values, TupleComp());
+}
+
+template <typename value_idx, typename value_t>
+CondensedHierarchy<value_idx, value_t>::CondensedHierarchy(
+  const raft::handle_t &handle_, size_t n_leaves_, int n_edges_,
+  int n_clusters_, rmm::device_uvector<value_idx> &&parents_,
+  rmm::device_uvector<value_idx> &&children_,
+  rmm::device_uvector<value_t> &&lambdas_,
+  rmm::device_uvector<value_idx> &&sizes_)
+  : handle(handle_),
+    n_leaves(n_leaves_),
+    n_edges(n_edges_),
+    n_clusters(n_clusters_),
+    parents(std::move(parents_)),
+    children(std::move(children_)),
+    lambdas(std::move(lambdas_)),
+    sizes(std::move(sizes_)) {}
+
+/**
+ * Populates the condensed hierarchy object with the output
+ * from Condense::condense_hierarchy
+ * @param full_parents
+ * @param full_children
+ * @param full_lambdas
+ * @param full_sizes
+ */
+template <typename value_idx, typename value_t>
+void CondensedHierarchy<value_idx, value_t>::condense(value_idx *full_parents,
+                                                      value_idx *full_children,
+                                                      value_t *full_lambdas,
+                                                      value_idx *full_sizes,
+                                                      value_idx size) {
+  auto stream = handle.get_stream();
+
+  if (size == -1) size = 4 * (n_leaves - 1) + 2;
+
+  n_edges = thrust::transform_reduce(
+    thrust::cuda::par.on(stream), full_sizes, full_sizes + size,
+    [=] __device__(value_idx a) { return a != -1; }, 0,
+    thrust::plus<value_idx>());
+
+  parents.resize(n_edges, stream);
+  children.resize(n_edges, stream);
+  lambdas.resize(n_edges, stream);
+  sizes.resize(n_edges, stream);
+
+  auto in = thrust::make_zip_iterator(
+    thrust::make_tuple(full_parents, full_children, full_lambdas, full_sizes));
+
+  auto out = thrust::make_zip_iterator(thrust::make_tuple(
+    parents.data(), children.data(), lambdas.data(), sizes.data()));
+
+  thrust::copy_if(
+    thrust::cuda::par.on(stream), in, in + size, out,
+    [=] __device__(
+      thrust::tuple<value_idx, value_idx, value_t, value_idx> tup) {
+      return thrust::get<3>(tup) != -1;
+    });
+
+  // TODO: Avoid the copies here by updating kernel
+  rmm::device_uvector<value_idx> parent_child(n_edges * 2, stream);
+  raft::copy_async(parent_child.begin(), children.begin(), n_edges, stream);
+  raft::copy_async(parent_child.begin() + n_edges, parents.begin(), n_edges,
+                   stream);
+
+  // find n_clusters
+  auto parents_ptr = thrust::device_pointer_cast(parents.data());
+  auto max_parent = *(thrust::max_element(thrust::cuda::par.on(stream),
+                                          parents_ptr, parents_ptr + n_edges));
+
+  // now invert labels
+  auto invert_op = [max_parent, n_leaves = n_leaves] __device__(auto &x) {
+    return x >= n_leaves ? max_parent - x + n_leaves : x;
+  };
+
+  thrust::transform(thrust::cuda::par.on(stream), parent_child.begin(),
+                    parent_child.end(), parent_child.begin(), invert_op);
+
+  raft::label::make_monotonic(parent_child.data(), parent_child.data(),
+                              parent_child.size(), stream,
+                              handle.get_device_allocator(), true);
+
+  raft::copy_async(children.begin(), parent_child.begin(), n_edges, stream);
+  raft::copy_async(parents.begin(), parent_child.begin() + n_edges, n_edges,
+                   stream);
+
+  auto parents_min_max = thrust::minmax_element(
+    thrust::cuda::par.on(stream), parents_ptr, parents_ptr + n_edges);
+  auto min_cluster = *parents_min_max.first;
+  auto max_cluster = *parents_min_max.second;
+
+  n_clusters = max_cluster - min_cluster + 1;
+
+  auto sort_keys = thrust::make_zip_iterator(
+    thrust::make_tuple(parents.begin(), children.begin(), sizes.begin()));
+  auto sort_values =
+    thrust::make_zip_iterator(thrust::make_tuple(lambdas.begin()));
+
+  thrust::sort_by_key(thrust::cuda::par.on(stream), sort_keys,
+                      sort_keys + n_edges, sort_values, TupleComp());
+}
+
+};  // namespace Common
+};  // namespace HDBSCAN
+};  // namespace ML
diff --git a/cpp/src/hdbscan/detail/condense.cuh b/cpp/src/hdbscan/detail/condense.cuh
new file mode 100644
index 0000000000..e5aa447c98
--- /dev/null
+++ b/cpp/src/hdbscan/detail/condense.cuh
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "kernels/condense.cuh"
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <thrust/execution_policy.h>
+#include <thrust/reduce.h>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Condense {
+
+/**
+ * Condenses a binary single-linkage tree dendrogram in the Scipy hierarchy
+ * format by collapsing subtrees that fall below a minimum cluster size.
+ *
+ * For increased parallelism, the output array sizes are held fixed but
+ * the result will be sparse (e.g. zeros in place of parents who have been
+ * removed / collapsed). This function accepts an empty instance of
+ * `CondensedHierarchy` and invokes the `condense()` function on it to
+ * convert the sparse output arrays into their dense form.
+ *
+ * @tparam value_idx
+ * @tparam value_t
+ * @tparam tpb
+ * @param handle
+ * @param[in] children parents/children from single-linkage dendrogram
+ * @param[in] delta distances from single-linkage dendrogram
+ * @param[in] sizes sizes from single-linkage dendrogram
+ * @param[in] min_cluster_size any subtrees less than this size will be
+ *                             collapsed.
+ * @param[in] n_leaves number of actual data samples in the dendrogram
+ * @param[out] condensed_tree output dendrogram. will likely no longer be
+ *                            a binary tree.
+ */
+template <typename value_idx, typename value_t, int tpb = 256>
+void build_condensed_hierarchy(
+  const raft::handle_t &handle, const value_idx *children, const value_t *delta,
+  const value_idx *sizes, int min_cluster_size, int n_leaves,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree) {
+  cudaStream_t stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  // Root is the last edge in the dendrogram
+  int root = 2 * (n_leaves - 1);
+
+  auto d_ptr = thrust::device_pointer_cast(children);
+  value_idx n_vertices =
+    *(thrust::max_element(exec_policy, d_ptr, d_ptr + root)) + 1;
+
+  // Prevent potential infinite loop from labeling disconnected
+  // connectivities graph.
+  RAFT_EXPECTS(n_vertices == (n_leaves - 1) * 2,
+               "Multiple components found in MST or MST is invalid. "
+               "Cannot find single-linkage solution.");
+
+  rmm::device_uvector<bool> frontier(root + 1, stream);
+
+  thrust::fill(exec_policy, frontier.begin(), frontier.end(), false);
+
+  // Array to propagate the lambda of subtrees actively being collapsed
+  // through multiple bfs iterations.
+  rmm::device_uvector<value_t> ignore(root + 1, stream);
+
+  // Propagate labels from root
+  rmm::device_uvector<value_idx> relabel(root + 1, handle.get_stream());
+  thrust::fill(exec_policy, relabel.begin(), relabel.end(), -1);
+
+  raft::update_device(relabel.data() + root, &root, 1, handle.get_stream());
+
+  // Flip frontier for root
+  constexpr bool start = true;
+  raft::update_device(frontier.data() + root, &start, 1, handle.get_stream());
+
+  rmm::device_uvector<value_idx> out_parent((root + 1) * 2, stream);
+  rmm::device_uvector<value_idx> out_child((root + 1) * 2, stream);
+  rmm::device_uvector<value_t> out_lambda((root + 1) * 2, stream);
+  rmm::device_uvector<value_idx> out_size((root + 1) * 2, stream);
+
+  thrust::fill(exec_policy, out_parent.begin(), out_parent.end(), -1);
+  thrust::fill(exec_policy, out_child.begin(), out_child.end(), -1);
+  thrust::fill(exec_policy, out_lambda.begin(), out_lambda.end(), -1);
+  thrust::fill(exec_policy, out_size.begin(), out_size.end(), -1);
+  thrust::fill(exec_policy, ignore.begin(), ignore.end(), -1);
+
+  // While frontier is not empty, perform single bfs through tree
+  size_t grid = raft::ceildiv(root + 1, (int)tpb);
+
+  value_idx n_elements_to_traverse =
+    thrust::reduce(exec_policy, frontier.data(), frontier.data() + root + 1, 0);
+
+  while (n_elements_to_traverse > 0) {
+    // TODO: Investigate whether it would be worth performing a gather/argmatch in order
+    // to schedule only the number of threads needed. (it might not be worth it)
+    condense_hierarchy_kernel<<<grid, tpb, 0, handle.get_stream()>>>(
+      frontier.data(), ignore.data(), relabel.data(), children, delta, sizes,
+      n_leaves, min_cluster_size, out_parent.data(), out_child.data(),
+      out_lambda.data(), out_size.data());
+
+    n_elements_to_traverse = thrust::reduce(exec_policy, frontier.data(),
+                                            frontier.data() + root + 1, 0);
+
+    CUDA_CHECK(cudaStreamSynchronize(stream));
+  }
+
+  condensed_tree.condense(out_parent.data(), out_child.data(),
+                          out_lambda.data(), out_size.data());
+}
+
+};  // end namespace Condense
+};  // end namespace detail
+};  // end namespace HDBSCAN
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/extract.cuh b/cpp/src/hdbscan/detail/extract.cuh
new file mode 100644
index 0000000000..6838f6f12e
--- /dev/null
+++ b/cpp/src/hdbscan/detail/extract.cuh
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <label/classlabels.cuh>
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include "membership.cuh"
+#include "select.cuh"
+#include "stabilities.cuh"
+#include "utils.h"
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <raft/label/classlabels.cuh>
+
+#include <algorithm>
+
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Extract {
+
+/**
+ * Union-rank data structure with path compression for
+ * labeling data points based on their farthest ancestors
+ * under root.
+ *
+ * For correctness, it is important that all children are
+ * visited before their parents.
+ * @tparam value_idx
+ */
+template <typename value_idx>
+class TreeUnionFind {
+ public:
+  TreeUnionFind(value_idx size_) : size(size_), data(size_ * 2, 0) {
+    for (int i = 0; i < size; i++) {
+      data[i * 2] = i;
+    }
+  }
+
+  void perform_union(value_idx x, value_idx y) {
+    value_idx x_root = find(x);
+    value_idx y_root = find(y);
+
+    if (data[x_root * 2 + 1] < data[y_root * 2 + 1])
+      data[x_root * 2] = y_root;
+    else if (data[x_root * 2 + 1] > data[y_root * 2 + 1])
+      data[y_root * 2] = x_root;
+    else {
+      data[y_root * 2] = x_root;
+      data[x_root * 2 + 1] += 1;
+    }
+  }
+
+  value_idx find(value_idx x) {
+    if (data[x * 2] != x) {
+      data[x * 2] = find(data[x * 2]);
+    }
+
+    return data[x * 2];
+  }
+
+  value_idx *get_data() { return data.data(); }
+
+ private:
+  value_idx size;
+  std::vector<value_idx> data;
+};
+
+template <typename value_idx, typename value_t>
+void do_labelling_on_host(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+  std::set<value_idx> &clusters, value_idx n_leaves, bool allow_single_cluster,
+  value_idx *labels, value_t cluster_selection_epsilon) {
+  auto stream = handle.get_stream();
+
+  std::vector<value_idx> children_h(condensed_tree.get_n_edges());
+  std::vector<value_t> lambda_h(condensed_tree.get_n_edges());
+  std::vector<value_idx> parent_h(condensed_tree.get_n_edges());
+
+  raft::update_host(children_h.data(), condensed_tree.get_children(),
+                    condensed_tree.get_n_edges(), stream);
+  raft::update_host(parent_h.data(), condensed_tree.get_parents(),
+                    condensed_tree.get_n_edges(), stream);
+  raft::update_host(lambda_h.data(), condensed_tree.get_lambdas(),
+                    condensed_tree.get_n_edges(), stream);
+
+  CUDA_CHECK(cudaStreamSynchronize(stream));
+
+  auto parents = thrust::device_pointer_cast(condensed_tree.get_parents());
+  auto thrust_policy = rmm::exec_policy(stream);
+  value_idx size = *thrust::max_element(thrust_policy, parents,
+                                        parents + condensed_tree.get_n_edges());
+
+  std::vector<value_idx> result(n_leaves);
+  std::vector<value_t> parent_lambdas(size + 1, 0);
+
+  auto union_find = TreeUnionFind<value_idx>(size + 1);
+
+  for (int i = 0; i < condensed_tree.get_n_edges(); i++) {
+    value_idx child = children_h[i];
+    value_idx parent = parent_h[i];
+
+    if (clusters.find(child) == clusters.end())
+      union_find.perform_union(parent, child);
+
+    parent_lambdas[parent_h[i]] = max(parent_lambdas[parent_h[i]], lambda_h[i]);
+  }
+
+  value_t inverse_cluster_selection_epsilon;
+  if (cluster_selection_epsilon != 0.0) {
+    inverse_cluster_selection_epsilon = 1 / cluster_selection_epsilon;
+  }
+
+  for (int i = 0; i < n_leaves; i++) {
+    value_idx cluster = union_find.find(i);
+
+    if (cluster < n_leaves)
+      result[i] = -1;
+    else if (cluster == n_leaves) {
+      //TODO: Implement the cluster_selection_epsilon / epsilon_search
+      if (clusters.size() == 1 && allow_single_cluster) {
+        auto it = std::find(children_h.begin(), children_h.end(), i);
+        auto child_idx = std::distance(children_h.begin(), it);
+        value_t child_lambda = lambda_h[child_idx];
+
+        if (cluster_selection_epsilon != 0) {
+          if (child_lambda >= inverse_cluster_selection_epsilon) {
+            result[i] = cluster - n_leaves;
+          } else {
+            result[i] = -1;
+          }
+        } else if (child_lambda >= parent_lambdas[cluster])
+          result[i] = cluster - n_leaves;
+        else
+          result[i] = -1;
+      } else {
+        result[i] = -1;
+      }
+    } else {
+      result[i] = cluster - n_leaves;
+    }
+  }
+
+  raft::update_device(labels, result.data(), n_leaves, stream);
+
+  // TODO: Need to nornalize the labels so they are pulled from a
+  // monotonically increasing set, but need to make sure the first
+  // label starts at 0 in the face of noise.
+  //  CUML_LOG_DEBUG("Calling make_monotonic");
+  //  raft::label::make_monotonic(labels, labels, n_leaves, stream,
+  //                              [] __device__(value_idx label) { return label == -1; },
+  //                              handle.get_device_allocator(), true);
+}
+
+/**
+ * Compute cluster stabilities, perform cluster selection, and
+ * label the resulting clusters. In addition, probabilities
+ * are computed and stabilities are normalized into scores.
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource management
+ * @param[in] condensed_tree a condensed hierarchy
+ * @param[in] n_leaves number of data samples
+ * @param[out] labels array of labels on device (size n_leaves)
+ * @param[out] stabilities array of stabilities on device (size n_clusters)
+ * @param[out] probabilities array of probabilities on device (size n_leaves)
+ * @param[in] cluster_selection_method method to use for cluster selection
+ * @param[in] allow_single_cluster allows a single cluster to be returned (rather than just noise)
+ * @param[in] max_cluster_size maximium number of points that can be considered in a cluster before it is split into multiple sub-clusters.
+ * @param[in] cluster_selection_epsilon a distance threshold. clusters below this value will be merged.
+ */
+template <typename value_idx, typename value_t>
+void extract_clusters(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+  size_t n_leaves, value_idx *labels, value_t *stabilities,
+  value_t *probabilities,
+  Common::CLUSTER_SELECTION_METHOD cluster_selection_method,
+  bool allow_single_cluster = false, value_idx max_cluster_size = 0,
+  value_t cluster_selection_epsilon = 0.0) {
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  rmm::device_uvector<value_t> tree_stabilities(condensed_tree.get_n_clusters(),
+                                                handle.get_stream());
+
+  Stability::compute_stabilities(handle, condensed_tree,
+                                 tree_stabilities.data());
+  rmm::device_uvector<int> is_cluster(condensed_tree.get_n_clusters(),
+                                      handle.get_stream());
+
+  if (max_cluster_size <= 0)
+    max_cluster_size = n_leaves;  // negates the max cluster size
+
+  Select::select_clusters(handle, condensed_tree, tree_stabilities.data(),
+                          is_cluster.data(), cluster_selection_method,
+                          allow_single_cluster, max_cluster_size,
+                          cluster_selection_epsilon);
+
+  std::vector<int> is_cluster_h(is_cluster.size());
+  raft::update_host(is_cluster_h.data(), is_cluster.data(), is_cluster_h.size(),
+                    stream);
+  CUDA_CHECK(cudaStreamSynchronize(stream));
+
+  std::set<value_idx> clusters;
+  for (int i = 0; i < is_cluster_h.size(); i++) {
+    if (is_cluster_h[i] != 0) {
+      clusters.insert(i + n_leaves);
+    }
+  }
+
+  do_labelling_on_host<value_idx, value_t>(handle, condensed_tree, clusters,
+                                           n_leaves, allow_single_cluster,
+                                           labels, cluster_selection_epsilon);
+
+  value_idx n_selected_clusters = clusters.size();
+
+  Membership::get_probabilities<value_idx, value_t>(handle, condensed_tree,
+                                                    labels, probabilities);
+
+  // TODO: Compute stability scores (below)
+
+  //  auto lambdas_ptr = thrust::device_pointer_cast(condensed_tree.get_lambdas());
+  //  value_t max_lambda = *(thrust::max_element(
+  //    exec_policy, lambdas_ptr,
+  //    lambdas_ptr + condensed_tree.get_n_edges()));
+  //
+  //  CUML_LOG_DEBUG("Computing stability scores");
+  //  Stability::get_stability_scores(handle, labels, tree_stabilities.data(),
+  //                                  clusters.size(), max_lambda, n_leaves,
+  //                                  stabilities);
+}
+
+};  // end namespace Extract
+};  // end namespace detail
+};  // end namespace HDBSCAN
+};  // end namespace ML
diff --git a/cpp/src/hdbscan/detail/kernels/condense.cuh b/cpp/src/hdbscan/detail/kernels/condense.cuh
new file mode 100644
index 0000000000..c656bcbd0b
--- /dev/null
+++ b/cpp/src/hdbscan/detail/kernels/condense.cuh
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Condense {
+
+template <typename value_idx, typename value_t>
+__device__ inline value_t get_lambda(value_idx node, value_idx num_points,
+                                     const value_t *deltas) {
+  value_t delta = deltas[node - num_points];
+  return delta > 0.0 ? 1.0 / delta : std::numeric_limits<value_t>::max();
+}
+
+/**
+  * Performs a breath-first search for a single level of the dendrogram, which
+  * is a binary tree, and collapses subtrees based on the min_cluster_size. The
+  * Arrays `relabel` and `ignore` are used to track state throughout subsequent
+  * launches of this kernel. Nodes who's ancestors are "reassigned" inherit
+  * the lambda value of their new parent.
+  *
+  * Note: This implementation differs from the reference implementation and
+  * exposes more parallelism by having any collapsed branches directly
+  * inherit the id of the persisted ancestor, rather than having to maintain
+  * a synchronized monotonically increasing counter. In this version, a
+  * renumbering is done afterwards, in parallel. The assumption here is that
+  * a topological sort order should result from sorting the resulting
+  * condensed dendrogram by (cluster size, id).
+  *
+  *
+  * @tparam value_idx
+  * @tparam value_t
+  * @param frontier determines which nodes should be processed in
+  *                 each iteration.
+  * @param ignore Should be initialized to -1. maintains the lambda
+  *               value of the new parent for each child of a subtree
+  *               in the process of being collapsed. For example,
+  *               ignore[5] = 0.9 means that all children of node w/
+  *               id 5 should be placed in the condensed tree with
+  *               parent relabel[5] and lambda=0.9.
+  *
+  * @param relabel relabel[0] should be initialized to root and
+  *                propagated to subtrees as they are collapsed. This
+  *                array stores the new parent that should be assigned
+  *                for all nodes in a subtree that is in the process
+  *                of being collapsed. For example, relabel[5] = 9
+  *                means that node with id 5 should be assigned parent
+  *                9 when ignore[5] > -1.
+  * @param hierarchy binary tree dendrogram as renumbered by single-linkage
+  *                  agglomerative labeling process.
+  * @param deltas array of distances as constructed by the single-linkage
+  *               agglomerative labeling process.
+  * @param sizes  array of cluster sizes as constructed by the single-linkage
+  *               agglomerative labeling process.
+  * @param n_leaves number of non-cluster data points
+  *
+  * @param min_cluster_size while performing a bfs from the root of the
+  *                         dendrogram, any subtrees below this size will
+  *                         be collapsed into their parent cluster.
+  *
+  * @param out_parent parents array of output dendrogram. this will no longer
+  *                   be a binary tree.
+  * @param out_child children array of output dendrogram. this will no longer
+  *                  be a binary tree.
+  * @param out_lambda lambda array of output dendrogram.
+  * @param out_count children cluster sizes of output dendrogram.
+  */
+template <typename value_idx, typename value_t>
+__global__ void condense_hierarchy_kernel(
+  bool *frontier, value_t *ignore, value_idx *relabel,
+  const value_idx *children, const value_t *deltas, const value_idx *sizes,
+  int n_leaves, int min_cluster_size, value_idx *out_parent,
+  value_idx *out_child, value_t *out_lambda, value_idx *out_count) {
+  int node = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (node >= n_leaves * 2 - 1 || !frontier[node]) return;
+
+  frontier[node] = false;
+
+  value_t subtree_lambda = ignore[node];
+
+  bool should_ignore = subtree_lambda > -1;
+
+  // TODO: Investigate whether this would be better done w/ an additional
+  //  kernel launch
+
+  // If node is a leaf, add it to the condensed hierarchy
+  if (node < n_leaves) {
+    out_parent[node * 2] = relabel[node];
+    out_child[node * 2] = node;
+    out_lambda[node * 2] = subtree_lambda;
+    out_count[node * 2] = 1;
+  }
+
+  // If node is not a leaf, condense its children if necessary
+  else {
+    value_idx left_child = children[(node - n_leaves) * 2];
+    value_idx right_child = children[((node - n_leaves) * 2) + 1];
+
+    // flip frontier for children
+    frontier[left_child] = true;
+    frontier[right_child] = true;
+
+    // propagate ignore down to children
+    ignore[left_child] = should_ignore ? subtree_lambda : -1;
+    ignore[right_child] = should_ignore ? subtree_lambda : -1;
+
+    relabel[left_child] = should_ignore ? relabel[node] : relabel[left_child];
+    relabel[right_child] = should_ignore ? relabel[node] : relabel[right_child];
+
+    value_idx node_relabel = relabel[node];
+
+    // TODO: Should be able to remove this nested conditional
+    if (!should_ignore) {
+      value_t lambda_value = get_lambda(node, n_leaves, deltas);
+
+      int left_count =
+        left_child >= n_leaves ? sizes[left_child - n_leaves] : 1;
+      int right_count =
+        right_child >= n_leaves ? sizes[right_child - n_leaves] : 1;
+
+      // Consume left or right child as necessary
+      bool left_child_too_small = left_count < min_cluster_size;
+      bool right_child_too_small = right_count < min_cluster_size;
+
+      // Node can "persist" to the cluster tree only if
+      // both children >= min_cluster_size
+      bool can_persist = !left_child_too_small && !right_child_too_small;
+
+      relabel[left_child] = !can_persist ? node_relabel : left_child;
+      relabel[right_child] = !can_persist ? node_relabel : right_child;
+
+      // set ignore for children. This is the node at which the "points underneath fall out"
+      ignore[left_child] = left_child_too_small ? lambda_value : -1;
+      ignore[right_child] = right_child_too_small ? lambda_value : -1;
+
+      // If both children are large enough, they should be relabeled and
+      // included directly in the output hierarchy.
+      if (can_persist) {
+        // TODO: Could probably pull this out if this conditional becomes
+        //  a bottleneck
+        out_parent[node * 2] = node_relabel;
+        out_child[node * 2] = left_child;
+        out_lambda[node * 2] = lambda_value;
+        out_count[node * 2] = left_count;
+
+        out_parent[node * 2 + 1] = node_relabel;
+        out_child[node * 2 + 1] = right_child;
+        out_lambda[node * 2 + 1] = lambda_value;
+        out_count[node * 2 + 1] = right_count;
+      }
+    }
+  }
+}
+
+};  // end namespace Condense
+};  // end namespace detail
+};  // end namespace HDBSCAN
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/kernels/membership.cuh b/cpp/src/hdbscan/detail/kernels/membership.cuh
new file mode 100644
index 0000000000..e48b319998
--- /dev/null
+++ b/cpp/src/hdbscan/detail/kernels/membership.cuh
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Membership {
+
+template <typename value_idx, typename value_t>
+struct probabilities_functor {
+ public:
+  probabilities_functor(value_t *probabilities_, const value_t *deaths_,
+                        const value_idx *children_, const value_t *lambdas_,
+                        const value_idx *labels_, const value_idx root_cluster_)
+    : probabilities(probabilities_),
+      deaths(deaths_),
+      children(children_),
+      lambdas(lambdas_),
+      labels(labels_),
+      root_cluster(root_cluster_) {}
+
+  __device__ void operator()(const value_idx &idx) {
+    auto child = children[idx];
+
+    // intermediate nodes
+    if (child >= root_cluster) {
+      return;
+    }
+
+    auto cluster = labels[child];
+
+    // noise
+    if (cluster == -1) {
+      return;
+    }
+
+    auto cluster_death = deaths[cluster];
+    auto child_lambda = lambdas[idx];
+    if (cluster_death == 0.0 || isnan(child_lambda)) {
+      probabilities[child] = 1.0;
+    } else {
+      auto min_lambda = min(child_lambda, cluster_death);
+      probabilities[child] = min_lambda / cluster_death;
+    }
+  }
+
+ private:
+  value_t *probabilities;
+  const value_t *deaths, *lambdas;
+  const value_idx *children, *labels, root_cluster;
+};
+
+};  // namespace Membership
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/kernels/select.cuh b/cpp/src/hdbscan/detail/kernels/select.cuh
new file mode 100644
index 0000000000..53eb1eaa40
--- /dev/null
+++ b/cpp/src/hdbscan/detail/kernels/select.cuh
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Select {
+
+/**
+ * For each non-0 value in frontier, deselects children clusters
+ * and adds children to frontier.
+ * @tparam value_idx
+ * @param[in] indptr CSR indptr of array (size n_clusters+1)
+ * @param[in] children array of children indices (size n_clusters)
+ * @param[inout] frontier frontier array storing which nodes need
+ *               processing in each kernel invocation (size n_clusters)
+ * @param[inout] is_cluster array of cluster selections / deselections (size n_clusters)
+ * @param[in] n_clusters number of clusters
+ */
+template <typename value_idx>
+__global__ void propagate_cluster_negation_kernel(const value_idx *indptr,
+                                                  const value_idx *children,
+                                                  int *frontier,
+                                                  int *is_cluster,
+                                                  int n_clusters) {
+  int cluster = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (cluster < n_clusters && frontier[cluster]) {
+    frontier[cluster] = false;
+
+    value_idx children_start = indptr[cluster];
+    value_idx children_stop = indptr[cluster + 1];
+    for (int i = children_start; i < children_stop; i++) {
+      value_idx child = children[i];
+      frontier[child] = true;
+      is_cluster[child] = false;
+    }
+  }
+}
+
+template <typename value_idx, typename value_t, int tpb = 256>
+__global__ void cluster_epsilon_search_kernel(
+  const int *selected_clusters, const int n_selected_clusters,
+  const value_idx *parents, const value_idx *children, const value_t *lambdas,
+  const value_idx cluster_tree_edges, int *is_cluster, int *frontier,
+  const int n_clusters, const value_t cluster_selection_epsilon,
+  const bool allow_single_cluster) {
+  auto selected_cluster_idx = threadIdx.x + blockDim.x * blockIdx.x;
+
+  if (selected_cluster_idx >= n_selected_clusters) {
+    return;
+  }
+
+  // don't need to process root as a cluster
+  // offsetting for root by subtracting 1 from the cluster
+  // this is because root isn't involved in epsilon search directly
+  // further, it allows the remaining clusters to be 0-index
+  // and directly access from the children/lambda arrays
+  // since parents/lambdas are sorted by children
+  // the relation is: child = child_idx + 1
+  auto child_idx = selected_clusters[selected_cluster_idx] - 1;
+  if (child_idx == -1) {
+    return;
+  }
+
+  auto eps = 1 / lambdas[child_idx];
+
+  if (eps < cluster_selection_epsilon) {
+    constexpr auto root = 0;
+
+    value_idx parent;
+    value_t parent_eps;
+
+    do {
+      parent = parents[child_idx];
+
+      if (parent == root) {
+        if (!allow_single_cluster) {
+          // setting parent to actual value of child
+          // by offsetting
+          parent = child_idx + 1;
+        }
+        break;
+      }
+
+      // again, offsetting for root
+      child_idx = parent - 1;
+      // lambda is picked for where the parent
+      // resides according to where it is a child
+      parent_eps = 1 / lambdas[child_idx];
+    } while (parent_eps <= cluster_selection_epsilon);
+
+    frontier[parent] = true;
+    is_cluster[parent] = true;
+  } else {
+    // offset 1 ahead for root
+    frontier[child_idx + 1] = true;
+  }
+}
+
+};  // namespace Select
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/kernels/stabilities.cuh b/cpp/src/hdbscan/detail/kernels/stabilities.cuh
new file mode 100644
index 0000000000..6ffafadc12
--- /dev/null
+++ b/cpp/src/hdbscan/detail/kernels/stabilities.cuh
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Stability {
+
+/**
+ * Uses cluster distances, births, and sizes to compute stabilities
+ * which are used for cluster selection.
+ * @tparam value_idx
+ * @tparam value_t
+ */
+template <typename value_idx, typename value_t>
+struct stabilities_functor {
+ public:
+  stabilities_functor(value_t *stabilities_, const value_t *births_,
+                      const value_idx *parents_, const value_t *lambdas_,
+                      const value_idx *sizes_, const value_idx n_leaves_)
+    : stabilities(stabilities_),
+      births(births_),
+      parents(parents_),
+      lambdas(lambdas_),
+      sizes(sizes_),
+      n_leaves(n_leaves_) {}
+
+  __device__ void operator()(const int &idx) {
+    auto parent = parents[idx] - n_leaves;
+
+    atomicAdd(&stabilities[parent],
+              (lambdas[idx] - births[parent]) * sizes[idx]);
+  }
+
+ private:
+  value_t *stabilities;
+  const value_t *births, *lambdas;
+  const value_idx *parents, *sizes, n_leaves;
+};
+
+};  // namespace Stability
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/membership.cuh b/cpp/src/hdbscan/detail/membership.cuh
new file mode 100644
index 0000000000..3f6a090948
--- /dev/null
+++ b/cpp/src/hdbscan/detail/membership.cuh
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "kernels/membership.cuh"
+#include "utils.h"
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <raft/label/classlabels.cuh>
+
+#include <algorithm>
+
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Membership {
+
+// TODO: Compute outlier scores
+
+template <typename value_idx, typename value_t>
+void get_probabilities(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+  const value_idx *labels, value_t *probabilities) {
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  auto parents = condensed_tree.get_parents();
+  auto children = condensed_tree.get_children();
+  auto lambdas = condensed_tree.get_lambdas();
+  auto n_edges = condensed_tree.get_n_edges();
+  auto n_clusters = condensed_tree.get_n_clusters();
+  auto n_leaves = condensed_tree.get_n_leaves();
+
+  rmm::device_uvector<value_idx> sorted_parents(n_edges, stream);
+  raft::copy_async(sorted_parents.data(), parents, n_edges, stream);
+
+  rmm::device_uvector<value_idx> sorted_parents_offsets(n_clusters + 1, stream);
+  Utils::parent_csr(handle, condensed_tree, sorted_parents.data(),
+                    sorted_parents_offsets.data());
+
+  // this is to find maximum lambdas of all children under a parent
+  rmm::device_uvector<value_t> deaths(n_clusters, stream);
+  thrust::fill(exec_policy, deaths.begin(), deaths.end(), 0.0f);
+
+  Utils::cub_segmented_reduce(
+    lambdas, deaths.data(), n_clusters, sorted_parents_offsets.data(), stream,
+    cub::DeviceSegmentedReduce::Max<const value_t *, value_t *,
+                                    const value_idx *>);
+
+  // Calculate probability per point
+  thrust::fill(exec_policy, probabilities, probabilities + n_leaves, 0.0f);
+
+  probabilities_functor<value_idx, value_t> probabilities_op(
+    probabilities, deaths.data(), children, lambdas, labels, n_leaves);
+  thrust::for_each(exec_policy, thrust::make_counting_iterator(value_idx(0)),
+                   thrust::make_counting_iterator(n_edges), probabilities_op);
+}
+
+};  // namespace Membership
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/reachability.cuh b/cpp/src/hdbscan/detail/reachability.cuh
new file mode 100644
index 0000000000..6784796ee9
--- /dev/null
+++ b/cpp/src/hdbscan/detail/reachability.cuh
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "reachability_faiss.cuh"
+
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
+
+#include <raft/mr/device/buffer.hpp>
+
+#include <raft/linalg/unary_op.cuh>
+
+#include <raft/sparse/convert/csr.cuh>
+#include <raft/sparse/hierarchy/detail/connectivities.cuh>
+#include <raft/sparse/linalg/symmetrize.cuh>
+#include <raft/sparse/selection/knn_graph.cuh>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <cuml/neighbors/knn.hpp>
+#include <raft/distance/distance.cuh>
+
+#include <thrust/transform.h>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Reachability {
+
+/**
+ * Extract core distances from KNN graph. This is essentially
+ * performing a knn_dists[:,min_pts]
+ * @tparam value_idx data type for integrals
+ * @tparam value_t data type for distance
+ * @tparam tpb block size for kernel
+ * @param[in] knn_dists knn distance array (size n * k)
+ * @param[in] k neighborhood size
+ * @param[in] min_samples this neighbor will be selected for core distances
+ * @param[in] n number of samples
+ * @param[out] out output array (size n)
+ * @param[in] stream stream for which to order cuda operations
+ */
+template <typename value_idx, typename value_t, int tpb = 256>
+void core_distances(value_t *knn_dists, int k, int min_samples, size_t n,
+                    value_t *out, cudaStream_t stream) {
+  int blocks = raft::ceildiv(n, (size_t)tpb);
+
+  auto exec_policy = rmm::exec_policy(stream);
+
+  auto indices = thrust::make_counting_iterator<value_idx>(0);
+
+  thrust::transform(exec_policy, indices, indices + n, out,
+                    [=] __device__(value_idx row) {
+                      return knn_dists[row * k + (min_samples - 1)];
+                    });
+}
+
+/**
+ * Constructs a mutual reachability graph, which is a k-nearest neighbors
+ * graph projected into mutual reachability space using the following
+ * function for each data point, where core_distance is the distance
+ * to the kth neighbor: max(core_distance(a), core_distance(b), d(a, b))
+ *
+ * Unfortunately, points in the tails of the pdf (e.g. in sparse regions
+ * of the space) can have very large neighborhoods, which will impact
+ * nearby neighborhoods. Because of this, it's possible that the
+ * radius for points in the main mass, which might have a very small
+ * radius initially, to expand very large. As a result, the initial
+ * knn which was used to compute the core distances may no longer
+ * capture the actual neighborhoods after projection into mutual
+ * reachability space.
+ *
+ * For the experimental version, we execute the knn twice- once
+ * to compute the radii (core distances) and again to capture
+ * the final neighborhoods. Future iterations of this algorithm
+ * will work improve upon this "exact" version, by using
+ * more specialized data structures, such as space-partitioning
+ * structures. It has also been shown that approximate nearest
+ * neighbors can yield reasonable neighborhoods as the
+ * data sizes increase.
+ *
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] X input data points (size m * n)
+ * @param[in] m number of rows in X
+ * @param[in] n number of columns in X
+ * @param[in] metric distance metric to use
+ * @param[in] k neighborhood size
+ * @param[in] min_samples this neighborhood will be selected for core distances
+ * @param[in] alpha weight applied when internal distance is chosen for
+ *            mutual reachability (value of 1.0 disables the weighting)
+ * @param[out] indptr CSR indptr of output knn graph (size m + 1)
+ * @param[out] core_dists output core distances array (size m)
+ * @param[out] out COO object, uninitialized on entry, on exit it stores the
+ *             (symmetrized) maximum reachability distance for the k nearest
+ *             neighbors.
+ */
+template <typename value_idx, typename value_t>
+void mutual_reachability_graph(const raft::handle_t &handle, const value_t *X,
+                               size_t m, size_t n,
+                               raft::distance::DistanceType metric, int k,
+                               int min_samples, value_t alpha,
+                               value_idx *indptr, value_t *core_dists,
+                               raft::sparse::COO<value_t, value_idx> &out) {
+  RAFT_EXPECTS(metric == raft::distance::DistanceType::L2SqrtExpanded,
+               "Currently only L2 expanded distance is supported");
+
+  auto stream = handle.get_stream();
+
+  auto exec_policy = rmm::exec_policy(stream);
+
+  std::vector<value_t *> inputs;
+  inputs.push_back(const_cast<value_t *>(X));
+
+  std::vector<int> sizes;
+  sizes.push_back(m);
+
+  // This is temporary. Once faiss is updated, we should be able to
+  // pass value_idx through to knn.
+  rmm::device_uvector<value_idx> coo_rows(k * m, stream);
+  rmm::device_uvector<int64_t> int64_indices(k * m, stream);
+  rmm::device_uvector<value_idx> inds(k * m, stream);
+  rmm::device_uvector<value_t> dists(k * m, stream);
+
+  // perform knn
+  brute_force_knn(handle, inputs, sizes, n, const_cast<value_t *>(X), m,
+                  int64_indices.data(), dists.data(), k, true, true, metric);
+
+  // convert from current knn's 64-bit to 32-bit.
+  thrust::transform(exec_policy, int64_indices.data(),
+                    int64_indices.data() + int64_indices.size(), inds.data(),
+                    [] __device__(int64_t in) -> value_idx { return in; });
+
+  // Slice core distances (distances to kth nearest neighbor)
+  core_distances<value_idx>(dists.data(), k, min_samples, m, core_dists,
+                            stream);
+
+  /**
+   * Compute L2 norm
+   */
+  mutual_reachability_knn_l2(handle, inds.data(), dists.data(), X, m, n, k,
+                             core_dists, (value_t)1.0 / alpha);
+
+  // self-loops get max distance
+  auto coo_rows_counting_itr = thrust::make_counting_iterator<value_idx>(0);
+  thrust::transform(exec_policy, coo_rows_counting_itr,
+                    coo_rows_counting_itr + (m * k), coo_rows.data(),
+                    [k] __device__(value_idx c) -> value_idx { return c / k; });
+
+  raft::sparse::linalg::symmetrize(handle, coo_rows.data(), inds.data(),
+                                   dists.data(), m, m, k * m, out);
+
+  raft::sparse::convert::sorted_coo_to_csr(
+    out.rows(), out.nnz, indptr, m + 1, handle.get_device_allocator(), stream);
+
+  // self-loops get max distance
+  auto transform_in = thrust::make_zip_iterator(
+    thrust::make_tuple(out.rows(), out.cols(), out.vals()));
+
+  thrust::transform(
+    exec_policy, transform_in, transform_in + out.nnz, out.vals(),
+    [=] __device__(const thrust::tuple<value_idx, value_idx, value_t> &tup) {
+      return thrust::get<0>(tup) == thrust::get<1>(tup)
+               ? std::numeric_limits<value_t>::max()
+               : thrust::get<2>(tup);
+    });
+}
+
+};  // end namespace Reachability
+};  // end namespace detail
+};  // end namespace HDBSCAN
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/reachability_faiss.cuh b/cpp/src/hdbscan/detail/reachability_faiss.cuh
new file mode 100644
index 0000000000..cc1b5672ff
--- /dev/null
+++ b/cpp/src/hdbscan/detail/reachability_faiss.cuh
@@ -0,0 +1,369 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file thirdparty/faiss.license.
+ */
+
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <faiss/gpu/GpuResources.h>
+#include <faiss/gpu/StandardGpuResources.h>
+
+#include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/FaissException.h>
+
+#include <faiss/gpu/impl/Distance.cuh>
+#include <faiss/gpu/impl/DistanceUtils.cuh>
+#include <faiss/gpu/impl/L2Norm.cuh>
+#include <faiss/gpu/impl/L2Select.cuh>
+
+#include <faiss/gpu/utils/CopyUtils.cuh>
+#include <faiss/gpu/utils/DeviceDefs.cuh>
+#include <faiss/gpu/utils/Limits.cuh>
+#include <faiss/gpu/utils/MatrixMult.cuh>
+
+#include <rmm/device_uvector.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Reachability {
+
+template <typename value_t, int NumWarpQ, int NumThreadQ, int ThreadsPerBlock>
+__global__ void l2SelectMinK(
+  faiss::gpu::Tensor<value_t, 2, true> inner_products,
+  faiss::gpu::Tensor<value_t, 1, true> sq_norms,
+  faiss::gpu::Tensor<value_t, 1, true> core_dists,
+  faiss::gpu::Tensor<value_t, 2, true> out_dists,
+  faiss::gpu::Tensor<int, 2, true> out_inds, int batch_offset, int k,
+  value_t initK, value_t alpha) {
+  // Each block handles a single row of the distances (results)
+  constexpr int kNumWarps = ThreadsPerBlock / 32;
+
+  __shared__ value_t smemK[kNumWarps * NumWarpQ];
+  __shared__ int smemV[kNumWarps * NumWarpQ];
+
+  faiss::gpu::BlockSelect<value_t, int, false, faiss::gpu::Comparator<value_t>,
+                          NumWarpQ, NumThreadQ, ThreadsPerBlock>
+    heap(initK, -1, smemK, smemV, k);
+
+  int row = blockIdx.x;
+
+  // Whole warps must participate in the selection
+  int limit = faiss::gpu::utils::roundDown(inner_products.getSize(1), 32);
+  int i = threadIdx.x;
+
+  for (; i < limit; i += blockDim.x) {
+    value_t v = sqrt(faiss::gpu::Math<value_t>::add(
+      sq_norms[row + batch_offset],
+      faiss::gpu::Math<value_t>::add(sq_norms[i], inner_products[row][i])));
+
+    v = max(core_dists[i], max(core_dists[row + batch_offset], alpha * v));
+    heap.add(v, i);
+  }
+
+  if (i < inner_products.getSize(1)) {
+    value_t v = sqrt(faiss::gpu::Math<value_t>::add(
+      sq_norms[row + batch_offset],
+      faiss::gpu::Math<value_t>::add(sq_norms[i], inner_products[row][i])));
+
+    v = max(core_dists[i], max(core_dists[row + batch_offset], alpha * v));
+    heap.addThreadQ(v, i);
+  }
+
+  heap.reduce();
+  for (int i = threadIdx.x; i < k; i += blockDim.x) {
+    out_dists[row][i] = smemK[i];
+    out_inds[row][i] = smemV[i];
+  }
+}
+
+/**
+ * Computes expanded L2 metric, projects points into reachability
+ * space, and performs a k-select.
+ * @tparam value_t
+ * @param[in] productDistances Tensor (or blocked view) of inner products
+ * @param[in] centroidDistances Tensor of l2 norms
+ * @param[in] coreDistances Tensor of core distances
+ * @param[out] outDistances Tensor of output distances
+ * @param[out] outIndices Tensor of output indices
+ * @param[in] batch_offset starting row (used when productDistances is a batch)
+ * @param[in] k number of neighbors to select
+ * @param[in] stream cuda stream for ordering gpu computations
+ */
+template <typename value_t>
+void runL2SelectMin(faiss::gpu::Tensor<value_t, 2, true> &productDistances,
+                    faiss::gpu::Tensor<value_t, 1, true> &centroidDistances,
+                    faiss::gpu::Tensor<value_t, 1, true> &coreDistances,
+                    faiss::gpu::Tensor<value_t, 2, true> &outDistances,
+                    faiss::gpu::Tensor<int, 2, true> &outIndices,
+                    int batch_offset, int k, value_t alpha,
+                    cudaStream_t stream) {
+  FAISS_ASSERT(productDistances.getSize(0) == outDistances.getSize(0));
+  FAISS_ASSERT(productDistances.getSize(0) == outIndices.getSize(0));
+  //  FAISS_ASSERT(centroidDistances.getSize(0) == productDistances.getSize(1));
+  FAISS_ASSERT(outDistances.getSize(1) == k);
+  FAISS_ASSERT(outIndices.getSize(1) == k);
+  FAISS_ASSERT(k <= GPU_MAX_SELECTION_K);
+
+  auto grid = dim3(outDistances.getSize(0));
+
+#define RUN_L2_SELECT(BLOCK, NUM_WARP_Q, NUM_THREAD_Q)                      \
+  do {                                                                      \
+    l2SelectMinK<value_t, NUM_WARP_Q, NUM_THREAD_Q, BLOCK>                  \
+      <<<grid, BLOCK, 0, stream>>>(                                         \
+        productDistances, centroidDistances, coreDistances, outDistances,   \
+        outIndices, batch_offset, k, faiss::gpu::Limits<value_t>::getMax(), \
+        alpha);                                                             \
+  } while (0)
+
+  // block size 128 for everything <= 1024
+  if (k <= 32) {
+    RUN_L2_SELECT(128, 32, 2);
+  } else if (k <= 64) {
+    RUN_L2_SELECT(128, 64, 3);
+  } else if (k <= 128) {
+    RUN_L2_SELECT(128, 128, 3);
+  } else if (k <= 256) {
+    RUN_L2_SELECT(128, 256, 4);
+  } else if (k <= 512) {
+    RUN_L2_SELECT(128, 512, 8);
+  } else if (k <= 1024) {
+    RUN_L2_SELECT(128, 1024, 8);
+
+#if GPU_MAX_SELECTION_K >= 2048
+  } else if (k <= 2048) {
+    // smaller block for less shared memory
+    RUN_L2_SELECT(64, 2048, 8);
+#endif
+
+  } else {
+    FAISS_ASSERT(false);
+  }
+}
+
+/**
+ * Given core distances, Fuses computations of L2 distances between all
+ * points, projection into mutual reachability space, and k-selection.
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[out] out_inds  output indices array (size m * k)
+ * @param[out] out_dists output distances array (size m * k)
+ * @param[in] X input data points (size m * n)
+ * @param[in] m number of rows in X
+ * @param[in] n number of columns in X
+ * @param[in] k neighborhood size (includes self-loop)
+ * @param[in] core_dists array of core distances (size m)
+ */
+template <typename value_idx, typename value_t>
+void mutual_reachability_knn_l2(const raft::handle_t &handle,
+                                value_idx *out_inds, value_t *out_dists,
+                                const value_t *X, size_t m, size_t n, int k,
+                                value_t *core_dists, value_t alpha) {
+  auto device = faiss::gpu::getCurrentDevice();
+  auto stream = handle.get_stream();
+
+  faiss::gpu::DeviceScope ds(device);
+  faiss::gpu::StandardGpuResources res;
+
+  res.noTempMemory();
+  res.setDefaultStream(device, stream);
+
+  auto resImpl = res.getResources();
+  auto gpu_res = resImpl.get();
+
+  gpu_res->initializeForDevice(device);
+  gpu_res->setDefaultStream(device, stream);
+
+  device = faiss::gpu::getCurrentDevice();
+
+  auto tmp_mem_cur_device = gpu_res->getTempMemoryAvailableCurrentDevice();
+
+  /**
+   * Compute L2 norm
+   */
+  rmm::device_uvector<value_t> norms(m, stream);
+
+  auto core_dists_tensor = faiss::gpu::toDeviceTemporary<value_t, 1>(
+    gpu_res, device,
+    const_cast<value_t *>(reinterpret_cast<const value_t *>(core_dists)),
+    stream, {(int)m});
+
+  auto x_tensor = faiss::gpu::toDeviceTemporary<value_t, 2>(
+    gpu_res, device,
+    const_cast<value_t *>(reinterpret_cast<const value_t *>(X)), stream,
+    {(int)m, (int)n});
+
+  auto out_dists_tensor = faiss::gpu::toDeviceTemporary<value_t, 2>(
+    gpu_res, device,
+    const_cast<value_t *>(reinterpret_cast<const value_t *>(out_dists)), stream,
+    {(int)m, k});
+
+  auto out_inds_tensor = faiss::gpu::toDeviceTemporary<value_idx, 2>(
+    gpu_res, device,
+    const_cast<value_idx *>(reinterpret_cast<const value_idx *>(out_inds)),
+    stream, {(int)m, k});
+
+  auto norms_tensor = faiss::gpu::toDeviceTemporary<value_t, 1>(
+    gpu_res, device,
+    const_cast<value_t *>(reinterpret_cast<const value_t *>(norms.data())),
+    stream, {(int)m});
+
+  runL2Norm(x_tensor, true, norms_tensor, true, stream);
+
+  /**
+   * Tile over PW dists, accumulating k-select
+   */
+
+  int tileRows = 0;
+  int tileCols = 0;
+  faiss::gpu::chooseTileSize(m, m, n, sizeof(value_t), tmp_mem_cur_device,
+                             tileRows, tileCols);
+
+  int numColTiles = raft::ceildiv(m, (size_t)tileCols);
+
+  faiss::gpu::DeviceTensor<value_t, 2, true> distanceBuf1(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, tileCols});
+  faiss::gpu::DeviceTensor<value_t, 2, true> distanceBuf2(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, tileCols});
+
+  faiss::gpu::DeviceTensor<value_t, 2, true> *distanceBufs[2] = {&distanceBuf1,
+                                                                 &distanceBuf2};
+
+  faiss::gpu::DeviceTensor<value_t, 2, true> outDistanceBuf1(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, numColTiles * k});
+  faiss::gpu::DeviceTensor<value_t, 2, true> outDistanceBuf2(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, numColTiles * k});
+  faiss::gpu::DeviceTensor<value_t, 2, true> *outDistanceBufs[2] = {
+    &outDistanceBuf1, &outDistanceBuf2};
+
+  faiss::gpu::DeviceTensor<value_idx, 2, true> outIndexBuf1(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, numColTiles * k});
+  faiss::gpu::DeviceTensor<value_idx, 2, true> outIndexBuf2(
+    gpu_res, faiss::gpu::makeTempAlloc(faiss::gpu::AllocType::Other, stream),
+    {tileRows, numColTiles * k});
+  faiss::gpu::DeviceTensor<value_idx, 2, true> *outIndexBufs[2] = {
+    &outIndexBuf1, &outIndexBuf2};
+
+  auto streams = gpu_res->getAlternateStreamsCurrentDevice();
+  faiss::gpu::streamWait(streams, {stream});
+
+  int curStream = 0;
+  bool interrupt = false;
+
+  // Tile over the input queries
+  for (int i = 0; i < m; i += tileRows) {
+    if (interrupt || faiss::InterruptCallback::is_interrupted()) {
+      interrupt = true;
+      break;
+    }
+
+    int curQuerySize = std::min((size_t)tileRows, m - i);
+
+    auto outDistanceView = out_dists_tensor.narrow(0, i, curQuerySize);
+    auto outIndexView = out_inds_tensor.narrow(0, i, curQuerySize);
+
+    auto queryView = x_tensor.narrow(0, i, curQuerySize);
+    auto queryNormNiew = norms_tensor.narrow(0, i, curQuerySize);
+
+    auto outDistanceBufRowView =
+      outDistanceBufs[curStream]->narrow(0, 0, curQuerySize);
+    auto outIndexBufRowView =
+      outIndexBufs[curStream]->narrow(0, 0, curQuerySize);
+
+    // Tile over the centroids
+    for (int j = 0; j < m; j += tileCols) {
+      if (faiss::InterruptCallback::is_interrupted()) {
+        interrupt = true;
+        break;
+      }
+
+      int curCentroidSize = std::min((size_t)tileCols, m - j);
+      int curColTile = j / tileCols;
+
+      auto centroidsView = sliceCentroids(x_tensor, true, j, curCentroidSize);
+
+      auto distanceBufView = distanceBufs[curStream]
+                               ->narrow(0, 0, curQuerySize)
+                               .narrow(1, 0, curCentroidSize);
+
+      auto outDistanceBufColView =
+        outDistanceBufRowView.narrow(1, k * curColTile, k);
+      auto outIndexBufColView = outIndexBufRowView.narrow(1, k * curColTile, k);
+
+      runMatrixMult(distanceBufView,
+                    false,  // not transposed
+                    queryView,
+                    false,  // transposed MM if col major
+                    centroidsView,
+                    true,  // transposed MM if row major
+                    -2.0f, 0.0f, gpu_res->getBlasHandleCurrentDevice(),
+                    streams[curStream]);
+
+      if (tileCols == m) {
+        // Write into the final output
+        runL2SelectMin<value_t>(distanceBufView, norms_tensor,
+                                core_dists_tensor, outDistanceView,
+                                outIndexView, i, k, alpha, streams[curStream]);
+      } else {
+        auto centroidNormsView = norms_tensor.narrow(0, j, curCentroidSize);
+
+        // Write into our intermediate output
+        runL2SelectMin<value_t>(distanceBufView, norms_tensor,
+                                core_dists_tensor, outDistanceBufColView,
+                                outIndexBufColView, i, k, alpha,
+                                streams[curStream]);
+      }
+    }
+
+    // As we're finished with processing a full set of centroids, perform
+    // the final k-selection
+    if (tileCols != m) {
+      // The indices are tile-relative; for each tile of k, we need to add
+      // tileCols to the index
+      faiss::gpu::runIncrementIndex(outIndexBufRowView, k, tileCols,
+                                    streams[curStream]);
+
+      faiss::gpu::runBlockSelectPair(outDistanceBufRowView, outIndexBufRowView,
+                                     outDistanceView, outIndexView, false, k,
+                                     streams[curStream]);
+    }
+
+    curStream = (curStream + 1) % 2;
+  }
+
+  // Have the desired ordering stream wait on the multi-stream
+  faiss::gpu::streamWait({stream}, streams);
+
+  if (interrupt) {
+    FAISS_THROW_MSG("interrupted");
+  }
+}
+
+};  // end namespace Reachability
+};  // end namespace detail
+};  // end namespace HDBSCAN
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/select.cuh b/cpp/src/hdbscan/detail/select.cuh
new file mode 100644
index 0000000000..538cb38fa4
--- /dev/null
+++ b/cpp/src/hdbscan/detail/select.cuh
@@ -0,0 +1,417 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "kernels/select.cuh"
+#include "utils.h"
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <raft/label/classlabels.cuh>
+
+#include <algorithm>
+
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Select {
+
+/**
+ * Given a frontier, iteratively performs a breadth-first search,
+ * launching the given kernel at each level.
+ * @tparam value_idx
+ * @tparam Bfs_Kernel
+ * @tparam tpb
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] indptr CSR indptr of children array (size n_clusters+1)
+ * @param[in] children children hierarchy array (size n_clusters)
+ * @param[inout] frontier array storing which nodes need to be processed
+ *               in each kernel invocation (size n_clusters)
+ * @param[inout] is_cluster array of cluster selection / deselections (size n_clusters)
+ * @param[in] n_clusters number of clusters
+ * @param[in] bfs_kernel kernel accepting indptr, children, frontier, is_cluster, and n_clusters
+ */
+template <typename value_idx, typename Bfs_Kernel, int tpb = 256>
+void perform_bfs(const raft::handle_t &handle, const value_idx *indptr,
+                 const value_idx *children, int *frontier, int *is_cluster,
+                 int n_clusters, Bfs_Kernel bfs_kernel) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(stream);
+
+  value_idx n_elements_to_traverse =
+    thrust::reduce(thrust_policy, frontier, frontier + n_clusters, 0);
+
+  // TODO: Investigate whether it's worth gathering the sparse frontier into
+  // a dense form for purposes of uniform workload/thread scheduling
+
+  // While frontier is not empty, perform single bfs through tree
+  size_t grid = raft::ceildiv(n_clusters, tpb);
+
+  while (n_elements_to_traverse > 0) {
+    bfs_kernel<<<grid, tpb, 0, stream>>>(indptr, children, frontier, is_cluster,
+                                         n_clusters);
+
+    n_elements_to_traverse =
+      thrust::reduce(thrust_policy, frontier, frontier + n_clusters, 0);
+  }
+}
+
+/**
+ * Computes a CSR index of parents of cluster tree. CSR index is
+ * created by sorting parents by (children, sizes)
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[inout] cluster_tree cluster tree (condensed hierarchy with all nodes of size > 1)
+ * @param[in] n_clusters number of clusters
+ * @param[out] indptr CSR indptr of parents array after sort
+ */
+template <typename value_idx, typename value_t>
+void parent_csr(const raft::handle_t &handle,
+                Common::CondensedHierarchy<value_idx, value_t> &cluster_tree,
+                value_idx *indptr) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(stream);
+
+  auto parents = cluster_tree.get_parents();
+  auto children = cluster_tree.get_children();
+  auto sizes = cluster_tree.get_sizes();
+  auto cluster_tree_edges = cluster_tree.get_n_edges();
+  auto n_clusters = cluster_tree.get_n_clusters();
+
+  if (cluster_tree_edges > 0) {
+    raft::sparse::op::coo_sort(0, 0, cluster_tree_edges, parents, children,
+                               sizes, handle.get_device_allocator(), stream);
+
+    raft::sparse::convert::sorted_coo_to_csr(
+      parents, cluster_tree_edges, indptr, n_clusters + 1,
+      handle.get_device_allocator(), stream);
+  } else {
+    thrust::fill(thrust_policy, indptr, indptr + n_clusters + 1, 0);
+  }
+}
+
+/**
+ * Computes the excess of mass. This is a cluster selection
+ * strategy that iterates upwards from the leaves of the cluster
+ * tree toward the root, selecting clusters based on stabilities and size.
+ * @tparam value_idx
+ * @tparam value_t
+ * @tparam tpb
+ * @param[in] handle raft handle for resource reuse
+ * @param[inout] cluster_tree condensed hierarchy containing only nodes of size > 1
+ * @param[in] stability an array of nodes from the cluster tree and their
+ *            corresponding stabilities
+ * @param[out] is_cluster array of cluster selections / deselections (size n_clusters)
+ * @param[in] n_clusters number of clusters in cluster tree
+ * @param[in] max_cluster_size max number of points in a cluster before
+ *            it will be deselected (and children selected)
+ */
+template <typename value_idx, typename value_t, int tpb = 256>
+void excess_of_mass(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &cluster_tree,
+  value_t *stability, int *is_cluster, int n_clusters,
+  value_idx max_cluster_size, bool allow_single_cluster) {
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  auto cluster_tree_edges = cluster_tree.get_n_edges();
+  auto parents = cluster_tree.get_parents();
+  auto children = cluster_tree.get_children();
+  auto lambdas = cluster_tree.get_lambdas();
+  auto sizes = cluster_tree.get_sizes();
+
+  rmm::device_uvector<value_idx> cluster_sizes(n_clusters, stream);
+
+  thrust::fill(exec_policy, cluster_sizes.data(),
+               cluster_sizes.data() + cluster_sizes.size(), 0);
+
+  value_idx *cluster_sizes_ptr = cluster_sizes.data();
+
+  auto out =
+    thrust::make_zip_iterator(thrust::make_tuple(parents, children, sizes));
+  thrust::for_each(
+    exec_policy, out, out + cluster_tree_edges,
+    [=] __device__(const thrust::tuple<value_idx, value_idx, value_idx> &tup) {
+      // if parent is root (0), add to cluster_sizes_ptr
+      if (thrust::get<0>(tup) == 0) cluster_sizes_ptr[0] += thrust::get<2>(tup);
+
+      cluster_sizes_ptr[thrust::get<1>(tup)] = thrust::get<2>(tup);
+    });
+
+  /**
+   * 2. Iterate through each level from leaves back to root. Use the cluster
+   *    tree CSR and warp-level reduction to sum stabilities and test whether
+   *    or not current cluster should continue to be its own
+   */
+  std::vector<int> is_cluster_h(n_clusters, true);
+  // setting the selection of root
+  is_cluster_h[0] = allow_single_cluster;
+  std::vector<int> frontier_h(n_clusters, false);
+  std::vector<value_idx> cluster_sizes_h(n_clusters);
+
+  rmm::device_uvector<value_idx> indptr(n_clusters + 1, stream);
+  parent_csr(handle, cluster_tree, indptr.data());
+
+  raft::update_host(cluster_sizes_h.data(), cluster_sizes.data(),
+                    cluster_sizes.size(), stream);
+
+  std::vector<value_idx> indptr_h(indptr.size(), 0);
+  if (cluster_tree_edges > 0)
+    raft::update_host(indptr_h.data(), indptr.data(), indptr.size(), stream);
+  CUDA_CHECK(cudaStreamSynchronize(stream));
+
+  // Loop through stabilities in "reverse topological order" (e.g. reverse sorted order)
+  value_idx tree_top = allow_single_cluster ? 0 : 1;
+  for (value_idx node = n_clusters - 1; node >= tree_top; node--) {
+    value_t node_stability = 0.0;
+
+    raft::update_host(&node_stability, stability + node, 1, stream);
+
+    value_t subtree_stability = 0.0;
+
+    if (indptr_h[node + 1] - indptr_h[node] > 0) {
+      subtree_stability = thrust::transform_reduce(
+        exec_policy, children + indptr_h[node], children + indptr_h[node + 1],
+        [=] __device__(value_idx a) { return stability[a]; }, 0.0,
+        thrust::plus<value_t>());
+    }
+
+    if (subtree_stability > node_stability ||
+        cluster_sizes_h[node] > max_cluster_size) {
+      // Deselect / merge cluster with children
+      raft::update_device(stability + node, &subtree_stability, 1, stream);
+      is_cluster_h[node] = false;
+    } else {
+      // Mark children to be deselected
+      frontier_h[node] = true;
+    }
+  }
+
+  /**
+   * 3. Perform BFS through is_cluster, propagating cluster
+   * "deselection" through subtrees
+   */
+  rmm::device_uvector<int> cluster_propagate(n_clusters, stream);
+  rmm::device_uvector<int> frontier(n_clusters, stream);
+
+  raft::update_device(is_cluster, is_cluster_h.data(), n_clusters, stream);
+  raft::update_device(frontier.data(), frontier_h.data(), n_clusters, stream);
+
+  perform_bfs(handle, indptr.data(), children, frontier.data(), is_cluster,
+              n_clusters, propagate_cluster_negation_kernel<value_idx>);
+}
+
+/**
+ * Uses the leaves of the cluster tree as final cluster selections
+ * @tparam value_idx
+ * @tparam value_t
+ * @tparam tpb
+ * @param[in] handle raft handle for resource reuse
+ * @param[inout] cluster_tree condensed hierarchy containing only nodes of size > 1
+ * @param[out] is_cluster array of cluster selections / deselections (size n_clusters)
+ * @param[in] n_clusters number of clusters in cluster tree
+ */
+template <typename value_idx, typename value_t, int tpb = 256>
+void leaf(const raft::handle_t &handle,
+          Common::CondensedHierarchy<value_idx, value_t> &cluster_tree,
+          int *is_cluster, int n_clusters) {
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  auto parents = cluster_tree.get_parents();
+  auto children = cluster_tree.get_children();
+  auto n_edges = cluster_tree.get_n_edges();
+
+  rmm::device_uvector<int> is_parent(n_clusters, stream);
+  thrust::fill(exec_policy, is_parent.begin(), is_parent.end(), false);
+  auto is_parent_op = [is_parent = is_parent.data()] __device__(auto &p) {
+    is_parent[p] = true;
+  };
+  thrust::for_each(exec_policy, parents, parents + n_edges, is_parent_op);
+
+  auto is_cluster_op = [is_parent = is_parent.data(),
+                        is_cluster = is_cluster] __device__(auto &c) {
+    if (!is_parent[c]) {
+      is_cluster[c] = true;
+    }
+  };
+  thrust::for_each(exec_policy, children, children + n_edges, is_cluster_op);
+}
+
+/**
+ * Selects clusters based on distance threshold.
+ * @tparam value_idx
+ * @tparam value_t
+ * @tparam tpb
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] cluster_tree condensed hierarchy with nodes of size > 1
+ * @param[out] is_cluster array of cluster selections / deselections (size n_clusters)
+ * @param[in] n_clusters number of clusters in cluster tree
+ * @param[in] cluster_selection_epsilon distance threshold
+ * @param[in] allow_single_cluster allows a single cluster with noisy datasets
+ * @param[in] n_selected_clusters numnber of cluster selections in is_cluster
+ */
+template <typename value_idx, typename value_t, int tpb = 256>
+void cluster_epsilon_search(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &cluster_tree, int *is_cluster,
+  const int n_clusters, const value_t cluster_selection_epsilon,
+  const bool allow_single_cluster, const int n_selected_clusters) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(stream);
+  auto parents = cluster_tree.get_parents();
+  auto children = cluster_tree.get_children();
+  auto lambdas = cluster_tree.get_lambdas();
+  auto cluster_tree_edges = cluster_tree.get_n_edges();
+
+  rmm::device_uvector<int> selected_clusters(n_selected_clusters, stream);
+
+  // copying selected clusters by index
+  thrust::copy_if(thrust_policy, thrust::make_counting_iterator(value_idx(0)),
+                  thrust::make_counting_iterator(n_clusters), is_cluster,
+                  selected_clusters.data(),
+                  [] __device__(auto cluster) { return cluster; });
+
+  // sort lambdas and parents by children for epsilon search
+  auto start = thrust::make_zip_iterator(thrust::make_tuple(parents, lambdas));
+  thrust::sort_by_key(thrust_policy, children, children + cluster_tree_edges,
+                      start);
+  rmm::device_uvector<value_t> eps(cluster_tree_edges, stream);
+  thrust::transform(thrust_policy, lambdas, lambdas + cluster_tree_edges,
+                    eps.begin(), [] __device__(auto x) { return 1 / x; });
+
+  // declare frontier and search
+  rmm::device_uvector<int> frontier(n_clusters, stream);
+  thrust::fill(thrust_policy, frontier.begin(), frontier.end(), false);
+
+  auto nblocks = raft::ceildiv(n_selected_clusters, tpb);
+  cluster_epsilon_search_kernel<<<nblocks, tpb, 0, stream>>>(
+    selected_clusters.data(), n_selected_clusters, parents, children, lambdas,
+    cluster_tree_edges, is_cluster, frontier.data(), n_clusters,
+    cluster_selection_epsilon, allow_single_cluster);
+
+  rmm::device_uvector<value_idx> indptr(n_clusters + 1, stream);
+  parent_csr(handle, cluster_tree, indptr.data());
+
+  perform_bfs(handle, indptr.data(), children, frontier.data(), is_cluster,
+              n_clusters, propagate_cluster_negation_kernel<value_idx>);
+}
+
+/**
+ * Entry point for end-to-end cluster selection logic
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] condensed_tree condensed hierarchy
+ * @param[in] tree_stabilities stabilities array (size n_leaves from condensed hierarchy)
+ * @param[out] is_cluster array of cluster selections / deselections (size n_clusters from condensed hierarchy)
+ * @param[in] cluster_selection_method method to use for selecting clusters
+ * @param[in] allow_single_cluster whether a single cluster can be selected in noisy conditions
+ * @param[in] max_cluster_size max size cluster to select before selecting children
+ * @param[in] cluster_selection_epsilon distance threshold (0.0 disables distance selection)
+ */
+template <typename value_idx, typename value_t>
+void select_clusters(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+  value_t *tree_stabilities, int *is_cluster,
+  Common::CLUSTER_SELECTION_METHOD cluster_selection_method,
+  bool allow_single_cluster, int max_cluster_size,
+  float cluster_selection_epsilon) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(handle.get_stream());
+
+  auto n_clusters = condensed_tree.get_n_clusters();
+
+  auto cluster_tree = Utils::make_cluster_tree(handle, condensed_tree);
+
+  if (cluster_selection_method == Common::CLUSTER_SELECTION_METHOD::EOM) {
+    Select::excess_of_mass(handle, cluster_tree, tree_stabilities, is_cluster,
+                           n_clusters, max_cluster_size, allow_single_cluster);
+  } else {
+    thrust::fill(thrust_policy, is_cluster, is_cluster + n_clusters, false);
+
+    if (cluster_tree.get_n_edges() > 0) {
+      Select::leaf(handle, cluster_tree, is_cluster, n_clusters);
+    }
+  }
+
+  auto n_selected_clusters =
+    thrust::reduce(thrust_policy, is_cluster, is_cluster + n_clusters);
+
+  // this variable is only used when cluster_selection_epsilon != 0.0
+  auto epsilon_search = true;
+
+  if (cluster_selection_method == Common::CLUSTER_SELECTION_METHOD::LEAF) {
+    // TODO: reenable to match reference implementation
+    // It's a confirmed bug https://github.com/scikit-learn-contrib/hdbscan/issues/476
+
+    // if no cluster leaves were found, declare root as cluster
+    // if (n_selected_clusters == 0 && allow_single_cluster) {
+    //   constexpr int root_is_cluster = true;
+    //   raft::update_device(is_cluster, &root_is_cluster, 1, stream);
+    //   epsilon_search = false;
+    // }
+  }
+
+  if (cluster_selection_epsilon != 0.0 && cluster_tree.get_n_edges() > 0) {
+    // no epsilon search if no clusters were selected
+    if (n_selected_clusters == 0) {
+      epsilon_search = false;
+    }
+
+    // this is to check when eom finds root as only cluster
+    // in which case, epsilon search is cancelled
+    if (cluster_selection_method == Common::CLUSTER_SELECTION_METHOD::EOM) {
+      if (n_selected_clusters == 1) {
+        int is_root_only_cluster = false;
+        raft::update_host(&is_root_only_cluster, is_cluster, 1, stream);
+        if (is_root_only_cluster && allow_single_cluster) {
+          epsilon_search = false;
+        }
+      }
+    }
+    if (epsilon_search) {
+      Select::cluster_epsilon_search(handle, cluster_tree, is_cluster,
+                                     n_clusters, cluster_selection_epsilon,
+                                     allow_single_cluster, n_selected_clusters);
+    }
+  }
+}
+
+};  // namespace Select
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
diff --git a/cpp/src/hdbscan/detail/stabilities.cuh b/cpp/src/hdbscan/detail/stabilities.cuh
new file mode 100644
index 0000000000..045c38e508
--- /dev/null
+++ b/cpp/src/hdbscan/detail/stabilities.cuh
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "kernels/stabilities.cuh"
+#include "utils.h"
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <raft/label/classlabels.cuh>
+
+#include <algorithm>
+
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Stability {
+
+/**
+ * Computes stability scores which are used for excess of mass cluster
+ * selection. Stabilities are computed over the points in each cluster as the sum
+ * of the lambda (1 / distance) of each point minus the lambda of its parent.
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] condensed_tree condensed hierarchy (size n_points + n_clusters)
+ * @param[out] stabilities output stabilities array (size n_clusters)
+ */
+template <typename value_idx, typename value_t>
+void compute_stabilities(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+  value_t *stabilities) {
+  auto parents = condensed_tree.get_parents();
+  auto children = condensed_tree.get_children();
+  auto lambdas = condensed_tree.get_lambdas();
+  auto sizes = condensed_tree.get_sizes();
+  auto n_edges = condensed_tree.get_n_edges();
+  auto n_clusters = condensed_tree.get_n_clusters();
+  auto n_leaves = condensed_tree.get_n_leaves();
+
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  rmm::device_uvector<value_idx> sorted_parents(n_edges, stream);
+  raft::copy_async(sorted_parents.data(), parents, n_edges, stream);
+
+  rmm::device_uvector<value_idx> sorted_parents_offsets(n_edges + 1, stream);
+  Utils::parent_csr(handle, condensed_tree, sorted_parents.data(),
+                    sorted_parents_offsets.data());
+
+  // This is to consider the case where a child may also be a parent
+  // in which case, births for that parent are initialized to
+  // lambda for that child
+  rmm::device_uvector<value_t> births(n_clusters, stream);
+  thrust::fill(exec_policy, births.begin(), births.end(), 0.0f);
+  auto births_init_op = [n_leaves, children, lambdas,
+                         births = births.data()] __device__(const auto &idx) {
+    auto child = children[idx];
+    if (child >= n_leaves) {
+      births[child - n_leaves] = lambdas[idx];
+    }
+  };
+
+  // this is to find minimum lambdas of all children under a parent
+  rmm::device_uvector<value_t> births_parent_min(n_clusters, stream);
+  thrust::for_each(exec_policy, thrust::make_counting_iterator(value_idx(0)),
+                   thrust::make_counting_iterator(n_edges), births_init_op);
+
+  Utils::cub_segmented_reduce(
+    lambdas, births_parent_min.data() + 1, n_clusters - 1,
+    sorted_parents_offsets.data() + 1, stream,
+    cub::DeviceSegmentedReduce::Min<const value_t *, value_t *,
+                                    const value_idx *>);
+  // finally, we find minimum between initialized births where parent=child
+  // and births of parents for their childrens
+  auto births_zip = thrust::make_zip_iterator(
+    thrust::make_tuple(births.data(), births_parent_min.data()));
+  auto min_op =
+    [] __device__(const thrust::tuple<value_t, value_t> &birth_pair) {
+      auto birth = thrust::get<0>(birth_pair);
+      auto births_parent_min = thrust::get<1>(birth_pair);
+
+      return birth < births_parent_min ? birth : births_parent_min;
+    };
+  thrust::transform(exec_policy, births_zip + 1, births_zip + n_clusters,
+                    births.begin() + 1, min_op);
+
+  thrust::fill(exec_policy, stabilities, stabilities + n_clusters, 0.0f);
+
+  // for each child, calculate summation (lambda[child] - birth[parent]) * sizes[child]
+  stabilities_functor<value_idx, value_t> stabilities_op(
+    stabilities, births.data(), parents, lambdas, sizes, n_leaves);
+  thrust::for_each(exec_policy, thrust::make_counting_iterator(value_idx(0)),
+                   thrust::make_counting_iterator(n_edges), stabilities_op);
+}
+
+/**
+ * Computes stability scores for each cluster by normalizing their
+ * stabilities by their sizes and scaling by the lambda of the root.
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] labels labels array (size n_leaves)
+ * @param[in] stability stabilities array (size n_clusters)
+ * @param[in] n_clusters number of clusters in cluster tree
+ * @param[in] max_lambda maximum lambda of cluster hierarchy
+ * @param[in] n_leaves number of data points (non-clusters) in hierarchy
+ * @param[out] result output stability scores
+ */
+template <typename value_idx, typename value_t>
+void get_stability_scores(const raft::handle_t &handle, const value_idx *labels,
+                          const value_t *stability, size_t n_clusters,
+                          value_t max_lambda, size_t n_leaves,
+                          value_t *result) {
+  auto stream = handle.get_stream();
+  auto exec_policy = rmm::exec_policy(stream);
+
+  /**
+   * 1. Populate cluster sizes
+   */
+  rmm::device_uvector<value_idx> cluster_sizes(n_clusters, handle.get_stream());
+  thrust::fill(exec_policy, cluster_sizes.data(),
+               cluster_sizes.data() + cluster_sizes.size(), 0);
+
+  value_idx *sizes = cluster_sizes.data();
+  thrust::for_each(exec_policy, labels, labels + n_leaves,
+                   [=] __device__(value_idx v) {
+                     if (v > -1) atomicAdd(sizes + v, 1);
+                   });
+
+  /**
+   * Compute stability scores
+   */
+  auto enumeration = thrust::make_zip_iterator(thrust::make_tuple(
+    thrust::make_counting_iterator(0), cluster_sizes.data()));
+  thrust::transform(
+    exec_policy, enumeration, enumeration + n_clusters, result,
+    [=] __device__(thrust::tuple<value_idx, value_idx> tup) {
+      value_idx size = thrust::get<1>(tup);
+      value_idx c = thrust::get<0>(tup);
+
+      bool expr = max_lambda == std::numeric_limits<value_t>::max() ||
+                  max_lambda == 0.0 || size == 0;
+      return (!expr * (stability[c] / size * max_lambda)) + (expr * 1.0);
+    });
+}
+
+};  // namespace Stability
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/detail/utils.h b/cpp/src/hdbscan/detail/utils.h
new file mode 100644
index 0000000000..77a47455ab
--- /dev/null
+++ b/cpp/src/hdbscan/detail/utils.h
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <label/classlabels.cuh>
+
+#include <cub/cub.cuh>
+
+#include <raft/cudart_utils.h>
+
+#include <raft/sparse/op/sort.h>
+#include <raft/sparse/convert/csr.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <raft/label/classlabels.cuh>
+
+#include <algorithm>
+
+#include <hdbscan/condensed_hierarchy.cu>
+
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/reduce.h>
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+namespace ML {
+namespace HDBSCAN {
+namespace detail {
+namespace Utils {
+
+/**
+ * Invokes a cub segmented reduce function over a CSR data array
+ * using the indptr as segment offsets
+ * @tparam value_idx
+ * @tparam value_t
+ * @tparam CUBReduceFunc
+ * @param[in] in data array (size offsets[n_segments]+1)
+ * @param[out] out output data array (size offsets[n_segmented]+1)
+ * @param[in] n_segments number of segments in offsets array
+ * @param[in] offsets array of segment offsets (size n_segments+1)
+ * @param[in] stream cuda stream for ordering operations
+ * @param[in] cub_reduce_func segmented reduction function
+ */
+template <typename value_idx, typename value_t, typename CUBReduceFunc>
+void cub_segmented_reduce(const value_t *in, value_t *out, int n_segments,
+                          const value_idx *offsets, cudaStream_t stream,
+                          CUBReduceFunc cub_reduce_func) {
+  rmm::device_uvector<char> d_temp_storage(0, stream);
+  size_t temp_storage_bytes = 0;
+  cub_reduce_func(nullptr, temp_storage_bytes, in, out, n_segments, offsets,
+                  offsets + 1, stream, false);
+  d_temp_storage.resize(temp_storage_bytes, stream);
+
+  cub_reduce_func(d_temp_storage.data(), temp_storage_bytes, in, out,
+                  n_segments, offsets, offsets + 1, stream, false);
+}
+
+/**
+ * Constructs a cluster tree from a CondensedHierarchy by
+ * filtering for only entries with cluster size > 1
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] condensed_tree condensed hierarchy (size n_leaves + n_clusters)
+ * @return a new condensed hierarchy with only entries of size > 1
+ */
+template <typename value_idx, typename value_t>
+Common::CondensedHierarchy<value_idx, value_t> make_cluster_tree(
+  const raft::handle_t &handle,
+  Common::CondensedHierarchy<value_idx, value_t> &condensed_tree) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(stream);
+  auto parents = condensed_tree.get_parents();
+  auto children = condensed_tree.get_children();
+  auto lambdas = condensed_tree.get_lambdas();
+  auto sizes = condensed_tree.get_sizes();
+
+  value_idx cluster_tree_edges = thrust::transform_reduce(
+    thrust_policy, sizes, sizes + condensed_tree.get_n_edges(),
+    [=] __device__(value_idx a) { return a > 1; }, 0,
+    thrust::plus<value_idx>());
+
+  // remove leaves from condensed tree
+  rmm::device_uvector<value_idx> cluster_parents(cluster_tree_edges, stream);
+  rmm::device_uvector<value_idx> cluster_children(cluster_tree_edges, stream);
+  rmm::device_uvector<value_t> cluster_lambdas(cluster_tree_edges, stream);
+  rmm::device_uvector<value_idx> cluster_sizes(cluster_tree_edges, stream);
+
+  auto in = thrust::make_zip_iterator(
+    thrust::make_tuple(parents, children, lambdas, sizes));
+
+  auto out = thrust::make_zip_iterator(
+    thrust::make_tuple(cluster_parents.data(), cluster_children.data(),
+                       cluster_lambdas.data(), cluster_sizes.data()));
+
+  thrust::copy_if(thrust_policy, in, in + (condensed_tree.get_n_edges()), sizes,
+                  out, [=] __device__(value_idx a) { return a > 1; });
+
+  auto n_leaves = condensed_tree.get_n_leaves();
+  thrust::transform(
+    thrust_policy, cluster_parents.begin(), cluster_parents.end(),
+    cluster_parents.begin(),
+    [n_leaves] __device__(value_idx a) { return a - n_leaves; });
+  thrust::transform(
+    thrust_policy, cluster_children.begin(), cluster_children.end(),
+    cluster_children.begin(),
+    [n_leaves] __device__(value_idx a) { return a - n_leaves; });
+
+  return Common::CondensedHierarchy<value_idx, value_t>(
+    handle, condensed_tree.get_n_leaves(), cluster_tree_edges,
+    condensed_tree.get_n_clusters(), std::move(cluster_parents),
+    std::move(cluster_children), std::move(cluster_lambdas),
+    std::move(cluster_sizes));
+}
+
+/**
+ * Computes a CSR index of sorted parents of condensed tree. 
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[inout] condensed_tree cluster tree (condensed hierarchy with all nodes of size > 1)
+ * @param[in] sorted_parents parents array sorted
+ * @param[out] indptr CSR indptr of parents array after sort
+ */
+template <typename value_idx, typename value_t>
+void parent_csr(const raft::handle_t &handle,
+                Common::CondensedHierarchy<value_idx, value_t> &condensed_tree,
+                value_idx *sorted_parents, value_idx *indptr) {
+  auto stream = handle.get_stream();
+  auto thrust_policy = rmm::exec_policy(stream);
+
+  auto children = condensed_tree.get_children();
+  auto sizes = condensed_tree.get_sizes();
+  auto n_edges = condensed_tree.get_n_edges();
+  auto n_leaves = condensed_tree.get_n_leaves();
+  auto n_clusters = condensed_tree.get_n_clusters();
+
+  // 0-index sorted parents by subtracting n_leaves for offsets and birth/stability indexing
+  auto index_op = [n_leaves] __device__(const auto &x) { return x - n_leaves; };
+  thrust::transform(thrust_policy, sorted_parents, sorted_parents + n_edges,
+                    sorted_parents, index_op);
+
+  raft::sparse::convert::sorted_coo_to_csr(
+    sorted_parents, n_edges, indptr, n_clusters + 1,
+    handle.get_device_allocator(), stream);
+}
+
+};  // namespace Utils
+};  // namespace detail
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/hdbscan.cu b/cpp/src/hdbscan/hdbscan.cu
new file mode 100644
index 0000000000..68645fbeb4
--- /dev/null
+++ b/cpp/src/hdbscan/hdbscan.cu
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <hdbscan/runner.h>
+
+namespace ML {
+
+void hdbscan(const raft::handle_t &handle, const float *X, size_t m, size_t n,
+             raft::distance::DistanceType metric,
+             HDBSCAN::Common::HDBSCANParams &params,
+             HDBSCAN::Common::hdbscan_output<int, float> &out) {
+  HDBSCAN::_fit_hdbscan(handle, X, m, n, metric, params, out);
+}
+
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src/hdbscan/runner.h b/cpp/src/hdbscan/runner.h
new file mode 100644
index 0000000000..49e2591d58
--- /dev/null
+++ b/cpp/src/hdbscan/runner.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <raft/cudart_utils.h>
+
+#include <raft/handle.hpp>
+#include <rmm/device_uvector.hpp>
+
+#include <cuml/common/logger.hpp>
+
+#include <raft/sparse/coo.cuh>
+#include <raft/sparse/hierarchy/detail/agglomerative.cuh>
+#include <raft/sparse/hierarchy/detail/mst.cuh>
+
+#include <cuml/cluster/hdbscan.hpp>
+#include "detail/condense.cuh"
+#include "detail/extract.cuh"
+#include "detail/reachability.cuh"
+
+namespace ML {
+namespace HDBSCAN {
+
+/**
+ * Functor with reduction ops for performing fused 1-nn
+ * computation and guaranteeing only cross-component
+ * neighbors are considered.
+ * @tparam value_idx
+ * @tparam value_t
+ */
+template <typename value_idx, typename value_t>
+struct FixConnectivitiesRedOp {
+  value_idx *colors;
+  value_t *core_dists;
+  value_idx m;
+
+  FixConnectivitiesRedOp(value_idx *colors_, value_t *core_dists_, value_idx m_)
+    : colors(colors_), core_dists(core_dists_), m(m_){};
+
+  typedef typename cub::KeyValuePair<value_idx, value_t> KVP;
+  DI void operator()(value_idx rit, KVP *out, const KVP &other) {
+    if (rit < m && other.value < std::numeric_limits<value_t>::max() &&
+        colors[rit] != colors[other.key]) {
+      value_t core_dist_rit = core_dists[rit];
+      value_t core_dist_other =
+        max(core_dist_rit, max(core_dists[other.key], other.value));
+      value_t core_dist_out =
+        max(core_dist_rit, max(core_dists[out->key], out->value));
+
+      bool smaller = core_dist_other < core_dist_out;
+      out->key = smaller ? other.key : out->key;
+      out->value = smaller ? core_dist_other : core_dist_out;
+    }
+  }
+
+  DI KVP operator()(value_idx rit, const KVP &a, const KVP &b) {
+    if (rit < m && a.key > -1 && colors[rit] != colors[a.key]) {
+      value_t core_dist_rit = core_dists[rit];
+      value_t core_dist_a = max(core_dist_rit, max(core_dists[a.key], a.value));
+      value_t core_dist_b = max(core_dist_rit, max(core_dists[b.key], b.value));
+
+      return core_dist_a < core_dist_b ? KVP(a.key, core_dist_a)
+                                       : KVP(b.key, core_dist_b);
+    }
+
+    return b;
+  }
+
+  DI void init(value_t *out, value_t maxVal) { *out = maxVal; }
+  DI void init(KVP *out, value_t maxVal) {
+    out->key = -1;
+    out->value = maxVal;
+  }
+};
+
+/**
+ * Constructs a linkage by computing mutual reachability, mst, and
+ * dendrogram. This is shared by HDBSCAN and Robust Single Linkage
+ * since the two algorithms differ only in the cluster
+ * selection and extraction.
+ * @tparam value_idx
+ * @tparam value_t
+ * @param[in] handle raft handle for resource reuse
+ * @param[in] X data points (size m * n)
+ * @param[in] m number of rows
+ * @param[in] n number of columns
+ * @param[in] metric distance metric to use
+ * @param[in] params hyper parameters
+ * @param[out] out output container object
+ */
+template <typename value_idx = int64_t, typename value_t = float>
+void build_linkage(
+  const raft::handle_t &handle, const value_t *X, size_t m, size_t n,
+  raft::distance::DistanceType metric, Common::HDBSCANParams &params,
+  Common::robust_single_linkage_output<value_idx, value_t> &out) {
+  auto d_alloc = handle.get_device_allocator();
+  auto stream = handle.get_stream();
+
+  int k = params.k + 1;
+
+  /**
+   * Mutual reachability graph
+   */
+  rmm::device_uvector<value_idx> mutual_reachability_indptr(m + 1, stream);
+  raft::sparse::COO<value_t, value_idx> mutual_reachability_coo(d_alloc, stream,
+                                                                k * m * 2);
+  rmm::device_uvector<value_t> core_dists(m, stream);
+
+  detail::Reachability::mutual_reachability_graph(
+    handle, X, (size_t)m, (size_t)n, metric, k, params.min_samples,
+    params.alpha, mutual_reachability_indptr.data(), core_dists.data(),
+    mutual_reachability_coo);
+
+  /**
+   * Construct MST sorted by weights
+   */
+
+  rmm::device_uvector<value_idx> color(m, stream);
+  FixConnectivitiesRedOp<value_idx, value_t> red_op(color.data(),
+                                                    core_dists.data(), m);
+  // during knn graph connection
+  raft::hierarchy::detail::build_sorted_mst(
+    handle, X, mutual_reachability_indptr.data(),
+    mutual_reachability_coo.cols(), mutual_reachability_coo.vals(), m, n,
+    out.get_mst_src(), out.get_mst_dst(), out.get_mst_weights(), color.data(),
+    mutual_reachability_coo.nnz, red_op, metric, (size_t)10);
+
+  /**
+   * Perform hierarchical labeling
+   */
+  size_t n_edges = m - 1;
+
+  raft::hierarchy::detail::build_dendrogram_host(
+    handle, out.get_mst_src(), out.get_mst_dst(), out.get_mst_weights(),
+    n_edges, out.get_children(), out.get_deltas(), out.get_sizes());
+}
+
+template <typename value_idx = int64_t, typename value_t = float>
+void _fit_hdbscan(const raft::handle_t &handle, const value_t *X, size_t m,
+                  size_t n, raft::distance::DistanceType metric,
+                  Common::HDBSCANParams &params,
+                  Common::hdbscan_output<value_idx, value_t> &out) {
+  auto d_alloc = handle.get_device_allocator();
+  auto stream = handle.get_stream();
+
+  int min_cluster_size = params.min_cluster_size;
+
+  build_linkage(handle, X, m, n, metric, params, out);
+
+  /**
+   * Condense branches of tree according to min cluster size
+   */
+  detail::Condense::build_condensed_hierarchy(
+    handle, out.get_children(), out.get_deltas(), out.get_sizes(),
+    min_cluster_size, m, out.get_condensed_tree());
+
+  out.set_n_clusters(out.get_condensed_tree().get_n_clusters());
+
+  /**
+   * Extract labels from stability
+   */
+  detail::Extract::extract_clusters(
+    handle, out.get_condensed_tree(), m, out.get_labels(),
+    out.get_stabilities(), out.get_probabilities(),
+    params.cluster_selection_method, params.allow_single_cluster,
+    params.max_cluster_size, params.cluster_selection_epsilon);
+}
+
+};  // end namespace HDBSCAN
+};  // end namespace ML
\ No newline at end of file
diff --git a/cpp/src_prims/label/classlabels.cuh b/cpp/src_prims/label/classlabels.cuh
index 9fc690f5fe..765b02bc4f 100644
--- a/cpp/src_prims/label/classlabels.cuh
+++ b/cpp/src_prims/label/classlabels.cuh
@@ -21,6 +21,7 @@
 #include <raft/cudart_utils.h>
 #include <cuml/common/device_buffer.hpp>
 #include <raft/cuda_utils.cuh>
+#include <raft/handle.hpp>
 #include <raft/linalg/unary_op.cuh>
 #include <raft/mr/device/allocator.hpp>
 
@@ -146,9 +147,9 @@ __global__ void map_label_kernel(Type *map_ids, size_t N_labels, Type *in,
    * should have monotonically increasing labels applied to them.
    */
 template <typename Type, typename Lambda>
-void make_monotonic(Type *out, Type *in, size_t N, cudaStream_t stream,
-                    Lambda filter_op,
-                    std::shared_ptr<raft::mr::device::allocator> allocator) {
+int make_monotonic(Type *out, Type *in, size_t N, cudaStream_t stream,
+                   Lambda filter_op,
+                   std::shared_ptr<raft::mr::device::allocator> allocator) {
   static const size_t TPB_X = 256;
 
   dim3 blocks(raft::ceildiv(N, TPB_X));
@@ -162,6 +163,8 @@ void make_monotonic(Type *out, Type *in, size_t N, cudaStream_t stream,
     map_ids, num_clusters, in, out, N, filter_op);
 
   allocator->deallocate(map_ids, num_clusters * sizeof(Type), stream);
+
+  return num_clusters;
 }
 
 /**
@@ -187,5 +190,13 @@ void make_monotonic(Type *out, Type *in, size_t N, cudaStream_t stream,
   make_monotonic<Type>(
     out, in, N, stream, [] __device__(Type val) { return false; }, allocator);
 }
+
+template <typename Type>
+int make_monotonic(const raft::handle_t &handle, Type *out, Type *in,
+                   size_t N) {
+  return make_monotonic<Type>(
+    out, in, N, handle.get_stream(), [] __device__(Type val) { return false; },
+    handle.get_device_allocator());
+}
 };  // namespace Label
 };  // end namespace MLCommon
diff --git a/cpp/test/CMakeLists.txt b/cpp/test/CMakeLists.txt
index 040df7b461..31935f1f18 100644
--- a/cpp/test/CMakeLists.txt
+++ b/cpp/test/CMakeLists.txt
@@ -47,6 +47,8 @@ if(BUILD_CUML_TESTS)
     sg/fnv_hash_test.cpp
     sg/genetic/node_test.cpp
     sg/genetic/param_test.cu
+    sg/handle_test.cu
+    sg/hdbscan_test.cu
     sg/holtwinters_test.cu
     sg/kmeans_test.cu
     sg/knn_test.cu
diff --git a/cpp/test/sg/hdbscan_inputs.hpp b/cpp/test/sg/hdbscan_inputs.hpp
new file mode 100644
index 0000000000..de45bd115a
--- /dev/null
+++ b/cpp/test/sg/hdbscan_inputs.hpp
@@ -0,0 +1,2863 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <datasets/digits.h>
+#include <cuml/cluster/hdbscan.hpp>
+
+#include <vector>
+
+namespace ML {
+namespace HDBSCAN {
+
+template <typename T, typename IdxT>
+struct HDBSCANInputs {
+  IdxT n_row;
+  IdxT n_col;
+  int k, min_pts, min_cluster_size;
+
+  std::vector<T> data;
+
+  std::vector<IdxT> expected_labels;
+};
+
+template <typename T, typename IdxT>
+struct ClusterCondensingInputs {
+  IdxT n_row;
+  int min_cluster_size;
+
+  std::vector<IdxT> mst_src;
+  std::vector<IdxT> mst_dst;
+  std::vector<T> mst_data;
+
+  std::vector<IdxT> expected;
+};
+
+template <typename T, typename IdxT>
+struct ClusterSelectionInputs {
+  IdxT n_row;
+  int min_samples;
+  int min_cluster_size;
+
+  std::vector<IdxT> condensed_parents;
+  std::vector<IdxT> condensed_children;
+  std::vector<T> condensed_lambdas;
+  std::vector<IdxT> condensed_sizes;
+
+  Common::CLUSTER_SELECTION_METHOD cluster_selection_method;
+  bool allow_single_cluster;
+  T cluster_selection_epsilon;
+
+  std::vector<T> probabilities;
+  std::vector<IdxT> labels;
+};
+
+const std::vector<HDBSCANInputs<float, int>> hdbscan_inputsf2 = {
+  // Test n_clusters == n_points
+  {10,
+   5,
+   5,
+   2,
+   3,
+   {0.21390334, 0.50261639, 0.91036676, 0.59166485, 0.71162682, 0.10248392,
+    0.77782677, 0.43772379, 0.4035871,  0.3282796,  0.47544681, 0.59862974,
+    0.12319357, 0.06239463, 0.28200272, 0.1345717,  0.50498218, 0.5113505,
+    0.16233086, 0.62165332, 0.42281548, 0.933117,   0.41386077, 0.23264562,
+    0.73325968, 0.37537541, 0.70719873, 0.14522645, 0.73279625, 0.9126674,
+    0.84854131, 0.28890216, 0.85267903, 0.74703138, 0.83842071, 0.34942792,
+    0.27864171, 0.70911132, 0.21338564, 0.32035554, 0.73788331, 0.46926692,
+    0.57570162, 0.42559178, 0.87120209, 0.22734951, 0.01847905, 0.75549396,
+    0.76166195, 0.66613745},
+   {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+  //  // Test outlier points
+  {9,
+   2,
+   3,
+   3,
+   3,
+   {-1, -50, 3, 4, 5000, 10000, 1, 3, 4, 5, 0.000005, 0.00002, 2000000, 500000,
+    10, 50, 30, 5},
+   {-1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+  // Test n_clusters == (n_points / 2)
+  {10,
+   5,
+   4,
+   3,
+   4,
+   {0.21390334, 0.50261639, 0.91036676, 0.59166485, 0.71162682, 0.10248392,
+    0.77782677, 0.43772379, 0.4035871,  0.3282796,  0.47544681, 0.59862974,
+    0.12319357, 0.06239463, 0.28200272, 0.1345717,  0.50498218, 0.5113505,
+    0.16233086, 0.62165332, 0.42281548, 0.933117,   0.41386077, 0.23264562,
+    0.73325968, 0.37537541, 0.70719873, 0.14522645, 0.73279625, 0.9126674,
+    0.84854131, 0.28890216, 0.85267903, 0.74703138, 0.83842071, 0.34942792,
+    0.27864171, 0.70911132, 0.21338564, 0.32035554, 0.73788331, 0.46926692,
+    0.57570162, 0.42559178, 0.87120209, 0.22734951, 0.01847905, 0.75549396,
+    0.76166195, 0.66613745},
+   {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+  {MLCommon::Datasets::Digits::n_samples,
+   MLCommon::Datasets::Digits::n_features,
+   50,
+   50,
+   25,
+   MLCommon::Datasets::Digits::digits,
+   {5,  3,  -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, 6,  -1, -1, -1, -1, -1,
+    -1, 5,  -1, 1,  -1, -1, -1, -1, -1, -1, -1, 5,  -1, -1, -1, 4,  -1, 5,  -1,
+    -1, -1, -1, 2,  -1, -1, 0,  -1, -1, -1, 5,  5,  -1, -1, -1, -1, -1, -1, -1,
+    -1, 4,  -1, -1, -1, -1, -1, -1, 4,  4,  -1, -1, -1, -1, -1, 5,  -1, -1, -1,
+    -1, -1, -1, 5,  -1, 0,  -1, -1, 1,  -1, -1, -1, 4,  -1, -1, -1, -1, -1, 0,
+    -1, -1, -1, -1, 3,  -1, -1, -1, -1, -1, -1, -1, -1, 0,  -1, -1, -1, 0,  -1,
+    -1, -1, -1, -1, 0,  -1, -1, -1, -1, -1, 2,  -1, 5,  -1, -1, -1, 5,  -1, 1,
+    -1, -1, -1, 4,  0,  -1, -1, 5,  -1, -1, -1, -1, -1, 4,  -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, -1, 4,  -1, 5,  -1, -1, -1, -1,
+    -1, -1, 0,  0,  6,  -1, -1, 5,  -1, 1,  1,  0,  -1, -1, 5,  -1, -1, 4,  -1,
+    -1, -1, -1, -1, -1, 4,  4,  4,  -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  -1, -1, -1, -1, -1,
+    -1, 5,  -1, -1, 4,  -1, 4,  -1, 0,  -1, -1, -1, -1, -1, 3,  -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, 5,  -1, -1, -1, 5,  3,  1,  -1, -1, -1, 4,  -1, -1, -1,
+    5,  -1, 1,  6,  -1, -1, 4,  0,  -1, -1, 5,  -1, -1, 6,  -1, -1, 4,  -1, -1,
+    -1, 5,  -1, -1, -1, 4,  -1, -1, -1, -1, -1, -1, 2,  -1, 0,  0,  -1, -1, -1,
+    5,  5,  -1, -1, 0,  -1, 1,  5,  -1, -1, -1, -1, 6,  -1, -1, -1, -1, 4,  4,
+    4,  -1, -1, 3,  -1, 5,  -1, -1, 1,  -1, -1, 5,  5,  -1, 0,  4,  6,  -1, -1,
+    0,  -1, 4,  6,  3,  -1, -1, 3,  -1, 4,  -1, 2,  -1, 3,  -1, 5,  -1, 6,  4,
+    -1, -1, -1, -1, -1, -1, 2,  0,  -1, -1, -1, 1,  -1, 0,  -1, -1, -1, -1, -1,
+    2,  -1, 5,  -1, -1, -1, 5,  -1, 1,  -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,  -1,
+    -1, -1, -1, -1, 5,  -1, -1, 6,  -1, -1, -1, -1, -1, -1, -1, -1, 5,  5,  -1,
+    1,  -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, -1, 4,  -1, 4,  -1, -1,
+    -1, -1, 5,  -1, -1, -1, -1, 1,  5,  5,  -1, -1, 4,  -1, 1,  -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,  -1, -1, 4,  -1, -1, -1,
+    -1, -1, -1, -1, -1, 1,  -1, 1,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,
+    -1, -1, -1, 5,  -1, -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, -1, -1, -1,
+    4,  0,  -1, -1, 5,  -1, -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, -1, 4,
+    -1, 5,  -1, -1, -1, -1, -1, -1, 0,  0,  -1, -1, -1, 5,  5,  -1, -1, -1, -1,
+    -1, 5,  -1, -1, -1, -1, -1, 0,  -1, -1, 2,  -1, 4,  -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, 6,  -1, -1, 0,  -1, -1, -1, -1, 0,  -1, -1, -1, -1, -1,
+    -1, -1, 0,  4,  -1, -1, -1, -1, -1, -1, -1, -1, 4,  -1, -1, -1, 0,  -1, -1,
+    -1, -1, -1, -1, 1,  -1, -1, 0,  6,  -1, -1, -1, -1, -1, -1, 5,  -1, -1, -1,
+    5,  3,  -1, -1, -1, -1, 4,  0,  -1, -1, -1, -1, -1, -1, -1, -1, 4,  -1, -1,
+    -1, 5,  -1, 1,  -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, -1, 4,  -1, 5,  -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5,  5,  -1, -1, 0,  -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, 6,  -1, 4,  4,  -1, -1, -1, -1, -1, 5,  -1, -1, -1,
+    -1, -1, 5,  5,  -1, -1, 4,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,  -1,
+    4,  -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, 0,  -1, -1, -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1, 3,  1,
+    -1, -1, -1, -1, 0,  -1, 6,  5,  -1, 1,  -1, 2,  -1, -1, 0,  -1, -1, -1, 3,
+    -1, 6,  -1, -1, -1, 0,  -1, -1, 5,  -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1,
+    2,  -1, -1, 0,  -1, -1, 3,  -1, -1, 1,  -1, -1, -1, -1, 5,  -1, 1,  4,  -1,
+    -1, 0,  -1, -1, 2,  4,  -1, -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1,
+    5,  -1, 0,  4,  6,  -1, 3,  -1, -1, -1, -1, 3,  6,  -1, 3,  -1, 4,  -1, -1,
+    -1, 3,  -1, 5,  -1, -1, -1, -1, 4,  -1, -1, -1, -1, -1, 0,  -1, -1, -1, -1,
+    -1, 0,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1,  -1, -1, -1, 4,
+    -1, -1, -1, 5,  -1, -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, 1,  -1, -1, -1,
+    4,  -1, -1, -1, 5,  -1, -1, -1, 4,  -1, 5,  -1, -1, 6,  -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, 5,  -1, 1,  4,  -1, -1, -1, -1, -1, -1, 4,  4,
+    4,  -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, 0,  4,  -1, 1,  -1,
+    -1, 4,  -1, -1, -1, -1, -1, -1, 4,  -1, -1, -1, -1, -1, 5,  -1, -1, 4,  -1,
+    4,  -1, -1, -1, -1, -1, 0,  -1, -1, -1, 1,  -1, 0,  -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, 5,  -1, 1,  -1, -1, -1, 4,  0,  -1, -1, 5,  3,  -1, -1, -1, -1,
+    4,  0,  -1, -1, -1, 3,  -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, -1, -1, 4,
+    -1, 5,  -1, -1, -1, -1, -1, 3,  -1, -1, -1, -1, 3,  -1, -1, -1, -1, -1, 5,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4,  4,  -1, -1, 3,  -1, 5,  -1, -1,
+    -1, -1, -1, 5,  5,  3,  -1, -1, -1, 1,  3,  -1, -1, -1, -1, -1, -1, -1, 3,
+    -1, 4,  -1, -1, -1, 3,  -1, 5,  -1, -1, -1, -1, 4,  3,  -1, -1, -1, -1, -1,
+    1,  -1, -1, -1, -1, -1, -1, -1, 2,  -1, -1, -1, -1, 5,  -1, -1, -1, 5,  -1,
+    1,  6,  2,  -1, 4,  -1, -1, -1, 5,  -1, -1, -1, -1, -1, 4,  0,  -1, -1, -1,
+    -1, -1, -1, 2,  -1, 4,  -1, -1, -1, -1, -1, -1, -1, 4,  -1, -1, -1, -1, -1,
+    -1, -1, 3,  -1, 0,  -1, -1, -1, -1, -1, -1, 1,  0,  -1, -1, -1, -1, -1, 4,
+    -1, -1, -1, -1, -1, -1, 4,  4,  4,  -1, -1, 3,  -1, -1, -1, -1, -1, -1, -1,
+    -1, 5,  3,  -1, 4,  -1, -1, -1, -1, 2,  4,  -1, 3,  -1, -1, 3,  0,  4,  -1,
+    2,  -1, -1, 2,  -1, -1, -1, 4,  -1, 4,  -1, -1, -1, -1, 2,  -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, 6,  -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, 0,  -1, -1, 5,  -1, -1, -1,
+    -1, -1, -1, 0,  -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,  -1, -1,
+    -1, -1, -1, -1, -1, 5,  5,  -1, -1, 0,  -1, -1, 5,  -1, -1, 4,  -1, 6,  -1,
+    -1, -1, -1, 4,  -1, 4,  -1, -1, 3,  -1, 5,  -1, -1, -1, -1, -1, 5,  5,  -1,
+    -1, 4,  6,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  -1, -1, -1, -1, 3,
+    2,  5,  -1, -1, -1, -1, -1, 3,  -1, -1, -1, -1, 0,  -1, -1, -1, -1, -1, 0,
+    -1, -1, -1, 3,  -1, -1, -1, -1, -1, 5,  -1, 1,  -1, -1, -1, 4,  0,  -1, -1,
+    5,  -1, -1, -1, -1, -1, 4,  -1, -1, -1, 5,  -1, 1,  -1, 2,  -1, 4,  -1, -1,
+    6,  5,  6,  -1, -1, 4,  -1, 5,  -1, -1, -1, -1, 2,  -1, 0,  -1, -1, -1, -1,
+    5,  5,  1,  1,  -1, -1, -1, 5,  -1, -1, 4,  -1, -1, 0,  -1, 6,  -1, 4,  4,
+    4,  2,  -1, -1, -1, 5,  -1, -1, 1,  -1, -1, 5,  5,  -1, 0,  4,  6,  -1, -1,
+    0,  2,  4,  6,  -1, -1, 6,  -1, 0,  4,  -1, -1, -1, -1, 2,  5,  -1, 6,  4,
+    -1, 4,  -1, -1, -1, 2,  -1, -1, 1,  -1, -1, -1, -1, -1, -1, -1, 2,  -1, -1,
+    2,  -1, 5,  -1, -1, -1, 5,  3,  -1, -1, -1, -1, -1, -1, -1, -1, 5,  -1, -1,
+    -1, 2,  -1, -1, -1, 5,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4,  -1, 5,  -1, -1, -1, -1, 2,  -1, 0,  -1, -1, -1, 3,  -1, -1, -1, 1,  -1,
+    -1, -1, -1, -1, 1,  -1, -1, -1, -1, -1, -1, -1, 4,  -1, 4,  -1, -1, 3,  -1,
+    -1, -1, -1, -1, -1, 5,  3,  0,  -1, -1, 1,  -1, -1, -1, -1, -1, -1, -1, -1,
+    3,  -1, -1, -1, -1, -1, -1, -1, 5,  -1, 6,  -1, -1, 2,  -1, 0,  -1, 2,  -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, 2,  -1, 5,  -1, -1, -1, 5,  -1, 1,  -1, -1,
+    -1, -1, 0,  -1, -1, 5,  -1, -1, -1, -1, -1, 4,  -1, -1, 6,  5,  -1, -1, -1,
+    2,  -1, 4,  0,  -1, 6,  5,  6,  -1, -1, 4,  -1, 5,  -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, 3,  5,  5,  -1, 1,  0,  -1, -1, -1, -1, -1, 4,  -1, -1, -1,
+    -1, -1, -1, -1, 4,  -1, -1, 6,  -1, -1, 5,  6,  -1, -1, -1, -1, 5,  5,  -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,  0,  4,  -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, 4,  -1, -1, -1, -1, -1, -1, 1,  -1, 1,  -1, -1, -1,
+    -1, -1, -1, -1, -1, 2,  6,  5,  -1, -1, -1}}};
+
+const std::vector<ClusterCondensingInputs<float, int>>
+  cluster_condensing_inputs = {
+    {9,
+     3,
+     {0, 2, 4, 6, 7, 1, 8, 8},
+     {1, 3, 5, 5, 8, 5, 3, 4},
+     {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0},
+     {1}},
+
+    // Iris
+    {150,
+     3,
+     {39,  17,  34,  1,   27,  7,   49,  30,  4,   28,  34,  40,  12,  47,  29,
+      45,  2,   26,  3,   21,  48,  37,  38,  11,  96,  25,  42,  19,  94,  6,
+      92,  92,  58,  89,  35,  46,  10,  82,  86,  31,  36,  8,   149, 101, 127,
+      95,  120, 20,  123, 145, 55,  78,  112, 67,  88,  61,  147, 54,  97,  111,
+      124, 115, 116, 128, 104, 143, 54,  74,  65,  23,  5,   91,  51,  16,  71,
+      83,  139, 111, 126, 43,  80,  77,  77,  76,  103, 66,  90,  72,  138, 81,
+      63,  53,  144, 24,  32,  73,  133, 137, 56,  70,  132, 79,  110, 44,  146,
+      33,  121, 136, 102, 13,  84,  85,  52,  18,  141, 50,  59,  22,  64,  130,
+      113, 107, 14,  62,  105, 100, 87,  148, 108, 114, 15,  125, 119, 134, 135,
+      122, 68,  129, 60,  93,  57,  41,  109, 98,  106, 118, 117, 131, 23},
+     {0,   0,   9,   34,  0,   39,  7,   34,  0,   27,  49,  17,  1,   29,  30,
+      1,   47,  7,   47,  17,  27,  4,   3,   29,  99,  34,  38,  21,  99,  47,
+      99,  69,  75,  69,  49,  19,  48,  92,  58,  28,  10,  38,  101, 142, 149,
+      96,  140, 31,  127, 112, 96,  55,  140, 92,  96,  96,  145, 58,  78,  147,
+      120, 145, 147, 111, 128, 120, 74,  97,  75,  26,  10,  78,  75,  10,  97,
+      101, 112, 123, 123, 26,  69,  147, 86,  58,  116, 55,  94,  123, 127, 80,
+      91,  89,  140, 11,  46,  63,  83,  116, 51,  138, 128, 81,  147, 46,  123,
+      32,  101, 115, 120, 38,  66,  56,  86,  5,   145, 52,  89,  6,   82,  102,
+      101, 130, 33,  92,  107, 136, 72,  136, 128, 121, 33,  102, 72,  103, 130,
+      105, 87,  125, 93,  81,  93,  8,   143, 57,  84,  122, 105, 117, 98},
+     {0.17320508, 0.17320508, 0.2,        0.2236068,  0.2236068,  0.2236068,
+      0.2236068,  0.2236068,  0.2236068,  0.2236068,  0.24494897, 0.24494897,
+      0.24494897, 0.24494897, 0.24494897, 0.26457513, 0.26457513, 0.26457513,
+      0.26457513, 0.28284271, 0.28284271, 0.3,        0.3,        0.3,
+      0.3,        0.3,        0.31622777, 0.31622777, 0.31622777, 0.31622777,
+      0.31622777, 0.31622777, 0.31622777, 0.33166248, 0.33166248, 0.33166248,
+      0.33166248, 0.34641016, 0.34641016, 0.34641016, 0.36055513, 0.36055513,
+      0.36055513, 0.36055513, 0.36055513, 0.36055513, 0.36055513, 0.36055513,
+      0.37416574, 0.37416574, 0.37416574, 0.37416574, 0.37416574, 0.37416574,
+      0.37416574, 0.37416574, 0.38729833, 0.38729833, 0.38729833, 0.38729833,
+      0.38729833, 0.38729833, 0.38729833, 0.38729833, 0.38729833, 0.38729833,
+      0.38729833, 0.38729833, 0.38729833, 0.38729833, 0.38729833, 0.38729833,
+      0.38729833, 0.4,        0.41231056, 0.41231056, 0.41231056, 0.42426407,
+      0.42426407, 0.42426407, 0.42426407, 0.42426407, 0.42426407, 0.42426407,
+      0.42426407, 0.42426407, 0.42426407, 0.43588989, 0.43588989, 0.43588989,
+      0.43588989, 0.43588989, 0.43588989, 0.4472136,  0.45825757, 0.45825757,
+      0.45825757, 0.45825757, 0.45825757, 0.46904158, 0.46904158, 0.46904158,
+      0.46904158, 0.47958315, 0.47958315, 0.47958315, 0.48989795, 0.5,
+      0.5,        0.5,        0.50990195, 0.50990195, 0.50990195, 0.51961524,
+      0.51961524, 0.51961524, 0.53851648, 0.53851648, 0.53851648, 0.53851648,
+      0.54772256, 0.55677644, 0.58309519, 0.58309519, 0.60827625, 0.60827625,
+      0.6164414,  0.6244998,  0.6244998,  0.64031242, 0.64031242, 0.64807407,
+      0.65574385, 0.7,        0.7,        0.7,        0.70710678, 0.70710678,
+      0.72111026, 0.72111026, 0.78740079, 0.79372539, 0.80622577, 0.81853528,
+      0.88317609, 0.96436508, 1.0198039,  1.02469508, 1.64012195},
+     {1}},
+
+    // Digits
+    {1797,
+     150,
+     {0,    305,  434,  434, 434, 396, 396,  396,  79,   464,  79,   396,  79,
+      396,  512,  79,   434, 229, 396, 441,  434,  229,  79,   512,  305,  229,
+      305,  229,  166,  252, 79,  0,   0,    79,   0,    0,    434,  229,  0,
+      0,    305,  0,    79,  79,  166, 79,   0,    0,    0,    229,  79,   252,
+      79,   79,   0,    252, 79,  0,   252,  79,   202,  126,  126,  305,  0,
+      166,  130,  79,   0,   166, 0,   79,   126,  0,    130,  0,    0,    126,
+      0,    160,  79,   0,   276, 48,  0,    160,  126,  0,    229,  0,    79,
+      126,  126,  20,   305, 79,  79,  48,   79,   79,   79,   36,   36,   276,
+      36,   79,   0,    36,  79,  79,  0,    79,   49,   130,  160,  0,    20,
+      79,   20,   79,   0,   48,  20,  79,   276,  79,   0,    48,   0,    130,
+      20,   0,    36,   0,   20,  0,   0,    49,   48,   48,   0,    0,    48,
+      0,    49,   0,    166, 20,  36,  10,   72,   20,   79,   0,    20,   36,
+      0,    0,    48,   0,   0,   36,  0,    594,  1507, 1282, 455,  1446, 455,
+      1444, 1282, 1444, 944, 455, 425, 425,  1282, 425,  425,  425,  425,  455,
+      425,  425,  635,  455, 425, 39,  425,  39,   1424, 708,  316,  339,  259,
+      867,  339,  259,  259, 345, 316, 345,  259,  259,  259,  279,  13,   13,
+      279,  316,  13,   259, 13,  259, 13,   13,   279,  13,   279,  13,   13,
+      259,  13,   318,  13,  193, 259, 345,  13,   259,  259,  13,   13,   139,
+      13,   285,  279,  269, 425, 259, 259,  13,   259,  635,  39,   259,  279,
+      259,  359,  3,    269, 13,  13,  425,  3,    13,   425,  285,  13,   39,
+      139,  189,  13,   39,  285, 13,  13,   279,  139,  13,   425,  339,  13,
+      139,  3,    13,   39,  279, 39,  1454, 1461, 562,  938,  938,  1535, 562,
+      562,  562,  562,  562, 549, 562, 1075, 1568, 117,  117,  117,  117,  117,
+      330,  281,  281,  281, 330, 117, 13,   117,  39,   3,    13,   13,   318,
+      301,  117,  281,  175, 3,   425, 60,   45,   139,  39,   281,  405,  879,
+      945,  148,  1327, 242, 257, 326, 1050, 1237, 1050, 1050, 1050, 1050, 326,
+      326,  326,  875,  326, 326, 326, 777,  326,  326,  326,  777,  326,  326,
+      326,  349,  777,  326, 326, 349, 326,  326,  777,  326,  326,  326,  349,
+      349,  257,  349,  257, 257, 326, 257,  99,   99,   326,  257,  326,  257,
+      257,  257,  349,  99,  99,  242, 257,  647,  349,  99,   346,  326,  242,
+      1,    298,  99,   13,  285, 405, 279,  139,  285,  242,  117,  148,  165,
+      148,  358,  654,  358, 3,   3,   298,  281,  117,  281,  549,  117,  39,
+      139,  148,  1688, 187, 132, 181, 372,  1017, 463,  501,  501,  501,  463,
+      463,  463,  463,  181, 463, 372, 310,  181,  310,  463,  372,  181,  310,
+      181,  132,  181,  372, 463, 132, 181,  463,  258,  388,  388,  132,  132,
+      132,  463,  388,  132, 408, 388, 408,  132,  84,   84,   181,  437,  132,
+      388,  181,  408,  181, 180, 22,  22,   132,  388,  84,   132,  84,   117,
+      259,  285,  117,  180, 405, 180, 139,  39,   293,  3,    148,  1295, 13,
+      117,  162,  1295, 148, 654, 135, 39,   148,  293,  101,  358,  139,  657,
+      1647, 6,    58,   65,  195, 65,  360,  360,  262,  262,  262,  262,  262,
+      262,  262,  262,  262, 262, 262, 262,  65,   65,   146,  65,   262,  262,
+      232,  65,   65,   146, 234, 234, 234,  232,  234,  65,   65,   234,  65,
+      262,  65,   234,  322, 65,  196, 262,  196,  146,  234,  234,  136,  65,
+      65,   234,  232,  146, 195, 196, 65,   65,   65,   136,  146,  196,  65,
+      196,  232,  234,  65,  234, 146, 197,  58,   136,  58,   65,   136,  262,
+      58,   197,  58,   65,  262, 65,  136,  164,  58,   65,   146,  136,  88,
+      65,   65,   65,   65,  58,  146, 65,   58,   164,  146,  164,  146,  234,
+      58,   6,    34,   58,  146, 58,  58,   6,    6,    65,   164,  6,    146,
+      136,  34,   146,  6,   34,  34,  6,    146,  146,  6,    197,  146,  146,
+      65,   34,   234,  34,  34,  197, 164,  6,    6,    6,    262,  164,  34,
+      6,    65,   13,   65,  180, 705, 3,    20,   55,   242,  242,  180,  39,
+      122,  654,  13,   122, 59,  117, 405,  181,  189,  705,  6,    139,  132,
+      330,  288,  388,  114, 40,  59,  39,   13,   117,  39,   15,   22,   293,
+      39,   99,   6,    128, 248, 279, 40,   84,   59,   22,   67,   1,    146,
+      102,  339,  1,    257, 99,  84,  22,   84,   388,  6,    40,   122,  40,
+      45,   372,  48,   264, 148, 148, 13,   148,  264,  93,   1168, 21,   21,
+      21,   21,   21,   21,  11,  11,  102,  437,  40,   39,   310,  281,  32,
+      169,  169,  437,  285, 358, 13,  541,  117,  148,  11,   128,  40,   281,
+      39,   358,  135,  388, 549, 440, 388,  40,   298,  3,    15,   30,   39,
+      281,  11,   3,    189, 373, 102, 259,  264,  13,   21,   39,   195,  40,
+      15,   3,    117,  1,   11,  148, 138,  32,   114,  114,  15,   13,   13,
+      34,   180,  148,  34,  148, 269, 1647, 790,  41,   124,  353,  1161, 1387,
+      353,  353,  124,  353, 124, 367, 817,  1483, 124,  320,  124,  1483, 124,
+      1439, 41,   817,  41,  41,  817, 124,  41,   124,  41,   124,  41,   297,
+      41,   124,  580,  124, 353, 817, 580,  297,  41,   41,   41,   124,  270,
+      297,  450,  270,  353, 353, 450, 41,   41,   64,   41,   41,   124,  540,
+      64,   450,  41,   97,  540, 450, 41,   97,   297,  14,   540,  260,  297,
+      270,  64,   124,  377, 260, 450, 111,  97,   111,  41,   410,  14,   14,
+      111,  111,  520,  817, 22,  657, 138,  22,   39,   102,  635,  264,  260,
+      40,   132,  40,   128, 14,  6,   64,   114,  148,  21,   15,   146,  123,
+      285,  32,   441,  164, 169, 109, 1,    264,  301,  148,  6,    408,  3,
+      541,  102,  124,  25,  297, 25,  22,   104,  410,  34,   148,  21,   22,
+      1,    93,   3,    293, 330, 410, 279,  455,  181,  76,   405,  15,   142,
+      3,    104,  15,   1,   40,  39,  123,  281,  76,   39,   1,    269,  410,
+      15,   64,   199,  39,  358, 264, 3,    32,   15,   11,   59,   199,  264,
+      280,  40,   13,   32,  180, 32,  152,  13,   102,  242,  122,  146,  149,
+      39,   15,   11,   13,  14,  22,  92,   84,   25,   242,  293,  440,  14,
+      114,  40,   64,   11,  129, 261, 45,   21,   1189, 388,  199,  22,   11,
+      41,   20,   13,   148, 34,  251, 64,   114,  388,  139,  297,  260,  199,
+      76,   92,   15,   132, 139, 102, 64,   40,   152,  41,   102,  410,  39,
+      180,  32,   287,  1,   11,  257, 220,  301,  0,    11,   40,   324,  84,
+      68,   436,  146,  13,  111, 21,  97,   189,  297,  64,   388,  26,   132,
+      32,   32,   281,  21,  76,  109, 76,   293,  128,  138,  45,   15,   76,
+      102,  128,  305,  73,  32,  129, 123,  32,   3,    111,  138,  99,   330,
+      39,   3,    102,  152, 358, 73,  287,  400,  76,   388,  32,   6,    13,
+      11,   84,   152,  25,  117, 272, 40,   11,   180,  40,   296,  25,   14,
+      84,   220,  289,  6,   163, 3,   398,  373,  324,  117,  353,  258,  13,
+      40,   269,  264,  280, 128, 40,  59,   281,  281,  40,   264,  105,  84,
+      11,   293,  22,   105, 146, 117, 15,   1,    11,   76,   8,    40,   883,
+      1649, 81,   273,  597, 624, 597, 983,  94,   94,   94,   94,   273,  273,
+      94,   273,  94,   94,  94,  81,  81,   94,   81,   81,   81,   174,  273,
+      94,   559,  94,   94,  81,  273, 94,   81,   94,   94,   94,   222,  273,
+      81,   174,  174,  81,  81,  81,  94,   174,  273,  81,   94,   94,   94,
+      81,   81,   174,  94,  81,  81,  174,  182,  94,   174,  174,  81,   174,
+      44,   94,   81,   182, 81,  94,  174,  44,   81,   108,  44,   94,   44,
+      94,   81,   173,  182, 81,  81,  94,   44,   273,  337,  94,   174,  81,
+      273,  94,   94,   17,  94,  112, 81,   174,  94,   94,   44,   157,  44,
+      137,  52,   44,   94,  44,  157, 157,  44,   44,   337,  52,   174,  17,
+      300,  17,   52,   174, 22,  56,  14,   129,  189,  3,    3,    199,  76,
+      52,   443,  99,   11,  152, 148, 295,  583,  76,   254,  264,  84,   257,
+      3,    52,   324,  92,  15,  6,   154,  35,   64,   1,    25,   4,    232,
+      117,  40,   180,  99,  11,  40,  76,   64,   13,   3,    42,   264,  71,
+      43,   264,  84,   289, 40,  181, 137,  461,  22,   93,   32,   11,   102,
+      324,  15,   44,   15,  8,   174, 181,  44,   32,   10,   142,  47,   12,
+      25,   7,    274,  148, 25,  73,  22,   25,   148,  25,   43,   251,  29,
+      15,   41,   99,   15,  40,  417, 8,    94,   68,   114,  4,    309,  85,
+      93,   23,   13,   154, 337, 36,  4,    384,  148,  17,   81,   18,   91,
+      15,   257,  152,  84,  15,  236, 95,   545,  84,   570,  521,  22,   232,
+      258,  14,   40,   264, 180, 25,  293,  152,  11,   104,  84,   309,  8,
+      59,   40,   199,  14,  8,   18,  14,   18,   251,  102,  12,   45,   39,
+      114,  94,   94,   64,  29,  483, 128,  18,   21,   40,   6,    43,   11,
+      76,   70,   251,  281, 111, 5,   40,   4,    4,    384,  461,  21,   28,
+      459,  18,   7,    6,   141, 13,  23,   146,  52,   8,    104,  220,  48,
+      6,    147,  68,   52,  309, 148, 151,  21,   8,    40,   15,   11,   99,
+      17,   114,  12,   264, 8,   359, 101,  264,  147,  251,  293,  4,    180,
+      123,  293,  76,   154, 135, 353, 325,  105,  102,  114,  119,  526,  264,
+      325,  138,  59,   325, 359, 113, 59,   533,  116,  13,   69,   123,  325,
+      248,  35,   70,   59,  84,  309, 152,  45,   152,  86,   289,  40,   135,
+      15,   76,   3,    84,  7,   32,  157,  190,  69,   14,   325,  289,  84,
+      15,   117,  261,  18,  128, 116, 40,   254,  74,   173,  3,    74,   21,
+      8,    18,   288,  18,  8,   174, 33,   0,    1,    15,   11,   366,  23,
+      378,  358,  5,    28,  69,  5,   40,   11,   417,  18,   121,  4,    40,
+      88,   69,   52,   388, 518, 154, 289,  40,   157,  113,  2,    260,  8,
+      157,  116,  2,    12,  184, 482, 147,  113,  518,  1,    56,   17,   5,
+      384,  398,  39,   12,  518, 68,  88,   325,  461,  324,  76,   29,   11,
+      461,  11,   43,   144, 519, 12,  392,  76,   19,   74,   8,    275,  415,
+      121,  18,   375,  56,  10,  11,  6,    84,   25,   15,   174,  205,  87,
+      102,  37,   353,  8,   23,  375, 325,  116,  33,   125,  199,  18,   62,
+      527,  177,  18,   264, 325, 125, 380,  349,  148,  32,   69,   131,  82,
+      69,   2,    7,    3,   151, 527, 8,    325,  83,   74,   398,  184,  47,
+      24,   49,   43,   180, 157, 131, 184,  19,   8,    74,   375,  18,   190,
+      131,  5,    76,   4,   2,   76,  2,    25,   2,    2,    38,   23,   2,
+      12,   151,  325,  2,   86,  349, 156,  236,  477,  131,  39,   135,  131,
+      400,  11,   518,  40,  18,  2,   2,    69,   157,  156,  27,   325,  18,
+      121,  18,   117,  317, 101, 38,  353,  56,   69,   157,  131,  131,  265,
+      27,   4,    131,  516, 62,  8,   167,  135,  2,    121,  89,   31,   87,
+      210,  51,   2,    2,   442, 131, 251,  375,  27,   11,   24,   12,   184,
+      3,    4,    69,   37,  303, 317, 375,  16,   155,  27,   2,    38,   2,
+      157,  375},
+     {305,  434,  1039, 1463, 396,  464,  1541, 79,   441,  512,  1677, 1336,
+      682,  642,  812,  229,  925,  1697, 1545, 877,  1494, 1365, 1464, 1663,
+      806,  252,  1029, 166,  935,  1579, 406,  725,  1002, 266,  957,  276,
+      1099, 694,  130,  516,  1415, 311,  1451, 1667, 1563, 1153, 1157, 335,
+      328,  1620, 202,  1335, 382,  435,  458,  747,  1425, 334,  1388, 1516,
+      126,  1703, 160,  552,  1128, 546,  1307, 1445, 1342, 772,  1359, 178,
+      848,  646,  1065, 1167, 855,  1642, 422,  718,  1082, 941,  48,   915,
+      676,  724,  1555, 1739, 786,  256,  1470, 140,  20,   36,   974,  1059,
+      49,   304,  1746, 1487, 386,  666,  416,  526,  1793, 1493, 536,  831,
+      565,  1317, 1236, 1715, 1105, 564,  1745, 695,  10,   465,  185,  487,
+      571,  1435, 55,   981,  1297, 1687, 1716, 1106, 286,  594,  72,   30,
+      208,  1193, 179,  1206, 1212, 150,  357,  1366, 1177, 796,  1598, 776,
+      1049, 656,  595,  854,  1413, 902,  101,  1323, 78,   292,  588,  1258,
+      825,  980,  1768, 1187, 1229, 1722, 1235, 1507, 1282, 455,  1446, 1444,
+      1740, 1696, 1698, 944,  635,  425,  1686, 1676, 1452, 1736, 1188, 1792,
+      881,  1360, 785,  1318, 139,  936,  39,   285,  514,  1424, 708,  316,
+      339,  259,  867,  345,  859,  1498, 799,  1246, 13,   1478, 1518, 319,
+      279,  359,  1504, 175,  1370, 706,  219,  1428, 193,  1160, 385,  1639,
+      318,  63,   789,  709,  1074, 1438, 1644, 1090, 1346, 865,  961,  1460,
+      1170, 269,  431,  1376, 301,  1324, 62,   1027, 1110, 1347, 1534, 347,
+      928,  1300, 1474, 815,  1706, 469,  1032, 3,    1513, 1475, 1385, 59,
+      1624, 924,  1477, 1087, 1759, 1379, 189,  589,  405,  705,  1240, 1392,
+      993,  89,   1566, 1042, 1616, 60,   1196, 1390, 143,  159,  874,  879,
+      1484, 1116, 1454, 1461, 562,  938,  1535, 1448, 1075, 587,  1420, 1003,
+      1517, 549,  973,  330,  1568, 117,  885,  162,  201,  165,  1614, 281,
+      1447, 625,  1430, 358,  692,  1770, 822,  395,  1418, 213,  1052, 1378,
+      1332, 503,  1450, 749,  45,   849,  1255, 1089, 1226, 904,  288,  478,
+      945,  148,  1327, 242,  257,  326,  1050, 1237, 1634, 1097, 1386, 1334,
+      1621, 1076, 875,  1613, 777,  1112, 1134, 1357, 1329, 1120, 1247, 869,
+      1213, 349,  1250, 1394, 1380, 1377, 1107, 1590, 1640, 1227, 1199, 355,
+      1546, 797,  866,  1585, 1648, 823,  1631, 346,  1714, 1760, 99,   657,
+      1126, 1040, 647,  739,  1757, 1071, 861,  1626, 298,  667,  1325, 1678,
+      1766, 1372, 1556, 702,  1,    1409, 787,  1688, 716,  1290, 293,  415,
+      999,  169,  1194, 1774, 1144, 654,  809,  248,  976,  1026, 1769, 449,
+      962,  1737, 365,  1550, 910,  1018, 135,  149,  167,  1295, 187,  132,
+      181,  372,  1017, 463,  501,  1718, 1417, 1140, 1782, 1490, 833,  1466,
+      310,  986,  1437, 1669, 826,  1031, 470,  1528, 1159, 927,  331,  268,
+      1600, 1492, 1780, 1211, 258,  388,  631,  959,  1111, 180,  499,  788,
+      1531, 408,  907,  1472, 437,  1469, 84,   214,  1625, 22,   1362, 778,
+      1084, 1744, 1465, 340,  1214, 1169, 1594, 307,  1371, 313,  830,  1721,
+      896,  448,  1520, 1101, 1208, 942,  762,  199,  1306, 1276, 1310, 183,
+      1315, 91,   679,  102,  1286, 168,  264,  763,  807,  943,  1423, 824,
+      1292, 1356, 1647, 6,    58,   65,   195,  146,  360,  1005, 262,  1773,
+      1519, 272,  741,  711,  1482, 1480, 939,  1421, 1133, 672,  969,  1261,
+      323,  232,  322,  234,  882,  967,  351,  290,  1354, 1503, 1510, 344,
+      1683, 984,  1222, 1223, 1007, 841,  1055, 1521, 1441, 652,  196,  197,
+      931,  136,  490,  1431, 321,  1045, 1733, 871,  968,  1449, 1610, 834,
+      921,  620,  468,  1191, 542,  1239, 282,  712,  164,  1497, 1122, 522,
+      728,  1345, 1725, 611,  1163, 1224, 1093, 1481, 911,  188,  858,  88,
+      1063, 532,  989,  1701, 662,  156,  1263, 453,  1035, 1577, 34,   1252,
+      1183, 1094, 66,   451,  1245, 582,  680,  1352, 713,  1215, 1473, 1693,
+      1749, 338,  1173, 996,  212,  550,  82,   1673, 1092, 704,  1762, 802,
+      960,  1623, 1321, 1755, 1369, 1601, 223,  474,  1636, 1608, 392,  412,
+      1353, 752,  880,  314,  1382, 1303, 452,  810,  750,  1609, 26,   583,
+      67,   1629, 1085, 1115, 1756, 362,  892,  1350, 315,  1615, 209,  846,
+      122,  759,  1020, 40,   1453, 98,   114,  835,  376,  505,  668,  729,
+      1086, 104,  287,  333,  551,  1054, 1016, 1363, 138,  821,  1543, 1630,
+      15,   128,  176,  369,  541,  920,  1564, 1771, 845,  1030, 1125, 1383,
+      306,  83,   207,  1734, 93,   864,  109,  614,  726,  753,  1083, 1427,
+      593,  798,  979,  1109, 1069, 129,  255,  908,  953,  1287, 515,  768,
+      923,  1217, 426,  955,  1168, 21,   56,   210,  186,  476,  11,   1343,
+      428,  456,  1312, 1402, 1596, 868,  1530, 32,   460,  971,  975,  977,
+      1262, 618,  389,  636,  230,  615,  493,  644,  836,  1532, 1434, 1672,
+      163,  440,  940,  1051, 1102, 1340, 1723, 918,  1034, 1205, 1249, 373,
+      407,  1058, 1506, 937,  1333, 446,  978,  1220, 1436, 1704, 622,  1401,
+      71,   475,  801,  471,  47,   424,  913,  1319, 1410, 509,  850,  1130,
+      1260, 1561, 658,  674,  444,  544,  649,  790,  41,   124,  353,  1161,
+      1387, 1244, 1502, 1584, 367,  817,  1254, 1483, 1539, 1515, 320,  1661,
+      1791, 1439, 1127, 1536, 297,  1525, 1257, 1651, 840,  580,  1549, 1559,
+      1456, 1691, 1148, 886,  380,  260,  1512, 1181, 1788, 450,  1429, 1681,
+      270,  97,   1053, 1268, 377,  1267, 844,  1638, 1764, 1171, 540,  1225,
+      64,   1278, 887,  1641, 1137, 613,  1198, 733,  1011, 497,  1479, 410,
+      14,   454,  627,  909,  520,  1023, 1355, 1526, 863,  111,  800,  356,
+      557,  280,  486,  1114, 343,  483,  427,  1731, 1124, 1091, 616,  900,
+      570,  736,  818,  1547, 1006, 1320, 934,  1028, 1567, 123,  142,  404,
+      445,  919,  1131, 1777, 76,   370,  433,  1192, 1393, 1790, 641,  488,
+      617,  842,  930,  237,  466,  529,  619,  686,  1645, 1783, 484,  531,
+      25,   1151, 246,  897,  1266, 152,  581,  660,  1293, 332,  387,  1014,
+      1298, 1599, 744,  816,  1713, 400,  990,  1316, 278,  383,  417,  1396,
+      1679, 1758, 598,  893,  1158, 1284, 1488, 1709, 261,  699,  1010, 397,
+      669,  714,  1061, 1351, 220,  1772, 1524, 309,  399,  1189, 35,   90,
+      153,  254,  1433, 324,  352,  1548, 302,  761,  1190, 1207, 1658, 1682,
+      277,  336,  1313, 1786, 92,   1322, 42,   1219, 507,  1041, 233,  243,
+      245,  883,  1406, 1403, 1767, 296,  1185, 366,  496,  1279, 1787, 190,
+      485,  1358, 443,  251,  461,  479,  100,  1591, 23,   773,  16,   459,
+      1328, 170,  436,  1132, 1411, 1607, 423,  775,  895,  1277, 371,  914,
+      1231, 1408, 158,  1232, 68,   495,  650,  73,   697,  1700, 295,  85,
+      200,  693,  1230, 1349, 1592, 227,  249,  640,  917,  1138, 1724, 481,
+      839,  1281, 1505, 154,  1180, 1374, 1398, 398,  604,  1272, 1702, 1738,
+      289,  1367, 684,  878,  1720, 1326, 585,  1794, 735,  781,  742,  748,
+      901,  1025, 203,  411,  1178, 244,  548,  477,  946,  1747, 363,  521,
+      553,  1248, 419,  1751, 1784, 105,  519,  743,  760,  956,  1699, 1732,
+      1750, 70,   184,  1081, 1129, 1182, 1361, 1606, 80,   648,  1414, 1455,
+      755,  1033, 1270, 1285, 1136, 95,   1560, 950,  591,  1021, 603,  791,
+      873,  629,  1558, 1763, 659,  1443, 1652, 805,  1117, 1146, 1486, 1489,
+      8,    814,  1176, 1499, 141,  535,  573,  965,  1375, 1578, 811,  1752,
+      221,  274,  513,  1619, 1649, 81,   273,  597,  624,  983,  764,  94,
+      610,  1761, 820,  1501, 559,  299,  793,  1201, 1719, 1458, 1046, 112,
+      1674, 174,  1209, 634,  1399, 1476, 1775, 1381, 222,  888,  1509, 698,
+      182,  368,  653,  783,  1013, 1036, 1174, 1622, 533,  1422, 308,  602,
+      1368, 1694, 837,  1304, 1164, 560,  337,  1019, 1339, 44,   1711, 300,
+      342,  1269, 236,  577,  1785, 137,  932,  707,  1251, 1527, 118,  803,
+      894,  870,  108,  350,  1442, 568,  727,  374,  1238, 1330, 1586, 1496,
+      173,  543,  157,  1405, 1684, 857,  1314, 1331, 995,  147,  1009, 17,
+      1243, 948,  884,  1459, 1056, 1653, 52,   1533, 1073, 1395, 1218, 819,
+      1294, 240,  1779, 1348, 1139, 862,  1373, 628,  1108, 1135, 963,  740,
+      1432, 61,   1523, 1121, 43,   949,  1689, 683,  1012, 731,  1216, 354,
+      1670, 1795, 1175, 663,  1309, 225,  172,  205,  933,  545,  1203, 1305,
+      1544, 722,  1654, 745,  737,  1184, 1419, 1646, 1659, 106,  228,  401,
+      4,    303,  1228, 1778, 782,  271,  508,  723,  856,  177,  534,  804,
+      1221, 217,  378,  719,  997,  651,  384,  1537, 730,  1162, 1253, 1273,
+      216,  537,  12,   144,  1302, 107,  1776, 584,  145,  1200, 1650, 1705,
+      1072, 1179, 7,    391,  701,  1241, 1416, 567,  1147, 263,  547,  1637,
+      1656, 29,   566,  661,  379,  671,  754,  1166, 119,  1044, 121,  171,
+      1643, 18,   621,  1123, 954,  110,  206,  1291, 1529, 239,  250,  691,
+      192,  390,  912,  1573, 473,  1542, 402,  687,  746,  1280, 1605, 33,
+      688,  721,  1717, 847,  1570, 1668, 1096, 889,  1143, 590,  113,  420,
+      539,  970,  1047, 1538, 528,  681,  829,  696,  247,  574,  853,  500,
+      1015, 1632, 1726, 1066, 1708, 28,   96,   929,  1603, 491,  1172, 1142,
+      1004, 418,  852,  1753, 922,  1397, 5,    626,  795,  1602, 890,  1789,
+      563,  710,  151,  1210, 1553, 608,  1098, 1692, 161,  1583, 1754, 24,
+      325,  991,  1457, 462,  555,  1233, 1265, 734,  738,  133,  226,  1391,
+      317,  224,  780,  1068, 1077, 1569, 1748, 134,  283,  439,  903,  1508,
+      131,  294,  1743, 1582, 267,  1256, 86,   630,  518,  607,  1156, 561,
+      843,  579,  364,  525,  1511, 1735, 872,  612,  1491, 284,  510,  204,
+      767,  1633, 409,  717,  700,  964,  1412, 482,  438,  899,  1588, 504,
+      576,  116,  125,  69,   703,  838,  329,  556,  375,  394,  74,   194,
+      1155, 241,  898,  1234, 992,  1655, 1118, 1404, 1680, 155,  1064, 1141,
+      19,   851,  1079, 1407, 211,  489,  361,  1043, 472,  1440, 600,  1062,
+      1259, 457,  1664, 511,  605,  1730, 414,  1617, 1710, 779,  1060, 1426,
+      1796, 38,   1612, 1666, 253,  1467, 432,  1283, 1242, 1662, 235,  876,
+      231,  575,  1741, 120,  53,   275,  1038, 1675, 312,  1296, 127,  530,
+      1384, 1781, 784,  1145, 758,  916,  1104, 238,  291,  664,  1604, 2,
+      524,  1095, 1103, 1587, 1289, 554,  1008, 832,  1048, 828,  860,  1299,
+      1204, 1500, 1728, 37,   1468, 538,  1540, 632,  1344, 87,   596,  480,
+      527,  637,  769,  951,  670,  982,  218,  348,  198,  813,  1565, 678,
+      1037, 31,   720,  1695, 1665, 578,  770,  1080, 765,  774,  492,  794,
+      606,  827,  1389, 1575, 430,  1557, 327,  506,  952,  1301, 1067, 1337,
+      381,  429,  569,  808,  265,  1186, 103,  1618, 958,  1554, 1197, 1165,
+      393,  1100, 1070, 601,  905,  633,  1628, 1485, 586,  523,  643,  1275,
+      1729, 677,  517,  1057, 403,  1341, 1765, 994,  906,  1288, 966,  1078,
+      27,   1271, 191,  771,  987,  1119, 1150, 1690, 655,  1712, 1742, 1471,
+      9,    1707, 1001, 341,  1581, 57,   46,   638,  645,  1088, 891,  50,
+      442,  685,  498,  592,  690,  609,  572,  1635, 599,  1462, 421,  766,
+      1522, 756,  1308, 1400, 1685, 1202, 639,  115,  1552, 1657, 558,  665,
+      413,  1727, 1022, 1195, 1576, 494,  792,  1571, 988,  715,  1611, 1627,
+      675,  1514, 1580, 732,  1311, 1574, 1593, 1364, 1154, 985,  1589, 51,
+      757,  1338, 1152, 1264, 751,  1597, 54,   502,  972,  1495, 1024, 467,
+      689,  215,  998,  1000, 926,  947,  1671, 1660, 1149, 623,  447,  1562,
+      1551, 1274, 673,  75,   1113, 77,   1595, 1572},
+
+     {18.46618531, 18.16590212, 17.20465053, 17.20465053, 17.40689519,
+      17.40689519, 17.40689519, 17.49285568, 17.54992877, 17.60681686,
+      17.60681686, 17.69180601, 17.8605711,  17.88854382, 17.88854382,
+      17.94435844, 17.94435844, 18.02775638, 18.05547009, 18.08314132,
+      18.08314132, 18.16590212, 18.16590212, 18.1934054,  18.22086716,
+      18.35755975, 18.38477631, 18.46618531, 18.49324201, 18.60107524,
+      18.62793601, 18.68154169, 18.78829423, 18.89444363, 18.89444363,
+      18.92088793, 18.92088793, 19.,         19.07878403, 19.07878403,
+      19.07878403, 19.10497317, 19.10497317, 19.10497317, 19.33907961,
+      19.36491673, 19.41648784, 19.5192213,  19.57038579, 19.57038579,
+      19.59591794, 19.62141687, 19.74841766, 19.77371993, 19.87460691,
+      19.87460691, 19.87460691, 20.0748599,  20.1246118,  20.1246118,
+      20.174241,   20.174241,   20.22374842, 20.22374842, 20.24845673,
+      20.27313493, 20.29778313, 20.29778313, 20.32240143, 20.4450483,
+      20.46948949, 20.51828453, 20.54263858, 20.63976744, 20.63976744,
+      20.68816087, 20.71231518, 20.76053949, 20.78460969, 20.80865205,
+      20.88061302, 20.92844954, 20.95232684, 20.95232684, 20.97617696,
+      20.97617696, 21.07130751, 21.16601049, 21.23676058, 21.26029163,
+      21.26029163, 21.33072901, 21.54065923, 21.54065923, 21.54065923,
+      21.54065923, 21.63330765, 21.70253441, 21.70253441, 21.77154106,
+      21.81742423, 21.84032967, 22.,         22.02271555, 22.06807649,
+      22.11334439, 22.15851981, 22.15851981, 22.20360331, 22.20360331,
+      22.27105745, 22.27105745, 22.3159136,  22.3383079,  22.3383079,
+      22.44994432, 22.60530911, 22.69361144, 22.71563338, 22.737634,
+      22.737634,   22.75961335, 22.89104628, 23.02172887, 23.10844002,
+      23.10844002, 23.10844002, 23.17326045, 23.23790008, 23.2594067,
+      23.28089345, 23.34523506, 23.40939982, 23.40939982, 23.53720459,
+      23.62202362, 23.64318084, 23.70653918, 23.70653918, 23.8117618,
+      24.,         24.06241883, 24.16609195, 24.35159132, 24.35159132,
+      24.41311123, 24.49489743, 24.49489743, 24.71841419, 24.73863375,
+      24.81934729, 25.03996805, 25.07987241, 25.07987241, 25.25866188,
+      25.3179778,  25.51470164, 25.53429067, 25.57342371, 25.61249695,
+      25.69046516, 25.70992026, 25.8069758,  26.05762844, 22.53885534,
+      22.38302929, 22.24859546, 22.24859546, 22.24859546, 22.3383079,
+      22.58317958, 22.737634,   22.82542442, 22.93468988, 22.97825059,
+      23.13006701, 23.17326045, 23.28089345, 23.32380758, 23.4520788,
+      23.47338919, 23.49468025, 23.64318084, 23.85372088, 23.89560629,
+      24.06241883, 24.08318916, 24.08318916, 24.12467616, 24.18677324,
+      24.18677324, 22.42766149, 22.13594362, 21.88606863, 21.86321111,
+      21.28379665, 21.9317122,  21.9544984,  22.09072203, 22.09072203,
+      22.24859546, 22.24859546, 22.4053565,  22.44994432, 22.47220505,
+      22.58317958, 22.58317958, 22.82542442, 22.89104628, 23.02172887,
+      23.06512519, 23.06512519, 23.15167381, 23.21637353, 23.32380758,
+      23.49468025, 23.51595203, 23.55843798, 23.55843798, 23.57965225,
+      23.76972865, 23.76972865, 23.76972865, 23.79075451, 23.8117618,
+      23.83275058, 23.85372088, 23.85372088, 23.91652149, 23.93741841,
+      23.97915762, 24.,         24.18677324, 24.24871131, 24.2899156,
+      24.2899156,  24.35159132, 24.35159132, 24.35159132, 24.37211521,
+      24.37211521, 24.39262184, 24.41311123, 24.45403852, 24.45403852,
+      24.4744765,  24.4744765,  24.55605832, 24.55605832, 24.57641145,
+      24.59674775, 24.61706725, 24.61706725, 24.63736999, 24.67792536,
+      24.69817807, 24.75883681, 24.79919354, 24.81934729, 24.8394847,
+      24.85960579, 24.8997992,  24.8997992,  24.8997992,  24.91987159,
+      24.97999199, 24.97999199, 25.03996805, 25.07987241, 25.0998008,
+      25.11971337, 25.11971337, 25.13961018, 25.15949125, 25.17935662,
+      25.17935662, 25.17935662, 25.19920634, 25.19920634, 25.19920634,
+      23.93741841, 23.85372088, 23.57965225, 23.66431913, 23.72762104,
+      23.87467277, 23.87467277, 24.,         24.10394159, 24.16609195,
+      24.41311123, 24.49489743, 24.65765601, 24.65765601, 23.19482701,
+      24.4744765,  24.4744765,  24.59674775, 24.59674775, 24.67792536,
+      24.75883681, 24.81934729, 25.01999201, 25.03996805, 25.17935662,
+      25.19920634, 25.21904043, 25.23885893, 25.23885893, 25.29822128,
+      25.3179778,  25.33771892, 25.35744467, 25.3968502,  25.43619468,
+      25.45584412, 25.49509757, 25.49509757, 25.49509757, 25.51470164,
+      25.51470164, 25.55386468, 25.61249695, 25.65151068, 25.65151068,
+      25.65151068, 25.15949125, 24.06241883, 23.89560629, 21.72556098,
+      17.88854382, 17.,         16.76305461, 17.29161647, 17.34935157,
+      17.8325545,  17.88854382, 18.02775638, 18.13835715, 18.43908891,
+      18.49324201, 18.49324201, 18.49324201, 19.05255888, 19.23538406,
+      19.31320792, 19.31320792, 19.62141687, 19.62141687, 19.6977156,
+      19.6977156,  19.74841766, 19.94993734, 19.97498436, 20.174241,
+      20.24845673, 20.61552813, 20.63976744, 20.90454496, 21.,
+      21.02379604, 21.09502311, 21.11871208, 21.14237451, 21.33072901,
+      21.72556098, 21.79449472, 22.02271555, 22.15851981, 22.69361144,
+      23.02172887, 23.13006701, 23.13006701, 23.17326045, 23.19482701,
+      23.43074903, 23.47338919, 23.72762104, 23.83275058, 24.08318916,
+      24.4744765,  24.65765601, 24.67792536, 24.67792536, 24.67792536,
+      24.69817807, 24.85960579, 24.87971061, 25.,         25.05992817,
+      25.13961018, 25.25866188, 25.43619468, 25.65151068, 25.67099531,
+      25.67099531, 25.67099531, 25.69046516, 25.70992026, 25.72936066,
+      25.74878638, 25.76819745, 25.76819745, 25.78759392, 25.78759392,
+      25.78759392, 25.8069758,  25.82634314, 25.82634314, 25.82634314,
+      25.84569597, 25.84569597, 25.88435821, 25.88435821, 25.90366769,
+      25.90366769, 25.90366769, 25.92296279, 25.94224354, 25.94224354,
+      23.66431913, 22.627417,   22.627417,   22.58317958, 22.22611077,
+      21.56385865, 21.74856317, 21.84032967, 22.29349681, 22.36067977,
+      22.627417,   22.64950331, 22.95648057, 23.06512519, 23.08679276,
+      23.08679276, 23.51595203, 23.51595203, 23.57965225, 23.62202362,
+      23.64318084, 23.89560629, 24.08318916, 24.18677324, 24.20743687,
+      24.22808288, 24.22808288, 24.31049156, 24.33105012, 24.37211521,
+      24.39262184, 24.41311123, 24.51530134, 24.63736999, 24.69817807,
+      24.75883681, 24.81934729, 24.85960579, 24.8997992,  24.8997992,
+      24.91987159, 24.91987159, 24.95996795, 24.95996795, 24.95996795,
+      25.01999201, 25.01999201, 25.07987241, 25.13961018, 25.13961018,
+      25.15949125, 25.17935662, 25.3179778,  25.35744467, 25.41653005,
+      25.45584412, 25.65151068, 25.78759392, 25.90366769, 25.92296279,
+      25.94224354, 25.96150997, 25.96150997, 25.98076211, 25.98076211,
+      26.,         26.01922366, 26.03843313, 26.03843313, 26.05762844,
+      26.05762844, 26.0959767,  26.0959767,  26.11512971, 26.11512971,
+      26.13426869, 26.13426869, 26.15339366, 26.15339366, 26.15339366,
+      26.15339366, 26.15339366, 26.15339366, 26.17250466, 26.17250466,
+      26.17250466, 26.17250466, 26.17250466, 23.28089345, 22.09072203,
+      19.87460691, 19.49358869, 19.87460691, 17.43559577, 18.11077028,
+      18.49324201, 18.89444363, 18.97366596, 19.15724406, 19.18332609,
+      19.18332609, 19.39071943, 19.54482029, 19.57038579, 19.59591794,
+      19.6468827,  19.72308292, 19.94993734, 20.,         20.02498439,
+      20.0748599,  20.1246118,  20.1246118,  20.1246118,  20.14944168,
+      20.174241,   20.19900988, 20.22374842, 20.22374842, 20.27313493,
+      20.29778313, 20.32240143, 20.32240143, 20.54263858, 20.59126028,
+      20.63976744, 20.63976744, 20.63976744, 20.71231518, 20.95232684,
+      20.97617696, 21.07130751, 21.11871208, 21.16601049, 21.16601049,
+      21.1896201,  21.23676058, 21.23676058, 21.33072901, 21.47091055,
+      21.56385865, 21.56385865, 21.56385865, 21.58703314, 21.63330765,
+      21.65640783, 21.67948339, 21.70253441, 21.77154106, 21.81742423,
+      21.84032967, 21.88606863, 21.9317122,  21.97726098, 22.,
+      22.06807649, 22.09072203, 22.09072203, 22.24859546, 22.27105745,
+      22.27105745, 22.27105745, 22.3159136,  22.3159136,  22.38302929,
+      22.4053565,  22.49444376, 22.5166605,  22.53885534, 22.60530911,
+      22.627417,   22.6715681,  22.71563338, 22.737634,   22.737634,
+      22.91287847, 22.93468988, 22.95648057, 22.97825059, 23.02172887,
+      23.10844002, 23.13006701, 23.19482701, 23.21637353, 23.23790008,
+      23.2594067,  23.38803113, 23.40939982, 23.47338919, 23.51595203,
+      23.68543856, 23.68543856, 23.74868417, 23.76972865, 23.85372088,
+      23.97915762, 24.0208243,  24.0208243,  24.04163056, 24.08318916,
+      24.12467616, 24.16609195, 24.20743687, 24.24871131, 24.24871131,
+      24.24871131, 24.2899156,  24.37211521, 24.39262184, 24.4744765,
+      24.53568829, 24.53568829, 24.53568829, 24.55605832, 24.69817807,
+      25.,         25.03996805, 25.0998008,  25.11971337, 25.13961018,
+      25.17935662, 25.19920634, 25.3968502,  25.53429067, 25.55386468,
+      25.57342371, 25.65151068, 25.70992026, 25.74878638, 25.8069758,
+      25.86503431, 25.90366769, 26.17250466, 26.19160171, 26.21068484,
+      26.21068484, 26.2297541,  26.2297541,  26.26785107, 26.26785107,
+      26.28687886, 26.28687886, 26.30589288, 26.32489316, 26.32489316,
+      26.34387974, 26.34387974, 26.34387974, 26.36285265, 26.36285265,
+      26.36285265, 26.38181192, 26.38181192, 26.40075756, 26.40075756,
+      26.40075756, 26.40075756, 26.40075756, 26.41968963, 26.41968963,
+      26.43860813, 26.43860813, 26.43860813, 26.43860813, 26.45751311,
+      26.45751311, 26.45751311, 26.45751311, 26.45751311, 26.45751311,
+      26.45751311, 26.47640459, 26.4952826,  26.4952826,  26.4952826,
+      26.4952826,  26.53299832, 26.55183609, 26.55183609, 26.55183609,
+      26.57066051, 26.57066051, 26.5894716,  26.5894716,  26.5894716,
+      26.5894716,  26.5894716,  26.5894716,  26.60826939, 26.60826939,
+      26.60826939, 26.60826939, 26.62705391, 26.66458325, 26.66458325,
+      26.66458325, 26.66458325, 26.66458325, 26.70205985, 26.73948391,
+      26.73948391, 26.73948391, 26.75817632, 26.75817632, 26.75817632,
+      25.21904043, 25.15949125, 25.53429067, 25.78759392, 25.88435821,
+      26.38181192, 26.40075756, 26.51414717, 26.64582519, 26.75817632,
+      26.77685568, 26.77685568, 26.79552201, 26.79552201, 26.81417536,
+      26.83281573, 26.83281573, 26.83281573, 26.83281573, 26.83281573,
+      26.85144316, 26.87005769, 26.88865932, 26.92582404, 26.92582404,
+      26.94438717, 26.94438717, 26.94438717, 26.96293753, 26.98147513,
+      26.98147513, 27.,         27.,         27.,         27.,
+      27.,         27.,         27.,         27.01851217, 27.01851217,
+      27.03701167, 27.03701167, 27.05549852, 27.05549852, 27.05549852,
+      27.05549852, 27.07397274, 27.07397274, 27.09243437, 27.09243437,
+      27.09243437, 27.09243437, 27.09243437, 27.11088342, 27.11088342,
+      27.12931993, 27.12931993, 27.12931993, 27.14774392, 27.16615541,
+      27.16615541, 27.16615541, 27.16615541, 27.16615541, 27.18455444,
+      27.18455444, 27.18455444, 27.18455444, 27.18455444, 27.20294102,
+      27.20294102, 27.22131518, 27.22131518, 27.22131518, 27.22131518,
+      24.67792536, 23.34523506, 22.29349681, 22.22611077, 21.54065923,
+      21.54065923, 22.24859546, 22.27105745, 22.42766149, 22.49444376,
+      22.5166605,  22.56102835, 22.75961335, 22.82542442, 22.86919325,
+      22.86919325, 23.04343724, 23.10844002, 23.13006701, 23.19482701,
+      23.34523506, 23.43074903, 23.47338919, 23.47338919, 23.49468025,
+      23.62202362, 23.62202362, 23.68543856, 23.70653918, 23.70653918,
+      23.76972865, 23.79075451, 23.8117618,  23.85372088, 23.9582971,
+      24.16609195, 24.16609195, 24.33105012, 24.35159132, 24.35159132,
+      24.37211521, 24.51530134, 24.51530134, 24.51530134, 24.53568829,
+      24.67792536, 24.85960579, 24.8997992,  24.95996795, 25.,
+      25.05992817, 25.11971337, 25.15949125, 25.23885893, 25.25866188,
+      25.27844932, 25.29822128, 25.57342371, 25.57342371, 25.59296778,
+      25.61249695, 25.67099531, 25.70992026, 25.78759392, 25.82634314,
+      25.88435821, 25.90366769, 25.92296279, 26.13426869, 26.15339366,
+      26.19160171, 26.19160171, 26.21068484, 26.30589288, 26.32489316,
+      26.34387974, 26.34387974, 26.45751311, 26.4952826,  26.55183609,
+      26.66458325, 26.70205985, 26.81417536, 26.83281573, 26.94438717,
+      27.07397274, 27.11088342, 27.20294102, 27.23967694, 27.25802634,
+      27.25802634, 27.25802634, 27.27636339, 27.27636339, 27.29468813,
+      27.31300057, 27.31300057, 27.33130074, 27.33130074, 27.33130074,
+      27.33130074, 27.33130074, 27.33130074, 27.33130074, 27.34958866,
+      27.34958866, 27.34958866, 27.34958866, 27.34958866, 27.38612788,
+      27.40437921, 27.4226184,  27.4226184,  27.4226184,  27.4226184,
+      27.44084547, 27.44084547, 27.44084547, 27.44084547, 27.44084547,
+      27.44084547, 27.44084547, 27.45906044, 27.45906044, 27.47726333,
+      27.47726333, 27.49545417, 27.49545417, 27.49545417, 27.51363298,
+      27.51363298, 27.51363298, 27.51363298, 27.5317998,  27.5317998,
+      27.54995463, 27.54995463, 27.54995463, 27.5680975,  27.5680975,
+      27.5680975,  27.58622845, 27.58622845, 27.58622845, 27.60434748,
+      27.60434748, 27.60434748, 27.60434748, 27.62245463, 27.62245463,
+      27.64054992, 27.64054992, 27.64054992, 27.64054992, 27.64054992,
+      27.64054992, 27.65863337, 27.65863337, 27.65863337, 27.67670501,
+      27.67670501, 27.67670501, 27.67670501, 27.67670501, 27.69476485,
+      27.69476485, 27.71281292, 27.73084925, 27.73084925, 27.73084925,
+      27.74887385, 27.74887385, 27.74887385, 27.74887385, 27.76688675,
+      27.78488798, 27.78488798, 27.78488798, 27.80287755, 27.82085549,
+      27.82085549, 27.82085549, 27.83882181, 27.83882181, 27.85677655,
+      27.85677655, 27.85677655, 27.85677655, 27.87471973, 27.87471973,
+      27.89265136, 27.89265136, 27.91057147, 27.91057147, 27.92848009,
+      27.92848009, 27.92848009, 27.92848009, 27.92848009, 27.94637722,
+      27.94637722, 27.96426291, 27.96426291, 27.98213716, 27.98213716,
+      27.98213716, 28.,         28.01785145, 28.01785145, 28.01785145,
+      28.03569154, 28.05352028, 28.05352028, 28.05352028, 28.0713377,
+      28.0713377,  28.08914381, 28.08914381, 28.10693865, 28.10693865,
+      28.10693865, 28.14249456, 28.14249456, 28.17800561, 28.19574436,
+      28.19574436, 28.21347196, 28.21347196, 28.21347196, 28.21347196,
+      28.24889378, 28.24889378, 28.26658805, 28.26658805, 28.28427125,
+      28.28427125, 28.3019434,  28.3019434,  28.3019434,  28.31960452,
+      28.31960452, 28.31960452, 28.33725463, 28.35489376, 28.35489376,
+      28.35489376, 28.35489376, 28.35489376, 28.35489376, 28.37252192,
+      28.37252192, 28.37252192, 28.37252192, 28.37252192, 28.37252192,
+      28.39013913, 28.39013913, 28.39013913, 28.39013913, 28.40774542,
+      28.40774542, 28.40774542, 28.40774542, 28.42534081, 28.42534081,
+      28.42534081, 28.42534081, 28.42534081, 28.44292531, 28.44292531,
+      28.46049894, 28.46049894, 28.46049894, 28.47806173, 28.4956137,
+      28.4956137,  28.51315486, 28.51315486, 28.53068524, 28.53068524,
+      28.53068524, 28.53068524, 28.54820485, 28.54820485, 28.54820485,
+      28.56571371, 28.56571371, 28.58321186, 28.58321186, 28.58321186,
+      28.60069929, 28.61817604, 28.61817604, 28.61817604, 28.63564213,
+      28.63564213, 28.63564213, 28.65309756, 28.65309756, 28.67054237,
+      28.67054237, 28.67054237, 28.67054237, 28.67054237, 28.67054237,
+      28.68797658, 28.68797658, 28.68797658, 28.68797658, 28.68797658,
+      28.70540019, 28.70540019, 28.72281323, 28.74021573, 28.74021573,
+      28.74021573, 28.75760769, 28.75760769, 28.75760769, 28.77498914,
+      28.7923601,  28.82707061, 28.82707061, 28.8444102,  28.86173938,
+      28.86173938, 28.87905816, 28.89636655, 28.89636655, 28.91366459,
+      28.91366459, 28.91366459, 28.94822965, 28.94822965, 28.94822965,
+      28.96549672, 28.96549672, 28.96549672, 28.96549672, 28.96549672,
+      29.,         29.,         29.,         29.,         29.01723626,
+      29.01723626, 29.01723626, 29.01723626, 29.01723626, 29.01723626,
+      29.03446228, 29.03446228, 29.05167809, 29.05167809, 29.05167809,
+      29.05167809, 29.05167809, 26.43860813, 23.17326045, 22.3159136,
+      21.16601049, 21.3541565,  21.54065923, 22.,         22.13594362,
+      22.47220505, 22.5166605,  22.53885534, 22.627417,   22.69361144,
+      22.97825059, 23.13006701, 23.15167381, 23.17326045, 23.2594067,
+      23.28089345, 23.36664289, 23.40939982, 23.51595203, 23.66431913,
+      23.72762104, 23.76972865, 23.93741841, 23.97915762, 24.06241883,
+      24.06241883, 24.06241883, 24.08318916, 24.14539294, 24.14539294,
+      24.20743687, 24.37211521, 24.37211521, 24.59674775, 24.61706725,
+      24.65765601, 24.67792536, 24.69817807, 24.8997992,  24.8997992,
+      24.91987159, 24.93992783, 25.,         25.,         25.03996805,
+      25.07987241, 25.0998008,  25.11971337, 25.11971337, 25.17935662,
+      25.25866188, 25.29822128, 25.3179778,  25.3968502,  25.41653005,
+      25.43619468, 25.43619468, 25.51470164, 25.55386468, 25.57342371,
+      25.78759392, 25.8069758,  25.82634314, 25.94224354, 26.01922366,
+      26.03843313, 26.2488095,  26.26785107, 26.32489316, 26.38181192,
+      26.43860813, 26.47640459, 26.4952826,  26.51414717, 26.55183609,
+      26.5894716,  26.70205985, 26.72077843, 26.75817632, 26.79552201,
+      26.79552201, 26.81417536, 26.83281573, 26.87005769, 26.96293753,
+      27.03701167, 27.05549852, 27.12931993, 27.12931993, 27.14774392,
+      27.16615541, 27.27636339, 27.31300057, 27.31300057, 27.36786437,
+      27.36786437, 27.38612788, 27.38612788, 27.49545417, 27.5317998,
+      27.64054992, 27.82085549, 27.96426291, 28.0713377,  28.19574436,
+      28.28427125, 28.28427125, 28.3019434,  28.3019434,  28.39013913,
+      28.40774542, 28.44292531, 28.44292531, 28.47806173, 28.53068524,
+      28.54820485, 28.77498914, 28.80972058, 29.05167809, 29.06888371,
+      29.06888371, 29.08607914, 29.10326442, 29.12043956, 29.13760457,
+      29.13760457, 29.15475947, 29.17190429, 29.17190429, 29.18903904,
+      29.20616373, 29.20616373, 29.20616373, 29.22327839, 29.22327839,
+      29.22327839, 29.22327839, 29.24038303, 29.24038303, 29.25747768,
+      29.27456234, 29.27456234, 29.27456234, 29.27456234, 29.27456234,
+      29.29163703, 29.29163703, 29.29163703, 29.30870178, 29.30870178,
+      29.30870178, 29.30870178, 29.3257566,  29.3428015,  29.3428015,
+      29.35983651, 29.35983651, 29.37686164, 29.37686164, 29.37686164,
+      29.39387691, 29.41088234, 29.41088234, 29.41088234, 29.41088234,
+      29.44486373, 29.46183973, 29.46183973, 29.47880595, 29.47880595,
+      29.47880595, 29.47880595, 29.49576241, 29.49576241, 29.51270913,
+      29.51270913, 29.52964612, 29.54657341, 29.54657341, 29.59729717,
+      29.61418579, 29.64793416, 29.64793416, 29.64793416, 29.66479395,
+      29.66479395, 29.68164416, 29.68164416, 29.68164416, 29.68164416,
+      29.68164416, 29.69848481, 29.69848481, 29.71531592, 29.71531592,
+      29.71531592, 29.73213749, 29.74894956, 29.74894956, 29.74894956,
+      29.76575213, 29.76575213, 29.76575213, 29.76575213, 29.78254522,
+      29.78254522, 29.79932885, 29.79932885, 29.81610303, 29.84962311,
+      29.84962311, 29.84962311, 29.86636905, 29.88310559, 29.9165506,
+      29.9165506,  29.9165506,  29.93325909, 29.93325909, 29.93325909,
+      29.94995826, 29.94995826, 29.94995826, 29.94995826, 29.9833287,
+      29.9833287,  30.,         30.,         30.,         30.,
+      30.,         30.01666204, 30.01666204, 30.01666204, 30.01666204,
+      30.03331484, 30.03331484, 30.03331484, 30.0499584,  30.06659276,
+      30.06659276, 30.08321791, 30.11644069, 30.11644069, 30.11644069,
+      30.11644069, 30.11644069, 30.11644069, 30.13303835, 30.13303835,
+      30.13303835, 30.14962686, 30.16620626, 30.16620626, 30.16620626,
+      30.19933774, 30.19933774, 30.19933774, 30.19933774, 30.21588986,
+      30.23243292, 30.24896692, 30.2654919,  30.2654919,  30.2654919,
+      30.28200786, 30.28200786, 30.29851482, 30.31501278, 30.33150178,
+      30.33150178, 30.33150178, 30.34798181, 30.38091506, 30.41381265,
+      30.41381265, 30.43024811, 30.43024811, 30.4466747,  30.4466747,
+      30.46309242, 30.47950131, 30.49590136, 30.5122926,  30.5450487,
+      30.56141358, 30.56141358, 30.5777697,  30.59411708, 30.59411708,
+      30.59411708, 30.61045573, 30.62678566, 30.62678566, 30.62678566,
+      30.64310689, 30.64310689, 30.64310689, 30.64310689, 30.65941943,
+      30.65941943, 30.6757233,  30.6757233,  30.69201851, 30.70830507,
+      30.7408523,  30.7408523,  30.7408523,  30.7408523,  30.7408523,
+      30.7408523,  30.757113,   30.757113,   30.78960864, 30.78960864,
+      30.78960864, 30.8058436,  30.8058436,  30.8058436,  30.83828789,
+      30.85449724, 30.85449724, 30.87069808, 30.87069808, 30.88689042,
+      30.88689042, 30.88689042, 30.90307428, 30.91924967, 30.9354166,
+      30.95157508, 30.96772513, 30.96772513, 30.98386677, 31.01612484,
+      31.06444913, 31.06444913, 31.09662361, 31.09662361, 31.11269837,
+      31.144823,   31.144823,   31.17691454, 31.17691454, 31.19294792,
+      31.19294792, 31.19294792, 31.20897307, 31.22498999, 31.22498999,
+      31.22498999, 31.2409987,  31.2409987,  31.25699922, 31.28897569,
+      31.30495168, 31.30495168, 31.33687923, 31.36877428, 31.38470965,
+      31.40063694, 31.40063694, 31.43246729, 31.43246729, 31.43246729,
+      31.44837039, 31.44837039, 31.44837039, 31.46426545, 31.46426545,
+      31.48015248, 31.48015248, 31.48015248, 31.4960315,  31.52776554,
+      31.52776554, 31.54362059, 31.54362059, 31.54362059, 31.54362059,
+      31.55946768, 31.55946768, 31.57530681, 31.57530681, 31.60696126,
+      31.6227766,  31.63858404, 31.63858404, 31.63858404, 31.65438358,
+      31.65438358, 31.67017524, 31.70173497, 31.70173497, 31.71750305,
+      31.71750305, 31.78049716, 31.79622619, 31.82766093, 31.85906464,
+      31.85906464, 31.8747549,  31.8747549,  31.8747549,  31.89043744,
+      31.89043744, 31.9217794,  31.93743885, 31.95309062, 31.95309062,
+      31.98437118, 32.,         32.01562119, 32.01562119, 32.01562119,
+      32.03123476, 32.06243908, 32.06243908, 32.06243908, 32.06243908,
+      32.07802986, 32.10918872, 32.12475681, 32.14031736, 32.14031736,
+      32.15587038, 32.17141588, 32.17141588, 32.24903099, 32.24903099,
+      32.24903099, 32.26453161, 32.26453161, 32.29551052, 32.29551052,
+      32.31098884, 32.40370349, 32.43454948, 32.43454948, 32.43454948,
+      32.48076354, 32.51153641, 32.51153641, 32.52691193, 32.52691193,
+      32.55764119, 32.55764119, 32.60368077, 32.61901286, 32.61901286,
+      32.61901286, 32.64965543, 32.64965543, 32.68026928, 32.69556545,
+      32.71085447, 32.71085447, 32.74141109, 32.74141109, 32.75667871,
+      32.80243893, 32.80243893, 32.80243893, 32.80243893, 32.83291032,
+      32.86335345, 32.87856445, 32.90896534, 32.92415527, 32.92415527,
+      32.92415527, 32.93933818, 32.93933818, 32.95451411, 32.95451411,
+      32.95451411, 32.96968304, 32.984845,   32.984845,   32.984845,
+      33.03028913, 33.03028913, 33.04542328, 33.04542328, 33.09078422,
+      33.10589071, 33.10589071, 33.10589071, 33.12099032, 33.12099032,
+      33.15116891, 33.19638535, 33.21144381, 33.21144381, 33.2565783,
+      33.28663395, 33.33166662, 33.33166662, 33.33166662, 33.33166662,
+      33.346664,   33.346664,   33.39161571, 33.46640106, 33.48133809,
+      33.48133809, 33.51119216, 33.52610923, 33.54101966, 33.55592347,
+      33.57082066, 33.61547263, 33.67491648, 33.68976106, 33.68976106,
+      33.7194306,  33.73425559, 33.74907406, 33.74907406, 33.76388603,
+      33.80828301, 33.83784863, 33.85262176, 33.88214869, 33.89690251,
+      33.91164992, 33.91164992, 33.92639091, 33.9411255,  33.98529094,
+      34.,         34.,         34.05877273, 34.07345007, 34.0881211,
+      34.10278581, 34.13209633, 34.13209633, 34.13209633, 34.16138171,
+      34.17601498, 34.17601498, 34.17601498, 34.20526275, 34.2636834,
+      34.33656943, 34.42382896, 34.45286635, 34.45286635, 34.49637662,
+      34.525353,   34.53983208, 34.55430509, 34.55430509, 34.59768778,
+      34.64101615, 34.64101615, 34.64101615, 34.81379037, 34.82814953,
+      34.82814953, 34.85685012, 34.88552709, 34.88552709, 34.89985673,
+      34.92849839, 35.02855978, 35.02855978, 35.05709629, 35.07135583,
+      35.07135583, 35.11409973, 35.12833614, 35.17101079, 35.19943181,
+      35.21363372, 35.27038418, 35.29872519, 35.32704347, 35.38361203,
+      35.41186242, 35.48239,    35.4964787,  35.51056181, 35.51056181,
+      35.52463934, 35.63705936, 35.70714214, 35.76310948, 35.83294573,
+      35.91656999, 35.98610843, 36.01388621, 36.01388621, 36.01388621,
+      36.06937759, 36.0970913,  36.20773398, 36.24913792, 36.29049462,
+      36.30426972, 36.31803959, 36.34556369, 36.35931793, 36.37306696,
+      36.44173432, 36.48287269, 36.57868232, 36.82390528, 36.86461718,
+      36.87817783, 36.87817783, 36.87817783, 36.89173349, 36.90528417,
+      36.97296309, 36.97296309, 37.01351105, 37.08099244, 37.13488926,
+      37.17526059, 37.28270376, 37.30951621, 37.36308338, 37.41657387,
+      37.76241518, 38.05259518, 38.13135193, 38.31448812, 38.45776905,
+      38.78143886, 39.79949748, 39.87480407, 40.47221269, 40.52159918,
+      42.11887938},
+     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}};
+
+namespace Iris {
+constexpr int n_row = 150;
+const std::vector<int> parents = {
+  150, 150, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152,
+  151, 152, 151, 152, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151,
+  152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151,
+  152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151,
+  152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151, 152, 151,
+  152, 151, 151, 152, 151, 152, 151, 152, 151, 151, 151, 151, 151, 151,
+  151, 151, 151, 151, 151, 151, 152, 152, 152, 152, 152, 152, 152, 152,
+  152, 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, 153, 154, 153,
+  154, 153, 153, 153, 153, 153, 153, 154, 153, 154, 153, 154, 153, 154,
+  154, 154, 154, 154, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
+  154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154};
+
+const std::vector<int> children = {
+  151, 152, 41,  131, 15,  117, 14,  118, 22,  106, 18,  98,  13,  109,
+  33,  57,  44,  60,  93,  32,  129, 24,  68,  43,  122, 16,  135, 5,
+  134, 23,  119, 20,  125, 8,   114, 36,  108, 31,  148, 10,  87,  46,
+  100, 35,  105, 6,   62,  19,  107, 42,  113, 25,  130, 11,  64,  38,
+  59,  37,  50,  48,  141, 21,  52,  3,   85,  26,  84,  2,   102, 45,
+  136, 47,  29,  121, 12,  146, 40,  110, 30,  1,   34,  9,   28,  4,
+  49,  7,   27,  17,  39,  0,   79,  132, 70,  56,  137, 133, 73,  144,
+  53,  63,  81,  138, 72,  90,  66,  103, 76,  153, 154, 77,  80,  126,
+  71,  83,  123, 127, 142, 149, 101, 51,  139, 91,  143, 65,  104, 74,
+  54,  86,  58,  75,  128, 116, 115, 124, 111, 147, 145, 112, 120, 140,
+  97,  61,  88,  67,  78,  55,  95,  82,  89,  69,  92,  94,  96,  99};
+
+const std::vector<float> lambdas = {
+  0.60971076, 0.60971076, 1.25988158, 0.97590007, 1.56173762, 0.98058068,
+  1.71498585, 1.03695169, 1.85695338, 1.13227703, 1.9245009,  1.22169444,
+  2.,         1.24034735, 2.08514414, 1.27000127, 2.08514414, 1.38675049,
+  1.38675049, 2.1821789,  1.41421356, 2.23606798, 1.41421356, 2.3570226,
+  1.42857143, 2.5,        1.42857143, 2.5819889,  1.42857143, 2.5819889,
+  1.5249857,  2.77350098, 1.5430335,  2.77350098, 1.56173762, 2.77350098,
+  1.60128154, 2.88675135, 1.60128154, 3.01511345, 1.62221421, 3.01511345,
+  1.64398987, 3.01511345, 1.64398987, 3.16227766, 1.71498585, 3.16227766,
+  1.79605302, 3.16227766, 1.82574186, 3.33333333, 1.85695338, 3.33333333,
+  1.85695338, 3.33333333, 1.85695338, 3.33333333, 1.9245009,  3.53553391,
+  1.9245009,  3.53553391, 1.96116135, 3.77964473, 1.96116135, 3.77964473,
+  1.96116135, 3.77964473, 2.,         3.77964473, 2.,         4.0824829,
+  4.0824829,  2.04124145, 4.0824829,  2.08514414, 4.0824829,  2.13200716,
+  4.0824829,  4.0824829,  4.0824829,  4.0824829,  4.0824829,  4.0824829,
+  4.0824829,  4.0824829,  4.0824829,  4.0824829,  4.0824829,  4.0824829,
+  2.13200716, 2.13200716, 2.13200716, 2.1821789,  2.1821789,  2.1821789,
+  2.1821789,  2.29415734, 2.29415734, 2.29415734, 2.29415734, 2.29415734,
+  2.29415734, 2.3570226,  2.3570226,  2.3570226,  2.3570226,  2.3570226,
+  2.3570226,  2.3570226,  2.3570226,  2.3570226,  2.42535625, 2.3570226,
+  2.3570226,  2.3570226,  2.3570226,  2.3570226,  2.3570226,  2.5819889,
+  2.42535625, 2.5819889,  2.5819889,  2.5819889,  2.5819889,  2.5819889,
+  2.5819889,  2.5819889,  2.5819889,  2.5819889,  2.5819889,  2.5819889,
+  2.5819889,  2.5819889,  2.5819889,  2.5819889,  2.5819889,  2.5819889,
+  2.5819889,  2.5819889,  2.5819889,  2.67261242, 2.67261242, 2.67261242,
+  2.67261242, 2.67261242, 2.67261242, 2.67261242, 2.67261242, 2.67261242,
+  2.67261242, 2.67261242, 2.67261242, 2.67261242};
+
+const std::vector<int> sizes = {
+  50, 100, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 21, 24, 1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1,
+  1,  1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  1,  1};
+};  // namespace Iris
+
+namespace Digits {
+constexpr int n_row = 1797;
+
+const std::vector<int> parents = {
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797,
+  1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1797, 1798,
+  1799, 1798, 1799, 1799, 1799, 1799, 1799, 1799, 1799, 1799, 1799, 1799, 1798,
+  1798, 1798, 1798, 1798, 1798, 1798, 1798, 1798, 1798, 1798, 1800, 1801, 1800,
+  1801, 1801, 1800, 1801, 1800, 1801, 1800, 1801, 1801, 1801, 1801, 1800, 1801,
+  1800, 1801, 1800, 1801, 1800, 1801, 1801, 1800, 1801, 1800, 1801, 1800, 1801,
+  1800, 1801, 1800, 1801, 1801, 1800, 1802, 1803, 1800, 1802, 1802, 1802, 1803,
+  1803, 1800, 1802, 1802, 1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803, 1800,
+  1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803, 1803, 1800, 1802, 1803, 1800,
+  1802, 1803, 1800, 1802, 1803, 1800, 1800, 1802, 1803, 1800, 1802, 1803, 1800,
+  1800, 1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803, 1800,
+  1802, 1803, 1800, 1802, 1802, 1803, 1803, 1800, 1802, 1803, 1800, 1802, 1803,
+  1803, 1800, 1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803, 1800, 1802, 1803,
+  1800, 1802, 1802, 1803, 1800, 1804, 1805, 1803, 1800, 1804, 1805, 1803, 1800,
+  1804, 1805, 1803, 1800, 1804, 1804, 1805, 1803, 1800, 1804, 1805, 1803, 1800,
+  1804, 1805, 1803, 1800, 1804, 1804, 1805, 1803, 1800, 1804, 1804, 1804, 1805,
+  1803, 1800, 1800, 1804, 1804, 1805, 1803, 1800, 1806, 1807, 1807, 1805, 1803,
+  1800, 1806, 1807, 1805, 1805, 1803, 1800, 1806, 1807, 1805, 1803, 1800, 1806,
+  1807, 1805, 1803, 1803, 1800, 1806, 1807, 1805, 1803, 1800, 1806, 1807, 1805,
+  1803, 1803, 1800, 1806, 1807, 1807, 1805, 1805, 1805, 1805, 1805, 1805, 1805,
+  1805, 1805, 1805, 1805, 1803, 1800, 1806, 1806, 1807, 1803, 1800, 1806, 1806,
+  1807, 1803, 1800, 1806, 1807, 1803, 1800, 1806, 1807, 1803, 1803, 1800, 1806,
+  1807, 1803, 1800, 1806, 1806, 1807, 1803, 1800, 1806, 1806, 1807, 1803, 1800,
+  1806, 1807, 1803, 1800, 1806, 1807, 1803, 1800, 1806, 1807, 1803, 1800, 1800,
+  1806, 1806, 1807, 1803, 1800, 1806, 1807, 1807, 1803, 1800, 1806, 1807, 1803,
+  1800, 1806, 1807, 1803, 1800, 1806, 1807, 1803, 1800, 1806, 1807, 1803, 1800,
+  1806, 1807, 1807, 1807, 1807, 1803, 1800, 1806, 1807, 1803, 1803, 1803, 1800,
+  1806, 1806, 1807, 1803, 1800, 1808, 1809, 1807, 1803, 1803, 1800, 1808, 1809,
+  1807, 1803, 1803, 1800, 1800, 1808, 1809, 1807, 1810, 1811, 1800, 1808, 1808,
+  1808, 1808, 1809, 1807, 1810, 1811, 1811, 1811, 1811, 1811, 1811, 1811, 1811,
+  1811, 1811, 1800, 1808, 1809, 1807, 1810, 1800, 1808, 1809, 1807, 1810, 1810,
+  1800, 1808, 1808, 1809, 1807, 1807, 1810, 1800, 1808, 1809, 1807, 1810, 1810,
+  1810, 1800, 1808, 1809, 1807, 1810, 1800, 1808, 1809, 1807, 1810, 1800, 1808,
+  1809, 1807, 1810, 1800, 1800, 1808, 1809, 1807, 1810, 1800, 1808, 1809, 1809,
+  1807, 1810, 1800, 1808, 1809, 1807, 1810, 1800, 1808, 1809, 1807, 1810, 1800,
+  1800, 1808, 1809, 1809, 1807, 1810, 1800, 1800, 1808, 1809, 1807, 1810, 1800,
+  1808, 1809, 1807, 1807, 1810, 1810, 1810, 1800, 1800, 1808, 1809, 1807, 1810,
+  1800, 1808, 1809, 1807, 1810, 1810, 1800, 1808, 1809, 1807, 1810, 1800, 1800,
+  1808, 1809, 1807, 1810, 1800, 1808, 1808, 1809, 1807, 1810, 1800, 1808, 1809,
+  1807, 1810, 1800, 1808, 1808, 1809, 1807, 1810, 1800, 1812, 1812, 1812, 1812,
+  1812, 1812, 1812, 1813, 1809, 1809, 1807, 1807, 1810, 1800, 1812, 1813, 1809,
+  1807, 1810, 1800, 1812, 1813, 1809, 1807, 1810, 1800, 1800, 1800, 1812, 1813,
+  1809, 1809, 1807, 1810, 1800, 1812, 1813, 1813, 1813, 1813, 1813, 1813, 1813,
+  1813, 1813, 1813, 1809, 1807, 1807, 1810, 1800, 1812, 1809, 1807, 1810, 1800,
+  1812, 1809, 1807, 1810, 1800, 1812, 1809, 1807, 1810, 1800, 1812, 1809, 1807,
+  1810, 1800, 1812, 1809, 1807, 1810, 1800, 1812, 1809, 1807, 1810, 1810, 1800,
+  1812, 1809, 1807, 1807, 1814, 1815, 1815, 1815, 1815, 1815, 1815, 1815, 1815,
+  1815, 1815, 1800, 1800, 1812, 1809, 1807, 1807, 1814, 1800, 1812, 1809, 1807,
+  1814, 1800, 1812, 1809, 1807, 1814, 1800, 1812, 1812, 1809, 1807, 1807, 1814,
+  1800, 1812, 1809, 1807, 1814, 1800, 1800, 1812, 1812, 1809, 1809, 1807, 1814,
+  1814, 1814, 1814, 1814, 1814, 1814, 1814, 1814, 1814, 1800, 1812, 1812, 1809,
+  1807, 1800, 1812, 1812, 1809, 1809, 1807, 1800, 1812, 1809, 1807, 1807, 1800,
+  1812, 1809, 1807, 1807, 1800, 1812, 1812, 1809, 1807, 1800, 1812, 1809, 1807,
+  1800, 1800, 1812, 1809, 1807, 1800, 1800, 1812, 1809, 1807, 1800, 1812, 1809,
+  1807, 1807, 1807, 1807, 1807, 1807, 1807, 1807, 1807, 1800, 1812, 1809, 1809,
+  1809, 1807, 1800, 1800, 1812, 1809, 1807, 1800, 1800, 1800, 1800, 1800, 1812,
+  1809, 1807, 1800, 1812, 1809, 1809, 1807, 1800, 1812, 1812, 1809, 1809, 1807,
+  1800, 1812, 1812, 1809, 1807, 1807, 1807, 1807, 1800, 1812, 1809, 1807, 1800,
+  1800, 1800, 1800, 1812, 1809, 1807, 1800, 1812, 1812, 1812, 1809, 1809, 1809,
+  1809, 1807, 1800, 1812, 1809, 1807, 1800, 1812, 1809, 1807, 1800, 1800, 1800,
+  1812, 1809, 1807, 1800, 1812, 1809, 1807, 1800, 1800, 1800, 1800, 1800, 1800,
+  1800, 1800, 1800, 1800, 1812, 1809, 1807, 1812, 1809, 1807, 1807, 1807, 1812,
+  1809, 1807, 1812, 1809, 1807, 1812, 1809, 1807, 1812, 1812, 1809, 1807, 1807,
+  1812, 1809, 1807, 1812, 1809, 1807, 1812, 1809, 1807, 1812, 1809, 1809, 1807,
+  1812, 1812, 1809, 1807, 1816, 1817, 1809, 1809, 1809, 1809, 1809, 1809, 1807,
+  1807, 1807, 1807, 1816, 1816, 1817, 1809, 1807, 1816, 1817, 1809, 1809, 1807,
+  1807, 1816, 1817, 1818, 1819, 1807, 1807, 1807, 1807, 1807, 1807, 1807, 1807,
+  1807, 1807, 1816, 1816, 1816, 1817, 1817, 1818, 1818, 1818, 1818, 1818, 1818,
+  1818, 1818, 1818, 1818, 1819, 1816, 1816, 1817, 1817, 1819, 1816, 1817, 1819,
+  1816, 1817, 1819, 1816, 1817, 1817, 1817, 1819, 1819, 1819, 1816, 1817, 1819,
+  1816, 1817, 1817, 1819, 1816, 1817, 1819, 1816, 1817, 1819, 1816, 1817, 1817,
+  1817, 1817, 1817, 1817, 1817, 1817, 1817, 1819, 1816, 1817, 1819, 1819, 1819,
+  1816, 1816, 1817, 1819, 1819, 1820, 1821, 1817, 1819, 1820, 1821, 1821, 1817,
+  1817, 1819, 1819, 1820, 1821, 1817, 1819, 1819, 1820, 1821, 1817, 1822, 1823,
+  1820, 1821, 1817, 1817, 1822, 1823, 1820, 1821, 1817, 1822, 1822, 1822, 1822,
+  1822, 1822, 1822, 1822, 1822, 1822, 1823, 1820, 1821, 1817, 1823, 1820, 1821,
+  1817, 1823, 1820, 1821, 1817, 1823, 1820, 1821, 1817, 1823, 1823, 1823, 1823,
+  1823, 1823, 1823, 1823, 1823, 1823, 1823, 1823, 1820, 1821, 1817, 1820, 1821,
+  1817, 1817, 1820, 1821, 1817, 1817, 1820, 1821, 1817, 1820, 1821, 1817, 1820,
+  1820, 1821, 1817, 1820, 1821, 1817, 1820, 1821, 1817, 1820, 1821, 1817, 1820,
+  1821, 1817, 1820, 1821, 1817, 1820, 1821, 1817, 1817, 1820, 1821, 1824, 1825,
+  1820, 1821, 1824, 1825, 1820, 1820, 1821, 1824, 1824, 1825, 1820, 1821, 1821,
+  1824, 1825, 1820, 1826, 1826, 1827, 1824, 1825, 1820, 1828, 1829, 1827, 1827,
+  1824, 1824, 1825, 1820, 1828, 1828, 1829, 1827, 1830, 1831, 1825, 1820, 1828,
+  1828, 1828, 1828, 1828, 1828, 1828, 1829, 1829, 1827, 1830, 1831, 1825, 1820,
+  1828, 1829, 1827, 1830, 1831, 1825, 1820, 1828, 1829, 1827, 1830, 1831, 1825,
+  1820, 1828, 1829, 1827, 1830, 1831, 1825, 1825, 1820, 1828, 1829, 1827, 1827,
+  1827, 1827, 1827, 1827, 1827, 1827, 1827, 1827, 1827, 1827, 1827, 1827, 1830,
+  1831, 1825, 1820, 1828, 1829, 1830, 1831, 1831, 1825, 1820, 1828, 1829, 1830,
+  1831, 1825, 1820, 1820, 1828, 1829, 1830, 1831, 1831, 1831, 1831, 1831, 1831,
+  1831, 1831, 1825, 1820, 1828, 1829, 1830, 1831, 1825, 1820, 1828, 1829, 1830,
+  1831, 1831, 1825, 1820, 1828, 1829, 1830, 1832, 1833, 1825, 1820, 1820, 1820,
+  1828, 1829, 1830, 1830, 1832, 1833, 1825, 1820, 1828, 1829, 1830, 1832, 1833,
+  1825, 1820, 1828, 1829, 1830, 1832, 1833, 1833, 1825, 1820, 1828, 1829, 1830,
+  1832, 1833, 1825, 1820, 1828, 1829, 1830, 1832, 1833, 1825, 1820, 1820, 1828,
+  1829, 1830, 1830, 1830, 1832, 1833, 1825, 1820, 1828, 1829, 1829, 1829, 1829,
+  1829, 1829, 1830, 1832, 1833, 1825, 1820, 1820, 1828, 1829, 1830, 1832, 1832,
+  1832, 1833, 1825, 1820, 1820, 1828, 1828, 1829, 1830, 1830, 1832, 1833, 1825,
+  1820, 1828, 1828, 1829, 1830, 1832, 1833, 1825, 1820, 1828, 1829, 1829, 1830,
+  1832, 1833, 1833, 1825, 1820, 1828, 1828, 1828, 1828, 1828, 1828, 1828, 1829,
+  1830, 1830, 1832, 1833, 1833, 1833, 1825, 1820, 1828, 1829, 1830, 1830, 1832,
+  1833, 1833, 1825, 1820, 1828, 1829, 1830, 1832, 1833, 1825, 1820, 1828, 1829,
+  1829, 1830, 1832, 1833, 1825, 1820, 1820, 1820, 1828, 1829, 1830, 1832, 1833,
+  1833, 1825, 1820, 1828, 1829, 1830, 1832, 1833, 1825, 1820, 1820, 1828, 1829,
+  1830, 1832, 1833, 1825, 1820, 1828, 1828, 1829, 1829, 1829, 1829, 1829, 1829,
+  1829, 1829, 1829, 1829, 1830, 1832, 1833, 1833, 1833, 1833, 1833, 1833, 1833,
+  1833, 1833, 1833, 1825, 1820, 1828, 1830, 1832, 1825, 1820, 1820, 1820, 1828,
+  1830, 1832, 1825, 1820, 1828, 1830, 1832, 1825, 1820, 1828, 1830, 1832, 1825,
+  1820, 1820, 1828, 1830, 1832, 1825, 1820, 1828, 1830, 1832, 1825, 1820, 1820,
+  1820, 1828, 1830, 1832, 1825, 1820, 1828, 1830, 1830, 1832, 1825, 1825, 1820,
+  1820, 1828, 1830, 1832, 1825, 1820, 1828, 1828, 1830, 1832, 1825, 1820, 1820,
+  1820, 1820, 1828, 1830, 1832, 1825, 1820, 1820, 1828, 1830, 1832, 1832, 1832,
+  1832, 1832, 1832, 1832, 1832, 1832, 1832, 1832, 1825, 1820, 1828, 1830, 1825,
+  1820, 1828, 1830, 1825, 1825, 1820, 1828, 1830, 1825, 1825, 1820, 1828, 1830,
+  1825, 1820, 1828, 1830, 1825, 1825, 1820, 1820, 1820, 1820, 1828, 1830, 1825,
+  1825, 1820, 1828, 1830, 1825, 1820, 1828, 1830, 1825, 1820, 1820, 1828, 1830,
+  1825, 1820, 1820, 1828, 1830, 1825, 1820, 1828, 1830, 1825, 1825, 1825, 1820,
+  1828, 1830, 1825, 1820, 1828, 1830, 1825, 1825, 1825, 1820, 1828, 1830, 1830,
+  1825, 1820, 1820, 1828, 1830, 1825, 1834, 1834, 1835, 1828, 1830, 1830, 1830,
+  1830, 1825, 1834, 1835, 1828, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830,
+  1830, 1830, 1830, 1830, 1825, 1834, 1835, 1828, 1825, 1834, 1834, 1835, 1828,
+  1825, 1834, 1835, 1828, 1825, 1834, 1835, 1828, 1825, 1834, 1835, 1828, 1825,
+  1825, 1825, 1834, 1835, 1828, 1825, 1834, 1835, 1828, 1825, 1834, 1835, 1835,
+  1835, 1835, 1835, 1835, 1835, 1835, 1835, 1835, 1828, 1825, 1834, 1828, 1825,
+  1834, 1828, 1825, 1834, 1828, 1828, 1828, 1828, 1828, 1825, 1825, 1825, 1825,
+  1834, 1828, 1825, 1834, 1828, 1825, 1825, 1825, 1834, 1828, 1825, 1834, 1828,
+  1825, 1834, 1828, 1825, 1825, 1834, 1828, 1828, 1828, 1828, 1828, 1828, 1828,
+  1828, 1828, 1828, 1825, 1834, 1825, 1834, 1825, 1834, 1834, 1834, 1834, 1834,
+  1834, 1834, 1834, 1834, 1834, 1825, 1825, 1825, 1825, 1825, 1825, 1825, 1825,
+  1825, 1825};
+
+const std::vector<int> children = {
+  1113, 1149, 1572, 1660, 1595, 985,  1024, 77,   1727, 1551, 757,  1562, 891,
+  1581, 673,  1552, 1729, 421,  1274, 1195, 1154, 1150, 1690, 1152, 1264, 792,
+  9,    1038, 1593, 1580, 1628, 1712, 1685, 905,  341,  1100, 769,  1574, 502,
+  87,   1210, 1165, 1657, 1571, 1057, 1118, 538,  678,  215,  664,  1271, 1675,
+  1707, 1662, 813,  756,  1611, 1671, 670,  1037, 37,   1597, 125,  1119, 703,
+  576,  770,  767,  409,  1796, 1728, 1468, 1197, 1067, 492,  1296, 1155, 1078,
+  414,  852,  633,  103,  1553, 1088, 482,  784,  430,  1618, 1275, 899,  480,
+  710,  794,  578,  69,   1095, 1389, 291,  1412, 1765, 795,  46,   689,  1666,
+  630,  120,  1627, 283,  1440, 113,  1617, 1612, 1391, 1141, 860,  1540, 547,
+  1710, 1404, 1048, 53,   1080, 903,  327,  1557, 1400, 127,  1637, 75,   54,
+  1573, 500,  690,  2,    1789, 284,  691,  1146, 418,  116,  50,   57,   51,
+  115,  33,   1575, 1605, 1299, 1202, 303,  951,  766,  528,  838,  457,  988,
+  394,  1289, 134,  638,  1079, 1708, 539,  1123, 1288, 1664, 992,  265,  444,
+  231,  1589, 1060, 1186, 1695, 38,   294,  170,  1077, 1233, 1798, 1799, 1145,
+  472,  158,  393,  447,  467,  429,  494,  498,  403,  413,  438,  504,  1576,
+  1632, 1646, 1699, 1742, 96,   378,  524,  74,   1800, 1801, 843,  1781, 1592,
+  161,  746,  824,  1022, 701,  1619, 617,  19,   121,  1062, 1583, 588,  191,
+  1258, 31,   1287, 27,   1205, 605,  700,  1722, 1565, 1025, 1072, 1283, 569,
+  1768, 1103, 1591, 1802, 1803, 902,  720,  86,   825,  8,    28,   651,  317,
+  1635, 78,   1242, 722,  1156, 7,    1615, 206,  1467, 1413, 876,  364,  1598,
+  1582, 211,  980,  1705, 1108, 595,  808,  523,  1139, 1049, 1763, 1604, 1366,
+  1558, 1135, 776,  965,  1587, 292,  796,  1665, 1073, 594,  1178, 732,  981,
+  1297, 1689, 43,   357,  1044, 1753, 101,  774,  922,  1745, 872,  1748, 1193,
+  1538, 628,  1716, 489,  1004, 374,  1684, 72,   600,  1586, 1229, 1058, 1056,
+  1570, 150,  1341, 1395, 179,  1066, 828,  564,  1096, 758,  695,  1132, 108,
+  465,  1804, 1805, 1649, 10,   1680, 623,  263,  1206, 379,  606,  52,   1793,
+  432,  586,  1348, 286,  1302, 1730, 563,  1779, 656,  506,  947,  894,  1715,
+  1743, 926,  216,  209,  545,  847,  609,  884,  1323, 760,  1602, 1603, 601,
+  857,  30,   416,  1806, 1807, 1000, 147,  20,   1129, 1234, 1654, 596,  1331,
+  36,   477,  1142, 572,  832,  118,  1106, 1726, 1364, 994,  1459, 536,  295,
+  1041, 558,  1218, 1265, 140,  966,  629,  537,  862,  831,  133,  1751, 442,
+  61,   912,  1105, 1750, 152,  518,  916,  527,  906,  987,  952,  1008, 991,
+  958,  982,  517,  972,  1314, 724,  198,  1098, 591,  1121, 1687, 1147, 1308,
+  721,  1243, 1317, 1064, 632,  819,  487,  599,  205,  222,  963,  422,  5,
+  12,   350,  571,  491,  779,  1309, 1373, 304,  555,  950,  1338, 949,  1435,
+  1544, 440,  1775, 747,  804,  1273, 17,   208,  521,  593,  1339, 256,  1177,
+  535,  1606, 1679, 1009, 1307, 1795, 1655, 1724, 240,  1187, 1248, 1337, 954,
+  1563, 737,  1547, 1184, 49,   1790, 461,  308,  915,  842,  436,  1036, 646,
+  1361, 570,  566,  567,  573,  995,  526,  1738, 244,  1294, 1304, 1174, 55,
+  1808, 1809, 1179, 1785, 854,  247,  1070, 1241, 1622, 1653, 1487, 18,   1001,
+  1014, 1810, 1811, 1359, 1493, 1407, 998,  243,  1399, 707,  848,  1172, 742,
+  352,  717,  4,    1783, 1200, 173,  1269, 663,  543,  740,  727,  754,  698,
+  1711, 577,  382,  1285, 780,  1530, 137,  48,   1658, 626,  696,  174,  559,
+  1642, 192,  1176, 1151, 1272, 1403, 837,  1212, 1280, 68,   761,  1251, 44,
+  1019, 334,  735,  1281, 723,  1496, 1235, 1787, 873,  1081, 1330, 386,  123,
+  1767, 917,  560,  1128, 1739, 839,  970,  142,  568,  1388, 445,  144,  171,
+  84,   1381, 855,  35,   110,  371,  342,  160,  267,  400,  207,  337,  126,
+  1555, 574,  496,  687,  369,  1405, 718,  772,  420,  473,  443,  1523, 552,
+  462,  1778, 697,  1232, 1761, 182,  1013, 1082, 1153, 277,  1735, 1169, 870,
+  1059, 203,  483,  851,  299,  803,  786,  402,  238,  730,  948,  1065, 1470,
+  964,  929,  1207, 1046, 565,  1489, 1643, 510,  1717, 932,  1425, 471,  427,
+  1625, 1533, 1342, 1812, 1813, 1221, 307,  1432, 1746, 275,  1633, 329,  348,
+  384,  325,  361,  719,  946,  1731, 668,  892,  1368, 1236, 1542, 1554, 1567,
+  437,  94,   1579, 913,  751,  627,  1499, 157,  458,  1167, 1445, 836,  677,
+  324,  497,  1104, 368,  1620, 681,  655,  375,  771,  738,  381,  765,  715,
+  665,  685,  675,  1397, 1102, 398,  783,  1157, 1166, 887,  1362, 236,  130,
+  254,  1311, 1600, 1719, 974,  1670, 1398, 1780, 1458, 666,  511,  24,   408,
+  653,  178,  548,  390,  184,  112,  1099, 253,  356,  187,  1814, 1815, 1667,
+  29,   1652, 1721, 1744, 634,  888,  983,  820,  300,  1509, 1527, 1422, 1476,
+  1442, 1501, 435,  1703, 1396, 64,   648,  853,  610,  1663, 1720, 897,  1344,
+  1238, 516,  106,  530,  278,  533,  166,  684,  688,  1023, 306,  1143, 1209,
+  266,  1659, 790,  1270, 764,  185,  935,  513,  525,  800,  1351, 340,  1694,
+  597,  793,  1201, 1164, 624,  273,  81,   602,  1674, 676,  590,  805,  239,
+  953,  202,  1313, 1794, 507,  637,  22,   1415, 1786, 1777, 827,  241,  1335,
+  683,  1754, 388,  889,  725,  296,  488,  743,  499,  806,  1216, 900,  658,
+  311,  1516, 1277, 194,  907,  512,  694,  1279, 100,  1427, 328,  661,  14,
+  1371, 956,  959,  979,  1016, 1051, 1402, 977,  1084, 276,  1068, 1419, 584,
+  1408, 1111, 877,  335,  755,  97,   214,  434,  406,  1545, 252,  1336, 1047,
+  366,  1465, 1697, 1015, 1526, 1607, 788,  1002, 1588, 1758, 557,  1181, 1214,
+  1677, 608,  1668, 1012, 1211, 333,  798,  830,  1039, 1700, 603,  778,  941,
+  812,  925,  305,  404,  1137, 132,  546,  1772, 92,   1021, 1328, 1291, 1301,
+  1384, 181,  642,  1702, 111,  1669, 441,  509,  1374, 1594, 1464, 396,  1451,
+  1260, 1267, 180,  1463, 354,  1278, 986,  1494, 1029, 79,   0,    464,  1365,
+  1541, 229,  682,  957,  508,  616,  631,  1130, 540,  1208, 759,  762,  1491,
+  909,  313,  1375, 250,  927,  373,  1651, 826,  554,  1393, 1138, 331,  1528,
+  1020, 863,  258,  898,  844,  372,  816,  1011, 463,  45,   1411, 1764, 1017,
+  1816, 1817, 280,  1782, 224,  942,  1124, 1043, 1053, 1091, 1033, 1114, 1159,
+  1031, 310,  268,  731,  1284, 1741, 1479, 470,  782,  391,  1818, 1819, 1140,
+  1718, 1256, 389,  225,  640,  1531, 833,  1417, 1466, 1472, 501,  1490, 1469,
+  1492, 1437, 829,  1529, 1537, 1180, 1230, 450,  454,  154,  660,  714,  410,
+  486,  733,  650,  228,  1691, 439,  1511, 155,  930,  1681, 1085, 519,  1638,
+  515,  1190, 1268, 1723, 1144, 901,  1061, 1641, 343,  1355, 312,  1532, 1456,
+  104,  553,  748,  353,  1253, 289,  1225, 235,  1194, 1257, 383,  1192, 641,
+  607,  529,  575,  561,  619,  614,  579,  1198, 736,  1219, 1788, 1171, 919,
+  1820, 1821, 1406, 1244, 1791, 1647, 1298, 1776, 817,  1561, 122,  168,  105,
+  302,  520,  1148, 362,  93,   1255, 1822, 1823, 314,  95,   220,  886,  580,
+  1732, 933,  1136, 1162, 1539, 380,  734,  997,  1656, 1512, 1502, 1515, 1439,
+  1483, 1429, 1536, 840,  1525, 613,  320,  481,  773,  1548, 297,  1734, 274,
+  1379, 270,  1569, 255,  1378, 1661, 1369, 1175, 1704, 377,  1584, 1161, 1254,
+  41,   124,  1387, 367,  1549, 1127, 260,  1559, 604,  148,  1650, 581,  129,
+  1189, 1310, 1645, 424,  1089, 1543, 996,  138,  1319, 16,   1204, 585,  752,
+  1109, 1752, 1231, 1382, 264,  401,  583,  1185, 879,  810,  172,  217,  1629,
+  1401, 293,  1303, 645,  419,  598,  1069, 1824, 1825, 1771, 978,  25,   990,
+  1636, 1747, 119,  1506, 452,  1601, 693,  271,  878,  226,  880,  1826, 1827,
+  423,  918,  1321, 1828, 1829, 775,  850,  744,  1293, 883,  85,   1455, 1453,
+  1830, 1831, 1349, 864,  1286, 1383, 1416, 945,  621,  1784, 446,  1131, 592,
+  534,  639,  544,  643,  556,  612,  131,  177,  426,  1326, 71,   1290, 1762,
+  183,  890,  768,  73,   1259, 1332, 1122, 114,  1505, 814,  251,  204,  1220,
+  1623, 1599, 1457, 370,  1392, 893,  835,  1170, 1473, 726,  80,   699,  686,
+  674,  332,  923,  1028, 654,  943,  955,  309,  1026, 1433, 1423, 1443, 417,
+  145,  448,  392,  1737, 1514, 459,  503,  1578, 190,  1608, 745,  1500, 39,
+  1054, 1770, 1092, 1481, 1363, 221,  807,  1333, 460,  1203, 411,  495,  1312,
+  1320, 1358, 999,  622,  856,  210,  589,  920,  659,  1609, 615,  433,  1324,
+  1832, 1833, 23,   1173, 336,  1495, 1006, 102,  109,  153,  713,  156,  712,
+  1414, 227,  895,  1488, 365,  671,  1052, 532,  1117, 1522, 845,  358,  809,
+  315,  750,  40,   218,  1306, 1322, 1101, 1228, 484,  1115, 1709, 141,  868,
+  1486, 679,  821,  453,  1409, 151,  128,  531,  811,  1513, 1577, 1673, 249,
+  42,   904,  914,  1434, 1769, 822,  874,  34,   1083, 407,  1426, 1471, 1462,
+  1485, 1508, 199,  1524, 237,  189,  412,  474,  363,  387,  1226, 1713, 1682,
+  1692, 1560, 1347, 858,  1755, 1410, 1564, 90,   405,  644,  1672, 163,  399,
+  1094, 76,   1340, 107,  1484, 551,  781,  928,  1749, 753,  428,  1343, 1534,
+  1292, 1266, 1550, 1418, 338,  248,  1305, 1325, 1327, 1295, 1315, 1596, 466,
+  478,  1424, 618,  15,   1568, 1034, 143,  223,  242,  1158, 993,  1318, 910,
+  246,  1182, 1086, 67,   1,    1367, 1316, 1010, 245,  1346, 834,  787,  397,
+  485,  169,  261,  176,  962,  188,  704,  1239, 1030, 479,  1262, 1018, 763,
+  692,  908,  802,  739,  1436, 1356, 288,  376,  1160, 1055, 1693, 1372, 70,
+  971,  1003, 230,  59,   680,  818,  1688, 21,   186,  200,  456,  493,  47,
+  1168, 476,  11,   56,   849,  32,   791,  135,  162,  1614, 201,  885,  896,
+  165,  801,  117,  1475, 1093, 647,  415,  541,  475,  968,  321,  542,  702,
+  1360, 1075, 3,    323,  846,  815,  1535, 1376, 1725, 1040, 1706, 549,  1217,
+  871,  960,  1556, 1792, 1430, 1042, 1191, 667,  1759, 281,  449,  1252, 322,
+  1224, 1774, 285,  1448, 318,  26,   1546, 233,  936,  940,  98,   1756, 282,
+  1701, 716,  1520, 1420, 1300, 1245, 1678, 1766, 1454, 1461, 1566, 66,   212,
+  1449, 1510, 1714, 167,  330,  749,  550,  1610, 1757, 287,  937,  976,  636,
+  938,  587,  973,  1517, 562,  625,  1447, 1450, 1074, 1215, 861,  505,  60,
+  290,  1071, 635,  1090, 1125, 1063, 1760, 975,  193,  269,  728,  657,  881,
+  385,  196,  823,  934,  1385, 1350, 58,   1163, 82,   232,  866,  1249, 1477,
+  1478, 6,    99,   1736, 13,   1133, 298,  395,  859,  1222, 1482, 346,  1686,
+  1630, 841,  1183, 257,  1276, 1474, 234,  1199, 1196, 1390, 83,   708,  1035,
+  1126, 159,  1087, 662,  797,  924,  669,  1116, 1644, 989,  1626, 1698, 149,
+  431,  1834, 1835, 869,  1740, 469,  164,  921,  1521, 1120, 1446, 1282, 1452,
+  1507, 1246, 1045, 65,   1613, 785,  1188, 1027, 514,  455,  425,  1676, 944,
+  1444, 1696, 139,  1616, 1110, 1733, 195,  1107, 867,  351,  967,  88,   1112,
+  213,  882,  1263, 355,  1428, 969,  146,  349,  1370, 136,  1353, 875,  1460,
+  91,   799,  344,  451,  1380, 1032, 1480, 490,  1357, 1624, 1683, 611,  1261,
+  468,  1354, 620,  1345, 1352, 522,  582,  1223, 1590, 1240, 1773, 1386, 89,
+  1007, 1076, 62,   1497, 326,  1247, 1227, 1134, 1250, 63,   359,  1438, 1639,
+  197,  1394, 649,  911,  1631, 316,  729,  705,  931,  1640, 301,  1503, 1377,
+  706,  939,  1213, 175,  219,  272,  1329, 1621, 1585, 1648, 1050, 777,  1334,
+  1237, 1634, 1097, 345,  652,  319,  672,  961,  1519, 1421, 1431, 1441, 711,
+  360,  262,  984,  1005, 741,  347,  709,  789,  1504, 339,  279,  1518, 259,
+  1498, 865};
+
+const std::vector<float> lambdas = {
+  0.02839809, 0.02897638, 0.02939905, 0.03051391, 0.03062819, 0.03100868,
+  0.0310236,  0.03115885, 0.03152833, 0.03160698, 0.0316386,  0.03171807,
+  0.03175003, 0.03202563, 0.03212463, 0.03266858, 0.03266858, 0.03280894,
+  0.03289758, 0.0329154,  0.03320446, 0.0335578,  0.03357671, 0.03367175,
+  0.03372916, 0.03384487, 0.03402069, 0.0340404,  0.03407991, 0.03415935,
+  0.03423935, 0.03431991, 0.03436041, 0.03440105, 0.03450328, 0.03466876,
+  0.03466876, 0.03471051, 0.03481553, 0.03485781, 0.03498557, 0.03502847,
+  0.03507153, 0.03513642, 0.03517988, 0.03520167, 0.0352235,  0.03524537,
+  0.03524537, 0.03528923, 0.03528923, 0.03533326, 0.03535534, 0.03539962,
+  0.03546635, 0.03546635, 0.03548867, 0.03564615, 0.03564615, 0.03566882,
+  0.03573708, 0.03582872, 0.03582872, 0.0358748,  0.03594426, 0.03606092,
+  0.03608439, 0.03610791, 0.03617873, 0.03620243, 0.03622618, 0.03624997,
+  0.03627381, 0.03632164, 0.03634562, 0.03636965, 0.03636965, 0.03636965,
+  0.03644203, 0.03649052, 0.03651484, 0.0365392,  0.0365392,  0.03658809,
+  0.0366126,  0.03666178, 0.03668644, 0.03673592, 0.03673592, 0.03681051,
+  0.03681051, 0.03683547, 0.03686049, 0.03688556, 0.03691067, 0.03693584,
+  0.03696106, 0.03696106, 0.03708795, 0.03711348, 0.03711348, 0.03711348,
+  0.0371904,  0.03729371, 0.03729371, 0.03731967, 0.03734568, 0.03737175,
+  0.03752933, 0.03752933, 0.0375823,  0.03760887, 0.0376355,  0.0376355,
+  0.03766218, 0.03774257, 0.03779645, 0.0378777,  0.03793216, 0.03793216,
+  0.03798686, 0.03806935, 0.03809697, 0.03809697, 0.03818018, 0.03818018,
+  0.03823596, 0.03826394, 0.03826394, 0.03826394, 0.03834825, 0.03837648,
+  0.03846154, 0.03854717, 0.03857584, 0.03857584, 0.03866223, 0.03872015,
+  0.03872015, 0.03872015, 0.03872015, 0.03872015, 0.03872015, 0.03872015,
+  0.03872015, 0.03877834, 0.03877834, 0.03883678, 0.03883678, 0.03883678,
+  0.0388661,  0.0388661,  0.0388661,  0.03889549, 0.03889549, 0.03895447,
+  0.03895447, 0.03898406, 0.03904344, 0.03904344, 0.03907323, 0.03907323,
+  0.03907323, 0.03910309, 0.03913302, 0.03919309, 0.03922323, 0.03922323,
+  0.03922323, 0.03922323, 0.03931406, 0.03934447, 0.03943615, 0.03943615,
+  0.03946685, 0.03946685, 0.03949763, 0.03949763, 0.03955939, 0.03955939,
+  0.03955939, 0.03959038, 0.04055536, 0.03965258, 0.04833682, 0.04833682,
+  0.04833682, 0.04833682, 0.04833682, 0.04833682, 0.04833682, 0.04833682,
+  0.04833682, 0.04833682, 0.03968379, 0.03974643, 0.03974643, 0.03974643,
+  0.03974643, 0.03977786, 0.03977786, 0.03977786, 0.03977786, 0.03977786,
+  0.03977786, 0.03977786, 0.03984095, 0.04134491, 0.03984095, 0.03984095,
+  0.04283529, 0.03987261, 0.04402255, 0.03990434, 0.0451754,  0.03990434,
+  0.03990434, 0.03990434, 0.03990434, 0.04545455, 0.03993615, 0.04598005,
+  0.03993615, 0.04607757, 0.03996804, 0.04622502, 0.04,       0.04,
+  0.04627448, 0.04003204, 0.04637389, 0.04006415, 0.04642383, 0.04006415,
+  0.04647394, 0.04016097, 0.046676,   0.04019339, 0.04019339, 0.04703604,
+  0.04025848, 0.04032389, 0.04783649, 0.04025848, 0.04025848, 0.04025848,
+  0.04085889, 0.04085889, 0.04856429, 0.04032389, 0.04032389, 0.04032389,
+  0.04089304, 0.04873702, 0.04032389, 0.04106508, 0.04956816, 0.04035672,
+  0.04106508, 0.04962917, 0.0404226,  0.0411345,  0.04975186, 0.04045567,
+  0.04120428, 0.04987547, 0.04048882, 0.0418487,  0.0418487,  0.05,
+  0.04052204, 0.04214498, 0.05031546, 0.04052204, 0.04225771, 0.05037927,
+  0.04058875, 0.04271788, 0.05044333, 0.05044333, 0.04062222, 0.04271788,
+  0.05057217, 0.04062222, 0.04287465, 0.05063697, 0.05063697, 0.04065578,
+  0.04291411, 0.05070201, 0.04065578, 0.04311306, 0.05083286, 0.04065578,
+  0.0433963,  0.05150262, 0.04072315, 0.04347826, 0.05157106, 0.04079085,
+  0.04389513, 0.05198752, 0.04082483, 0.04082483, 0.04419417, 0.04419417,
+  0.0521286,  0.04085889, 0.04432422, 0.05227084, 0.04089304, 0.04445542,
+  0.04445542, 0.05234239, 0.04092728, 0.04454354, 0.05255883, 0.0409616,
+  0.04454354, 0.05263158, 0.0409616,  0.04476615, 0.05270463, 0.0409616,
+  0.04485613, 0.05270463, 0.040996,   0.040996,   0.0451754,  0.05285164,
+  0.0410305,  0.04222003, 0.04522156, 0.05292561, 0.0410305,  0.04229549,
+  0.04526787, 0.0531494,  0.04106508, 0.04360207, 0.04559608, 0.05345225,
+  0.04109975, 0.04109975, 0.04476615, 0.04564355, 0.05352877, 0.0411345,
+  0.04593152, 0.04578685, 0.05368281, 0.04116935, 0.0474579,  0.04607757,
+  0.05368281, 0.04116935, 0.04116935, 0.04767313, 0.04617571, 0.05383819,
+  0.04120428, 0.04120428, 0.04120428, 0.04828045, 0.04642383, 0.05407381,
+  0.05407381, 0.04120428, 0.04120428, 0.04981355, 0.04642383, 0.05415304,
+  0.04127442, 0.04130962, 0.04130962, 0.05012547, 0.04657464, 0.05455447,
+  0.04127442, 0.04134491, 0.05096472, 0.05096472, 0.046676,   0.05488213,
+  0.04130962, 0.04173919, 0.05191741, 0.04688072, 0.05504819, 0.04130962,
+  0.0417756,  0.05263158, 0.0469841,  0.0469841,  0.05513178, 0.04134491,
+  0.0421076,  0.05383819, 0.0469841,  0.05521576, 0.04138029, 0.04218245,
+  0.05439283, 0.04729838, 0.04729838, 0.05538488, 0.04141577, 0.04237136,
+  0.04237136, 0.05479966, 0.05479966, 0.05479966, 0.05479966, 0.05479966,
+  0.05479966, 0.05479966, 0.05479966, 0.05479966, 0.05479966, 0.05479966,
+  0.04740455, 0.05538488, 0.04141577, 0.04141577, 0.04295368, 0.0474579,
+  0.05564149, 0.04145133, 0.04145133, 0.04299336, 0.04761905, 0.05598925,
+  0.04145133, 0.04303315, 0.04789131, 0.05607722, 0.04148699, 0.04303315,
+  0.04850713, 0.04850713, 0.05607722, 0.04155858, 0.04319342, 0.0489116,
+  0.05634362, 0.04159452, 0.04159452, 0.04389513, 0.04897021, 0.05643326,
+  0.04163054, 0.04163054, 0.04393748, 0.04902903, 0.05652334, 0.04166667,
+  0.04419417, 0.04944682, 0.05688801, 0.04166667, 0.04428074, 0.04950738,
+  0.05698029, 0.04173919, 0.04454354, 0.05025189, 0.05707301, 0.05707301,
+  0.0417756,  0.0417756,  0.0445878,  0.05025189, 0.0571662,  0.04188539,
+  0.04508348, 0.04508348, 0.05025189, 0.05725983, 0.04188539, 0.04508348,
+  0.05050763, 0.05735393, 0.04188539, 0.04526787, 0.05057217, 0.05783149,
+  0.04192218, 0.04526787, 0.05063697, 0.05812382, 0.04192218, 0.04526787,
+  0.05070201, 0.05812382, 0.04195907, 0.04545455, 0.04545455, 0.04545455,
+  0.04545455, 0.05070201, 0.05822225, 0.04199605, 0.04559608, 0.05103104,
+  0.05103104, 0.05103104, 0.05832118, 0.04199605, 0.04199605, 0.04564355,
+  0.05157106, 0.05872202, 0.04199605, 0.0421076,  0.04593152, 0.05170877,
+  0.05170877, 0.05882353, 0.04203314, 0.04225771, 0.04593152, 0.05191741,
+  0.05191741, 0.05902813, 0.05902813, 0.04207032, 0.04244764, 0.04617571,
+  0.05191741, 0.05399492, 0.05913124, 0.0421076,  0.0421076,  0.0421076,
+  0.0421076,  0.04275691, 0.04637389, 0.0521286,  0.05415304, 0.05415304,
+  0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05415304,
+  0.05415304, 0.05415304, 0.05933908, 0.04222003, 0.04291411, 0.04729838,
+  0.05248639, 0.05944383, 0.04229549, 0.04295368, 0.04740455, 0.05255883,
+  0.05255883, 0.059655,   0.04229549, 0.04229549, 0.04351941, 0.04751143,
+  0.04751143, 0.05263158, 0.05976143, 0.04233338, 0.04415108, 0.04751143,
+  0.05270463, 0.05270463, 0.05270463, 0.05997601, 0.04233338, 0.04419417,
+  0.04756515, 0.05277798, 0.06008418, 0.04237136, 0.0442374,  0.04761905,
+  0.05277798, 0.06019293, 0.04237136, 0.04445542, 0.04778185, 0.05307449,
+  0.06030227, 0.06030227, 0.04244764, 0.04449942, 0.04783649, 0.0531494,
+  0.06052275, 0.04248593, 0.04485613, 0.04485613, 0.04783649, 0.05345225,
+  0.06063391, 0.04248593, 0.04494666, 0.04794633, 0.05391639, 0.06063391,
+  0.04252433, 0.04499213, 0.04800154, 0.05399492, 0.06074567, 0.06074567,
+  0.04256283, 0.04503773, 0.04503773, 0.04816831, 0.05399492, 0.06108472,
+  0.06108472, 0.04256283, 0.04536092, 0.04822428, 0.05407381, 0.06119901,
+  0.04260143, 0.04545455, 0.04828045, 0.04828045, 0.05415304, 0.05415304,
+  0.05415304, 0.06142951, 0.06142951, 0.04264014, 0.04588315, 0.04850713,
+  0.05423261, 0.06142951, 0.04264014, 0.04642383, 0.04856429, 0.05423261,
+  0.05423261, 0.06142951, 0.04271788, 0.04652421, 0.04856429, 0.05447347,
+  0.06154575, 0.06154575, 0.04275691, 0.04677803, 0.04856429, 0.05488213,
+  0.06154575, 0.04283529, 0.04283529, 0.04682929, 0.0488532,  0.05564149,
+  0.06178021, 0.04287465, 0.04688072, 0.04897021, 0.05572782, 0.06189845,
+  0.04291411, 0.04291411, 0.04708816, 0.04920678, 0.05572782, 0.06213698,
+  0.04303315, 0.04303315, 0.04303315, 0.04303315, 0.04303315, 0.04303315,
+  0.04303315, 0.04376881, 0.04735137, 0.04735137, 0.04932636, 0.04932636,
+  0.05581456, 0.06213698, 0.04303315, 0.0451754,  0.04751143, 0.04938648,
+  0.0559017,  0.06237829, 0.04303315, 0.04602873, 0.04751143, 0.04944682,
+  0.05634362, 0.0625,     0.0625,     0.0625,     0.04311306, 0.0469841,
+  0.04756515, 0.04756515, 0.04956816, 0.05652334, 0.06274558, 0.04311306,
+  0.0474579,  0.0474579,  0.0474579,  0.0474579,  0.0474579,  0.0474579,
+  0.0474579,  0.0474579,  0.0474579,  0.0474579,  0.04783649, 0.04962917,
+  0.04962917, 0.05652334, 0.06274558, 0.04315319, 0.04794633, 0.04962917,
+  0.05688801, 0.06274558, 0.04315319, 0.04811252, 0.0496904,  0.05688801,
+  0.06286946, 0.04319342, 0.04845016, 0.05006262, 0.05707301, 0.06324555,
+  0.04319342, 0.04850713, 0.05025189, 0.05725983, 0.06350006, 0.04323377,
+  0.04856429, 0.05025189, 0.05725983, 0.06362848, 0.04323377, 0.04862166,
+  0.05044333, 0.0574485,  0.0574485,  0.06401844, 0.04323377, 0.04897021,
+  0.05050763, 0.05050763, 0.05862104, 0.05783149, 0.05783149, 0.05783149,
+  0.05783149, 0.05783149, 0.05783149, 0.05783149, 0.05783149, 0.05783149,
+  0.05783149, 0.06454972, 0.06454972, 0.04331481, 0.04902903, 0.05050763,
+  0.05050763, 0.05933908, 0.06482037, 0.0433555,  0.04914732, 0.05057217,
+  0.05954913, 0.06482037, 0.0433555,  0.04944682, 0.05103104, 0.06008418,
+  0.06482037, 0.0433963,  0.0433963,  0.04950738, 0.05109761, 0.05109761,
+  0.06063391, 0.06509446, 0.04351941, 0.04950738, 0.05129892, 0.06074567,
+  0.06523281, 0.06523281, 0.04351941, 0.04351941, 0.0496904,  0.0496904,
+  0.05129892, 0.06108472, 0.06108472, 0.06108472, 0.06108472, 0.06108472,
+  0.06108472, 0.06108472, 0.06108472, 0.06108472, 0.06108472, 0.06565322,
+  0.04356068, 0.04356068, 0.04993762, 0.05157106, 0.06565322, 0.04360207,
+  0.04360207, 0.05,       0.05,       0.05157106, 0.06579517, 0.04364358,
+  0.05012547, 0.05163978, 0.05163978, 0.06608186, 0.04364358, 0.05012547,
+  0.05163978, 0.05163978, 0.06608186, 0.0436852,  0.0436852,  0.05018856,
+  0.05184758, 0.06681531, 0.04372695, 0.05037927, 0.0521286,  0.06726728,
+  0.06726728, 0.04376881, 0.05037927, 0.05241424, 0.06757374, 0.06757374,
+  0.0438108,  0.05037927, 0.05277798, 0.06772855, 0.0438108,  0.05044333,
+  0.05330018, 0.05330018, 0.05330018, 0.05330018, 0.05330018, 0.05330018,
+  0.05330018, 0.05330018, 0.05330018, 0.06772855, 0.0438529,  0.05063697,
+  0.05063697, 0.05063697, 0.05330018, 0.06804138, 0.06804138, 0.04389513,
+  0.05083286, 0.05337605, 0.06819943, 0.06819943, 0.06819943, 0.06819943,
+  0.06819943, 0.04397995, 0.05109761, 0.05352877, 0.06851887, 0.04397995,
+  0.05116445, 0.05116445, 0.05352877, 0.06900656, 0.04402255, 0.04402255,
+  0.05116445, 0.05116445, 0.05360563, 0.06917145, 0.04406526, 0.04406526,
+  0.05143445, 0.05376033, 0.05376033, 0.05376033, 0.05376033, 0.06917145,
+  0.04415108, 0.05150262, 0.05376033, 0.0695048,  0.0695048,  0.0695048,
+  0.0695048,  0.04415108, 0.05163978, 0.05376033, 0.070014,   0.04419417,
+  0.04419417, 0.04419417, 0.05177804, 0.05177804, 0.05177804, 0.05177804,
+  0.05391639, 0.070014,   0.0442374,  0.05198752, 0.05415304, 0.07106691,
+  0.0442374,  0.0521286,  0.05415304, 0.07124705, 0.07124705, 0.07124705,
+  0.04428074, 0.05227084, 0.05431254, 0.07161149, 0.04428074, 0.05255883,
+  0.05439283, 0.07179582, 0.07179582, 0.07179582, 0.07179582, 0.07179582,
+  0.07179582, 0.07179582, 0.07179582, 0.07179582, 0.07179582, 0.04432422,
+  0.05263158, 0.05447347, 0.04436783, 0.05263158, 0.05455447, 0.05455447,
+  0.05455447, 0.04441156, 0.05270463, 0.05471757, 0.04441156, 0.05285164,
+  0.05547002, 0.04441156, 0.05307449, 0.05547002, 0.04445542, 0.04445542,
+  0.05322463, 0.05555556, 0.05555556, 0.04449942, 0.05330018, 0.05598925,
+  0.04449942, 0.05330018, 0.05698029, 0.04449942, 0.05337605, 0.0571662,
+  0.04454354, 0.05360563, 0.05360563, 0.05763904, 0.04463218, 0.04463218,
+  0.05407381, 0.05773503, 0.04472136, 0.04463218, 0.05415304, 0.05415304,
+  0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05832118, 0.05832118,
+  0.05832118, 0.05832118, 0.04476615, 0.04476615, 0.04467671, 0.05431254,
+  0.05892557, 0.04481107, 0.04476615, 0.05471757, 0.05471757, 0.06119901,
+  0.06119901, 0.04481107, 0.04481107, 0.05538488, 0.05479966, 0.06237829,
+  0.06237829, 0.06237829, 0.06237829, 0.06237829, 0.06237829, 0.06237829,
+  0.06237829, 0.06237829, 0.06237829, 0.04485613, 0.04485613, 0.04485613,
+  0.04485613, 0.04485613, 0.05538488, 0.05538488, 0.05538488, 0.05538488,
+  0.05538488, 0.05538488, 0.05538488, 0.05538488, 0.05538488, 0.05538488,
+  0.05496497, 0.04485613, 0.04485613, 0.04490133, 0.04490133, 0.05530013,
+  0.04499213, 0.04494666, 0.05538488, 0.04503773, 0.04499213, 0.05538488,
+  0.04512937, 0.04499213, 0.04499213, 0.04499213, 0.05555556, 0.05555556,
+  0.05555556, 0.04512937, 0.04508348, 0.05572782, 0.0451754,  0.04512937,
+  0.04512937, 0.05607722, 0.04522156, 0.04512937, 0.0561656,  0.04522156,
+  0.04526787, 0.0562544,  0.04531433, 0.04526787, 0.04526787, 0.04526787,
+  0.04526787, 0.04526787, 0.04526787, 0.04526787, 0.04526787, 0.04526787,
+  0.05661385, 0.04536092, 0.04531433, 0.05698029, 0.05698029, 0.05698029,
+  0.04540766, 0.04540766, 0.04536092, 0.05698029, 0.05698029, 0.04598005,
+  0.04540766, 0.04540766, 0.05698029, 0.04607757, 0.04540766, 0.04540766,
+  0.04540766, 0.04540766, 0.05754353, 0.05754353, 0.04632411, 0.04540766,
+  0.04550158, 0.05763904, 0.05763904, 0.04647394, 0.04540766, 0.04559608,
+  0.05862104, 0.05763904, 0.04693233, 0.04554875, 0.04569117, 0.04569117,
+  0.05933908, 0.05802589, 0.04708816, 0.04559608, 0.04583492, 0.059655,
+  0.059655,   0.059655,   0.059655,   0.059655,   0.059655,   0.059655,
+  0.059655,   0.059655,   0.059655,   0.05852057, 0.0477274,  0.04559608,
+  0.04593152, 0.05902813, 0.04783649, 0.04564355, 0.04593152, 0.05954913,
+  0.04873702, 0.04569117, 0.04593152, 0.05986843, 0.04950738, 0.04578685,
+  0.04598005, 0.06019293, 0.06019293, 0.06019293, 0.06019293, 0.06019293,
+  0.06019293, 0.06019293, 0.06019293, 0.06019293, 0.06019293, 0.06019293,
+  0.06019293, 0.04962917, 0.04578685, 0.04602873, 0.0496904,  0.04578685,
+  0.04602873, 0.04602873, 0.04987547, 0.04583492, 0.04607757, 0.04607757,
+  0.05031546, 0.04588315, 0.04617571, 0.05031546, 0.04593152, 0.04617571,
+  0.05037927, 0.05037927, 0.04607757, 0.04622502, 0.05057217, 0.04612656,
+  0.04627448, 0.05076731, 0.04622502, 0.04642383, 0.05123155, 0.04627448,
+  0.04652421, 0.05150262, 0.04642383, 0.04657464, 0.05170877, 0.04647394,
+  0.046676,   0.05177804, 0.04657464, 0.04672693, 0.04672693, 0.05191741,
+  0.04657464, 0.04677803, 0.04688072, 0.05205792, 0.04662524, 0.04688072,
+  0.04703604, 0.05234239, 0.05234239, 0.04672693, 0.0469841,  0.0469841,
+  0.04708816, 0.05255883, 0.04682929, 0.04682929, 0.04703604, 0.04714045,
+  0.05322463, 0.0469841,  0.0469841,  0.04682929, 0.04708816, 0.04719292,
+  0.05330018, 0.04714045, 0.0469841,  0.04688072, 0.04688072, 0.04708816,
+  0.04708816, 0.04729838, 0.05383819, 0.04724556, 0.04724556, 0.04719292,
+  0.04688072, 0.04714045, 0.04714045, 0.0474579,  0.05399492, 0.04735137,
+  0.04735137, 0.04735137, 0.04735137, 0.04735137, 0.04735137, 0.04735137,
+  0.04751143, 0.04751143, 0.04714045, 0.04714045, 0.04714045, 0.04751143,
+  0.05407381, 0.04735137, 0.04756515, 0.04756515, 0.04735137, 0.04724556,
+  0.04756515, 0.05415304, 0.0474579,  0.04778185, 0.04761905, 0.04740455,
+  0.04724556, 0.04789131, 0.05423261, 0.04756515, 0.04873702, 0.04811252,
+  0.0477274,  0.04740455, 0.04794633, 0.04794633, 0.05423261, 0.04761905,
+  0.04914732, 0.04987547, 0.04987547, 0.04987547, 0.04987547, 0.04987547,
+  0.04987547, 0.04987547, 0.04987547, 0.04987547, 0.04987547, 0.04987547,
+  0.04987547, 0.04987547, 0.04987547, 0.04778185, 0.04740455, 0.04800154,
+  0.05431254, 0.04767313, 0.04926646, 0.04778185, 0.04751143, 0.04751143,
+  0.04800154, 0.05439283, 0.0477274,  0.04950738, 0.04789131, 0.04767313,
+  0.04811252, 0.05439283, 0.05439283, 0.04794633, 0.04981355, 0.04800154,
+  0.04778185, 0.04778185, 0.04778185, 0.04778185, 0.04778185, 0.04778185,
+  0.04778185, 0.04778185, 0.04816831, 0.05439283, 0.04811252, 0.04981355,
+  0.04805693, 0.04778185, 0.04816831, 0.05447347, 0.04822428, 0.04987547,
+  0.04839339, 0.04778185, 0.04778185, 0.04850713, 0.05455447, 0.04822428,
+  0.04993762, 0.04845016, 0.04778185, 0.04794633, 0.04850713, 0.05479966,
+  0.05479966, 0.05479966, 0.04845016, 0.05050763, 0.04856429, 0.04856429,
+  0.04778185, 0.04794633, 0.04856429, 0.05496497, 0.04845016, 0.05057217,
+  0.04873702, 0.04778185, 0.04805693, 0.048795,   0.05521576, 0.04850713,
+  0.05076731, 0.048795,   0.04811252, 0.04811252, 0.04811252, 0.04897021,
+  0.05538488, 0.048795,   0.05184758, 0.0488532,  0.04833682, 0.04822428,
+  0.04932636, 0.05538488, 0.0488532,  0.05227084, 0.0488532,  0.04833682,
+  0.04828045, 0.04944682, 0.05547002, 0.05547002, 0.0489116,  0.05330018,
+  0.04920678, 0.04920678, 0.04920678, 0.04845016, 0.04833682, 0.04944682,
+  0.05547002, 0.04908807, 0.05337605, 0.05337605, 0.05337605, 0.05337605,
+  0.05337605, 0.05337605, 0.04938648, 0.04850713, 0.04833682, 0.04944682,
+  0.05555556, 0.05555556, 0.04914732, 0.05337605, 0.04950738, 0.04867924,
+  0.04867924, 0.04867924, 0.04862166, 0.04950738, 0.05572782, 0.05572782,
+  0.04926646, 0.04926646, 0.05360563, 0.04950738, 0.04950738, 0.04867924,
+  0.04873702, 0.04950738, 0.05661385, 0.0496904,  0.0496904,  0.05368281,
+  0.04962917, 0.04867924, 0.0489116,  0.04962917, 0.05679618, 0.04975186,
+  0.05383819, 0.05383819, 0.04975186, 0.04873702, 0.04908807, 0.04908807,
+  0.0496904,  0.05688801, 0.05076731, 0.05076731, 0.05076731, 0.05076731,
+  0.05076731, 0.05076731, 0.05076731, 0.05407381, 0.04981355, 0.04981355,
+  0.048795,   0.04987547, 0.04987547, 0.04987547, 0.04975186, 0.05688801,
+  0.05076731, 0.05439283, 0.04987547, 0.04987547, 0.04897021, 0.05006262,
+  0.05006262, 0.04981355, 0.05688801, 0.05083286, 0.05547002, 0.04993762,
+  0.04987547, 0.05018856, 0.04993762, 0.05698029, 0.05089866, 0.05598925,
+  0.05598925, 0.05,       0.05037927, 0.05116445, 0.04993762, 0.05754353,
+  0.05754353, 0.05754353, 0.05157106, 0.05598925, 0.05006262, 0.05096472,
+  0.05241424, 0.05241424, 0.04993762, 0.05783149, 0.05227084, 0.05643326,
+  0.05012547, 0.05109761, 0.05285164, 0.05031546, 0.05802589, 0.05802589,
+  0.05270463, 0.05661385, 0.05025189, 0.05157106, 0.05447347, 0.05031546,
+  0.05812382, 0.05285164, 0.05285164, 0.0567048,  0.0567048,  0.0567048,
+  0.0567048,  0.0567048,  0.0567048,  0.0567048,  0.0567048,  0.0567048,
+  0.0567048,  0.05044333, 0.0521286,  0.05463584, 0.05463584, 0.05463584,
+  0.05463584, 0.05463584, 0.05463584, 0.05463584, 0.05463584, 0.05463584,
+  0.05463584, 0.05037927, 0.05842062, 0.05330018, 0.05050763, 0.05277798,
+  0.05037927, 0.05852057, 0.05852057, 0.05852057, 0.05337605, 0.05057217,
+  0.05292561, 0.05037927, 0.05862104, 0.05345225, 0.05057217, 0.05292561,
+  0.05044333, 0.05872202, 0.05368281, 0.05063697, 0.05292561, 0.05044333,
+  0.05923489, 0.05923489, 0.05415304, 0.05063697, 0.05299989, 0.05057217,
+  0.05933908, 0.05415304, 0.05083286, 0.05345225, 0.05070201, 0.05944383,
+  0.05944383, 0.05944383, 0.0559017,  0.05089866, 0.05352877, 0.05076731,
+  0.05954913, 0.0559017,  0.05109761, 0.05109761, 0.05360563, 0.05096472,
+  0.05096472, 0.059655,   0.059655,   0.0562544,  0.05123155, 0.05368281,
+  0.05109761, 0.05976143, 0.05634362, 0.05634362, 0.05157106, 0.05399492,
+  0.05129892, 0.05997601, 0.05997601, 0.05997601, 0.05997601, 0.0567048,
+  0.05163978, 0.05407381, 0.05143445, 0.06008418, 0.06008418, 0.05679618,
+  0.05184758, 0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05415304,
+  0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05415304, 0.05415304,
+  0.05170877, 0.06041221, 0.05688801, 0.05241424, 0.05191741, 0.06052275,
+  0.05698029, 0.05248639, 0.05198752, 0.05198752, 0.06097108, 0.05754353,
+  0.05255883, 0.05205792, 0.05205792, 0.06108472, 0.05832118, 0.05263158,
+  0.05227084, 0.06108472, 0.05862104, 0.05270463, 0.05248639, 0.05248639,
+  0.06119901, 0.06119901, 0.06119901, 0.06119901, 0.06085806, 0.05307449,
+  0.05255883, 0.05255883, 0.06119901, 0.06108472, 0.05376033, 0.05263158,
+  0.06131393, 0.06213698, 0.05383819, 0.05270463, 0.06142951, 0.06142951,
+  0.06237829, 0.05423261, 0.05277798, 0.06142951, 0.06142951, 0.06262243,
+  0.05423261, 0.05285164, 0.06189845, 0.06286946, 0.05439283, 0.05307449,
+  0.05307449, 0.05307449, 0.06201737, 0.06482037, 0.05455447, 0.05330018,
+  0.06237829, 0.06917145, 0.05463584, 0.05415304, 0.05415304, 0.05415304,
+  0.0625,     0.06984303, 0.05496497, 0.05496497, 0.05423261, 0.0625,
+  0.0625,     0.07124705, 0.05496497, 0.05431254, 0.06262243, 0.06262243,
+  0.0625,     0.07161149, 0.05504819, 0.05504819, 0.05504819, 0.05504819,
+  0.05439283, 0.06286946, 0.0625,     0.07216878, 0.05513178, 0.05513178,
+  0.05513178, 0.05513178, 0.05513178, 0.05513178, 0.05513178, 0.05513178,
+  0.05513178, 0.05513178, 0.05513178, 0.05513178, 0.05447347, 0.06337243,
+  0.06324555, 0.07254763, 0.05447347, 0.06337243, 0.06337243, 0.06324555,
+  0.0729325,  0.05455447, 0.06375767, 0.06337243, 0.07392213, 0.05463584,
+  0.06495698, 0.06337243, 0.0745356,  0.05479966, 0.06495698, 0.06454972,
+  0.0751646,  0.05504819, 0.05504819, 0.05504819, 0.06509446, 0.06482037,
+  0.07624929, 0.05513178, 0.06523281, 0.06509446, 0.07624929, 0.05538488,
+  0.06537205, 0.06523281, 0.06523281, 0.06523281, 0.06523281, 0.06523281,
+  0.06523281, 0.06523281, 0.06523281, 0.06523281, 0.06523281, 0.07647191,
+  0.05538488, 0.06579517, 0.07738232, 0.05555556, 0.06637233, 0.07784989,
+  0.05555556, 0.06666667, 0.07784989, 0.07784989, 0.07784989, 0.07784989,
+  0.07784989, 0.05572782, 0.05572782, 0.05572782, 0.05572782, 0.06666667,
+  0.07808688, 0.0559017,  0.06681531, 0.08084521, 0.05607722, 0.05607722,
+  0.05607722, 0.06726728, 0.08333333, 0.05652334, 0.06819943, 0.08333333,
+  0.05679618, 0.06835859, 0.08333333, 0.05832118, 0.05832118, 0.06868028,
+  0.08703883, 0.08703883, 0.08703883, 0.08703883, 0.08703883, 0.08703883,
+  0.08703883, 0.08703883, 0.08703883, 0.08703883, 0.05832118, 0.06900656,
+  0.05852057, 0.06900656, 0.05892557, 0.06917145, 0.06917145, 0.06917145,
+  0.06917145, 0.06917145, 0.06917145, 0.06917145, 0.06917145, 0.06917145,
+  0.06917145, 0.05902813, 0.05902813, 0.05902813, 0.05902813, 0.05902813,
+  0.05902813, 0.05902813, 0.05902813, 0.05902813, 0.05902813};
+
+const std::vector<int> sizes = {
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1607, 11,  1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   176, 1420, 1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1254, 148, 1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1197, 27, 1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1037,
+  148, 1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   848, 159,  1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  65,  11,  1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   805, 14,  1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   16,
+  10,  1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   387,  352,  1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 11,   51,  1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    163, 205, 1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    12, 18, 1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 185,  113, 1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    157, 22,  1,    1,  1,  108, 49,  1,   1,    1,    1,   1,
+  1,   1, 1, 82,   97,  1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   44,  35,   1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   33,  19,   1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1,   1,   1,    1,    1,   1,
+  1,   1, 1, 1,    1,   1,   1,    1,  1,  1,   1};
+};  // namespace Digits
+
+const std::vector<ClusterSelectionInputs<float, int>> cluster_selection_inputs =
+  {{150,
+    5,
+    10,
+    Iris::parents,
+    Iris::children,
+    Iris::lambdas,
+    Iris::sizes,
+    Common::CLUSTER_SELECTION_METHOD::EOM,
+    false,
+    0.0,
+    {1.,      1.,      0.92582, 0.92582, 1.,      0.63246, 0.7746,  1.,
+     0.67937, 1.,      0.73855, 0.8165,  1.,      0.4899,  0.42008, 0.38255,
+     0.61237, 1.,      0.4714,  0.7746,  0.67937, 0.86603, 0.45486, 0.63246,
+     0.54772, 0.8165,  0.92582, 1.,      1.,      1.,      1.,      0.70711,
+     0.53452, 0.51075, 1.,      0.73855, 0.67937, 0.8165,  0.8165,  1.,
+     1.,      0.30861, 0.7746,  0.57735, 0.51075, 0.92582, 0.73855, 1.,
+     0.86603, 1.,      0.8165,  1.,      0.83205, 0.97333, 1.,      1.,
+     0.92582, 0.53882, 1.,      0.78784, 0.58835, 1.,      0.72761, 0.97333,
+     0.78784, 1.,      1.,      1.,      0.6,     1.,      0.90453, 1.,
+     0.97333, 0.92582, 1.,      1.,      1.,      1.,      1.,      0.90453,
+     1.,      0.97333, 1.,      1.,      0.83205, 0.83205, 1.,      0.68825,
+     1.,      1.,      1.,      1.,      1.,      0.58835, 1.,      1.,
+     1.,      1.,      0.51832, 1.,      0.69749, 1.,      0.84853, 1.,
+     1.,      0.69749, 0.48038, 0.762,   0.67937, 0.52623, 0.90453, 1.,
+     1.,      0.7746,  0.66259, 1.,      1.,      0.41603, 0.43994, 0.647,
+     1.,      0.86603, 0.60609, 1.,      1.,      0.65465, 1.,      1.,
+     1.,      0.6,     0.78784, 0.41404, 0.90453, 0.92582, 0.60609, 0.60609,
+     0.84853, 0.92582, 0.97333, 1.,      1.,      0.8165,  1.,      1.,
+     0.97333, 1.,      0.88465, 1.,      0.67937, 1.},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}},
+   {150,
+    5,
+    10,
+    Iris::parents,
+    Iris::children,
+    Iris::lambdas,
+    Iris::sizes,
+    Common::CLUSTER_SELECTION_METHOD::EOM,
+    true,
+    50.0,
+    {1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
+     1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+   {1797,
+    5,
+    10,
+    Digits::parents,
+    Digits::children,
+    Digits::lambdas,
+    Digits::sizes,
+    Common::CLUSTER_SELECTION_METHOD::EOM,
+    false,
+    0.0,
+    {1.,      0.58403, 0.,      0.85348, 0.78141, 0.,      0.97918, 0.78766,
+     0.,      0.,      0.73614, 1.,      0.69244, 0.89164, 0.92189, 0.91287,
+     0.80505, 0.95358, 0.,      0.,      0.75426, 1.,      0.82675, 0.82176,
+     0.8865,  0.,      0.95279, 0.,      0.,      0.,      0.75316, 0.,
+     0.96262, 0.,      0.88752, 0.,      0.75986, 0.,      0.,      0.86867,
+     0.5573,  1.,      0.93996, 0.82658, 1.,      0.,      0.,      1.,
+     0.82796, 0.8055,  0.,      0.,      0.87192, 0.,      0.,      0.81232,
+     1.,      0.,      0.97918, 0.8524,  0.87954, 0.91103, 0.94117, 0.94409,
+     0.89604, 1.,      0.95962, 0.91021, 0.80689, 0.,      0.9984,  0.,
+     0.72607, 0.85888, 0.,      0.,      0.5709,  0.,      0.67642, 1.,
+     0.86672, 1.,      0.97918, 0.89914, 0.76688, 0.82857, 0.77669, 0.,
+     1.,      0.94117, 0.94535, 0.93258, 0.,      0.,      1.,      0.,
+     0.,      0.929,   0.8634,  0.70181, 0.92071, 0.70802, 0.88235, 0.,
+     0.,      0.,      0.,      0.94671, 0.86399, 0.87756, 0.82143, 0.95011,
+     1.,      0.,      0.54525, 0.,      0.,      1.,      0.89904, 0.,
+     0.,      0.,      0.,      0.,      1.,      0.,      0.84609, 0.,
+     0.88612, 0.,      0.87394, 0.83787, 0.86184, 0.,      0.,      1.,
+     1.,      1.,      0.,      1.,      0.7679,  0.91434, 0.76688, 0.84285,
+     0.81978, 0.,      1.,      0.89419, 0.,      0.99697, 0.72905, 0.92181,
+     0.67926, 0.82176, 1.,      0.,      0.87679, 1.,      0.,      0.98953,
+     0.84453, 0.,      1.,      0.89203, 1.,      1.,      0.90284, 0.93666,
+     0.,      0.90692, 0.,      0.81978, 0.,      1.,      1.,      0.98802,
+     0.93646, 0.83787, 0.88445, 0.73206, 0.8707,  0.86435, 1.,      0.54403,
+     0.8056,  0.90859, 1.,      0.80867, 0.9207,  0.83768, 0.8132,  0.,
+     0.,      0.88192, 0.92071, 1.,      0.97736, 1.,      0.,      0.89579,
+     1.,      1.,      0.91444, 0.,      0.,      0.68987, 0.,      0.76952,
+     0.79364, 0.74772, 0.87847, 0.79231, 0.95962, 0.92421, 0.85568, 0.,
+     0.88752, 0.,      0.89529, 0.98802, 0.,      0.87847, 0.93431, 0.91021,
+     0.,      1.,      0.79772, 0.89071, 1.,      1.,      0.99703, 0.,
+     0.97918, 0.92683, 0.99038, 0.,      1.,      0.88471, 0.85026, 0.91264,
+     0.96792, 0.82785, 0.58327, 0.74025, 0.73096, 0.9186,  0.9163,  0.,
+     0.58327, 0.56195, 0.9659,  0.85984, 0.94991, 0.,      0.,      0.,
+     0.79494, 0.71948, 0.89758, 1.,      1.,      0.93031, 1.,      0.87103,
+     0.,      0.,      0.90666, 0.,      0.93496, 0.88192, 1.,      0.,
+     1.,      1.,      0.,      0.,      0.94335, 0.,      0.81809, 1.,
+     0.98823, 0.98706, 0.95448, 0.,      0.,      0.92322, 0.7445,  0.94043,
+     0.94358, 0.,      0.96836, 0.,      0.70259, 0.,      0.,      0.,
+     0.,      1.,      0.7139,  1.,      1.,      0.95757, 0.,      0.,
+     0.78602, 0.96809, 0.81916, 0.78884, 0.97534, 1.,      0.93496, 0.93692,
+     0.,      0.87719, 0.74358, 0.82664, 0.95001, 0.787,   0.86005, 0.9914,
+     1.,      0.93633, 0.9511,  0.93794, 0.86928, 0.,      0.89443, 0.,
+     0.94335, 0.,      0.99854, 0.89062, 1.,      0.86184, 0.83537, 0.94771,
+     0.55405, 1.,      0.91021, 1.,      0.82238, 0.,      1.,      1.,
+     1.,      0.98802, 0.71667, 1.,      0.,      0.85635, 0.9421,  1.,
+     0.,      1.,      0.,      0.8493,  0.88859, 0.7062,  0.88235, 0.94409,
+     1.,      0.,      0.74119, 0.56466, 0.79097, 0.88235, 0.93384, 1.,
+     1.,      0.7722,  0.96465, 0.76864, 0.91346, 0.,      0.85124, 1.,
+     0.96734, 1.,      0.,      0.,      1.,      1.,      0.8265,  0.,
+     0.,      0.88552, 0.83839, 0.9413,  0.82785, 0.,      0.88754, 0.,
+     0.869,   1.,      0.,      0.97654, 0.99236, 0.98738, 0.79562, 0.83871,
+     0.82226, 0.,      0.,      1.,      0.,      0.89798, 0.94991, 0.9413,
+     0.8056,  0.,      1.,      0.,      0.88889, 1.,      0.,      0.91613,
+     0.75316, 0.86668, 0.,      0.,      0.,      0.,      0.78107, 0.,
+     0.,      1.,      0.94516, 0.85678, 0.94945, 1.,      0.,      0.91876,
+     0.,      0.87956, 0.94991, 0.89907, 0.7257,  0.79173, 1.,      0.,
+     0.70849, 0.98985, 0.99258, 0.77309, 0.,      0.,      0.80399, 1.,
+     0.8132,  0.85895, 1.,      1.,      0.83748, 0.88616, 1.,      1.,
+     1.,      0.,      0.87052, 0.86668, 0.,      0.7257,  0.,      0.91644,
+     1.,      0.73409, 0.9536,  1.,      1.,      0.92011, 0.94465, 0.,
+     0.83902, 0.829,   0.88889, 0.85348, 1.,      0.,      0.90354, 0.98738,
+     0.,      0.76364, 0.,      0.84843, 0.82961, 0.98738, 1.,      0.78107,
+     0.,      0.,      1.,      0.,      0.,      1.,      1.,      0.,
+     0.82309, 0.86928, 1.,      0.83118, 0.,      1.,      0.,      0.,
+     1.,      0.95071, 0.,      0.91378, 0.,      0.,      0.85584, 0.,
+     0.94119, 0.,      1.,      0.,      0.90284, 1.,      0.67926, 0.,
+     1.,      0.,      1.,      0.80606, 0.,      0.,      0.81094, 1.,
+     0.,      0.,      0.90367, 0.8926,  0.87944, 1.,      0.54403, 0.,
+     0.76673, 0.98245, 0.,      0.,      0.96188, 0.97461, 0.93633, 1.,
+     0.54403, 0.,      0.97518, 0.,      0.,      0.97733, 0.96135, 0.89892,
+     0.8524,  0.,      0.,      0.,      0.54403, 0.93506, 0.96044, 1.,
+     1.,      0.,      1.,      0.81691, 0.73307, 0.85723, 0.72869, 0.72869,
+     1.,      0.,      0.72869, 0.78478, 0.93002, 0.72869, 0.,      0.,
+     0.,      1.,      0.,      0.,      1.,      0.79505, 1.,      0.81228,
+     0.92542, 0.,      0.79566, 1.,      0.63311, 0.87167, 0.,      0.6886,
+     0.54403, 0.71409, 0.70439, 0.69468, 0.9147,  1.,      0.82845, 0.,
+     0.,      0.88104, 1.,      0.94124, 0.79407, 0.,      0.77182, 0.,
+     0.,      0.86995, 1.,      1.,      0.54403, 1.,      0.,      0.55405,
+     0.96188, 0.62922, 0.90106, 0.,      1.,      0.85505, 0.87029, 0.77044,
+     1.,      1.,      0.78501, 0.8683,  0.84548, 0.67504, 0.,      0.87328,
+     0.68987, 0.,      1.,      0.95202, 1.,      0.91378, 0.,      0.54403,
+     1.,      0.,      0.97518, 0.54403, 0.89798, 0.,      0.80957, 0.61237,
+     0.8097,  0.94703, 1.,      0.,      1.,      1.,      1.,      1.,
+     0.74557, 0.67006, 0.83569, 0.81602, 1.,      0.,      0.99805, 1.,
+     0.,      1.,      0.88091, 0.62217, 0.79076, 0.91741, 0.,      0.87756,
+     1.,      0.,      1.,      1.,      0.91444, 0.99002, 0.,      0.88265,
+     0.92998, 0.,      1.,      0.,      0.,      1.,      1.,      0.82309,
+     0.,      0.,      0.,      0.,      0.95934, 0.,      0.94119, 0.73409,
+     0.75995, 0.77399, 1.,      1.,      0.,      0.61316, 0.61324, 0.,
+     0.9207,  0.95001, 0.96219, 1.,      0.89914, 1.,      0.,      1.,
+     0.87679, 0.87679, 1.,      1.,      0.64631, 0.,      0.85081, 0.92227,
+     0.,      0.68924, 0.,      0.76253, 0.77142, 0.92041, 0.5471,  1.,
+     0.97736, 0.95001, 0.77854, 0.,      0.82582, 1.,      0.75341, 0.,
+     0.,      0.,      1.,      0.60055, 1.,      1.,      0.,      0.91723,
+     0.7995,  0.54835, 0.,      0.79236, 0.,      0.87135, 0.88345, 0.96989,
+     0.80607, 0.57161, 1.,      0.,      0.,      0.,      0.86226, 0.87457,
+     0.,      0.76167, 0.87457, 0.95934, 1.,      1.,      0.,      0.,
+     0.95368, 0.,      0.,      1.,      0.85081, 0.,      0.,      0.93892,
+     0.7017,  1.,      0.86184, 0.,      0.78428, 0.89523, 0.,      1.,
+     0.,      1.,      0.85561, 0.58478, 0.85813, 1.,      0.90478, 1.,
+     0.,      1.,      0.,      0.,      0.70259, 0.79472, 0.86184, 0.93258,
+     0.90813, 1.,      0.9253,  1.,      0.,      0.,      0.93063, 0.87067,
+     0.,      0.87959, 0.8197,  0.88368, 0.96809, 0.,      0.95476, 0.9173,
+     0.,      1.,      0.60722, 0.92245, 1.,      0.83564, 0.88471, 0.6735,
+     0.59663, 0.66629, 0.88925, 0.82785, 0.85797, 0.,      0.86184, 0.76907,
+     0.93002, 1.,      0.91168, 0.81226, 0.,      1.,      0.,      0.,
+     1.,      0.98287, 0.,      0.55404, 0.9741,  0.88401, 0.61412, 0.,
+     0.8236,  0.91496, 0.,      0.77854, 0.,      0.8097,  0.8179,  0.84453,
+     0.55277, 0.89419, 0.89165, 0.89287, 0.,      0.65359, 0.90498, 0.9741,
+     0.86141, 1.,      0.69921, 0.92284, 0.88612, 0.81857, 1.,      0.94776,
+     0.,      0.80847, 0.83768, 0.86358, 0.,      0.94771, 0.,      0.,
+     0.84094, 0.95465, 1.,      0.5416,  0.88941, 1.,      1.,      0.87625,
+     1.,      0.82785, 0.83882, 0.,      0.79076, 0.,      0.88192, 0.88088,
+     1.,      0.8982,  0.,      0.,      0.92071, 0.,      0.65514, 0.,
+     0.89253, 0.,      1.,      0.84026, 0.846,   0.96321, 0.90429, 1.,
+     0.91103, 0.,      0.89253, 0.80957, 1.,      0.766,   0.79861, 1.,
+     0.,      1.,      0.83587, 1.,      0.991,   0.96809, 0.86603, 0.88925,
+     0.84077, 0.8549,  0.,      1.,      1.,      0.,      0.95598, 0.90859,
+     0.92683, 1.,      1.,      1.,      0.98989, 0.96809, 0.,      1.,
+     1.,      0.93996, 0.86538, 0.83817, 1.,      0.94437, 0.,      0.,
+     1.,      0.82675, 0.97285, 1.,      0.85447, 1.,      1.,      0.85447,
+     0.94776, 0.99826, 0.846,   0.93431, 0.,      0.,      0.,      1.,
+     0.93633, 1.,      0.81326, 0.91149, 1.,      1.,      0.87567, 0.95333,
+     1.,      0.85447, 0.,      0.85447, 0.69296, 0.70529, 1.,      1.,
+     1.,      0.,      0.87198, 1.,      0.,      1.,      0.79421, 1.,
+     0.,      0.90466, 0.9474,  0.97659, 0.80505, 0.,      0.77576, 0.81602,
+     0.90901, 0.77229, 0.96115, 0.95232, 0.,      1.,      0.87881, 1.,
+     1.,      0.96792, 0.92101, 0.97548, 0.94,    1.,      0.73634, 0.,
+     0.85447, 0.92402, 0.94112, 1.,      0.,      0.,      0.,      0.90478,
+     0.,      0.64591, 1.,      1.,      1.,      1.,      0.59251, 0.93496,
+     0.93399, 0.98968, 0.91287, 0.99228, 0.97659, 0.,      0.,      0.96345,
+     0.61677, 0.66971, 0.85675, 0.98968, 0.,      1.,      1.,      0.,
+     0.,      0.69642, 1.,      0.85447, 0.82273, 0.98968, 0.,      0.92841,
+     0.85627, 0.,      0.,      0.85561, 0.,      0.,      0.,      0.97554,
+     0.,      0.85723, 0.,      0.,      0.,      0.,      0.76954, 0.65465,
+     0.,      0.8228,  0.876,   0.97733, 0.89443, 0.,      0.,      0.,
+     0.,      0.76339, 0.85561, 0.56398, 0.85447, 0.,      0.8439,  0.90296,
+     0.,      0.,      0.88072, 0.98968, 0.87029, 0.93473, 0.90582, 0.,
+     0.,      1.,      0.,      0.88624, 0.,      0.8806,  0.79562, 0.,
+     0.79464, 0.77142, 0.76442, 0.83351, 0.79365, 0.80607, 0.92284, 0.85447,
+     0.83793, 0.,      0.98968, 0.88616, 0.91741, 0.55665, 0.,      0.,
+     0.82275, 0.9141,  0.86645, 0.,      0.98968, 0.88072, 0.74473, 1.,
+     0.83991, 0.,      0.,      0.86392, 0.,      0.98102, 0.89443, 0.81394,
+     0.,      0.94375, 0.97272, 0.80606, 0.98109, 0.,      0.66281, 0.81916,
+     0.,      0.,      0.,      0.,      1.,      0.,      0.,      0.79535,
+     0.,      0.85561, 0.,      0.,      0.,      0.87394, 0.95923, 0.93496,
+     0.8524,  1.,      0.,      0.97918, 1.,      0.,      0.,      0.87052,
+     1.,      0.77763, 0.81226, 1.,      0.,      0.87287, 0.98293, 0.,
+     0.,      0.79494, 0.,      0.73172, 0.,      0.93506, 0.9163,  0.98287,
+     0.97409, 0.,      0.,      0.79754, 1.,      0.,      0.,      0.94943,
+     0.,      0.7183,  0.,      0.,      0.9866,  0.,      1.,      0.72232,
+     1.,      1.,      0.,      0.,      0.,      0.64384, 0.73717, 0.77854,
+     0.87457, 1.,      0.,      0.86184, 0.83238, 0.95743, 0.85936, 0.9666,
+     0.,      0.85456, 0.90498, 0.,      0.81133, 0.86057, 0.98287, 1.,
+     0.9511,  1.,      0.89798, 0.89443, 0.8806,  0.72805, 0.,      0.,
+     0.77399, 0.,      0.66224, 0.83688, 0.86547, 1.,      1.,      0.9207,
+     0.93828, 0.73634, 0.,      0.91721, 1.,      0.95618, 0.92147, 0.89443,
+     0.,      0.96268, 0.89443, 1.,      0.9511,  0.,      1.,      0.,
+     0.,      1.,      0.64043, 0.,      0.,      1.,      0.90805, 1.,
+     0.,      0.90498, 0.89846, 0.95528, 1.,      1.,      0.82238, 0.,
+     0.76167, 0.70987, 0.,      0.,      0.98369, 0.,      0.96055, 0.,
+     0.,      0.80768, 0.99848, 0.64661, 0.,      0.,      0.54281, 0.64179,
+     0.,      0.,      0.80489, 0.94628, 0.89999, 0.8528,  0.98293, 0.58327,
+     0.,      0.70529, 0.,      0.,      0.86565, 0.94628, 0.,      0.82734,
+     0.98293, 0.58327, 0.88506, 0.79623, 0.,      0.70369, 0.,      0.87929,
+     0.,      0.,      0.91308, 0.58327, 0.90579, 0.77984, 0.90466, 0.,
+     0.,      0.85159, 0.88845, 0.74988, 0.87778, 0.58327, 0.85505, 0.58327,
+     0.94628, 1.,      1.,      0.89709, 0.8058,  0.,      1.,      0.92041,
+     0.94991, 0.72274, 0.70437, 0.96792, 0.5709,  0.,      0.86215, 0.94945,
+     0.81073, 1.,      0.846,   0.83871, 0.87824, 0.80129, 0.88918, 0.90813,
+     1.,      1.,      1.,      1.,      0.90919, 0.87604, 0.,      0.82217,
+     0.9173,  0.,      0.79562, 0.55086, 0.66913, 1.,      0.70081, 0.97822,
+     1.,      0.79212, 0.92837, 0.85447, 0.60553, 0.94323, 0.95268, 0.,
+     0.85456, 0.95743, 0.,      0.,      0.87604, 1.,      0.80915, 0.54281,
+     0.94628, 0.88918, 0.88906, 1.,      0.84298, 0.,      0.89914, 0.,
+     0.8657,  0.,      0.89715, 0.85797, 0.,      0.87424, 0.88546, 1.,
+     0.,      0.,      0.85447, 0.76167, 0.,      1.,      0.,      0.,
+     0.92542, 0.56128, 0.56603, 0.97968, 0.,      0.6904,  0.55665, 0.91642,
+     0.83226, 1.,      0.84181, 0.92542, 0.99132, 1.,      1.,      1.,
+     0.90354, 0.8605,  0.9413,  0.8461,  0.92559, 1.,      0.97871, 1.,
+     1.,      1.,      0.89253, 0.78728, 0.99521, 1.,      0.94409, 1.,
+     0.,      1.,      1.,      1.,      1.,      0.87052, 0.99848, 1.,
+     0.98847, 0.95962, 1.,      0.99236, 0.99848, 0.93996, 0.93541, 0.93996,
+     1.,      0.85949, 1.,      0.90299, 0.93258, 0.99708, 0.9413,  0.99743,
+     0.99236, 0.85813, 1.,      0.79097, 0.,      1.,      0.85723, 0.9413,
+     1.,      0.86772, 0.89536, 0.85348, 1.,      0.8904,  0.8904,  0.9926,
+     1.,      0.87029, 0.98287, 1.,      0.90019, 0.9413,  0.8926,  0.81932,
+     0.88088, 0.,      1.,      0.,      1.,      0.82217, 1.,      0.88066,
+     1.,      1.,      1.,      0.79269, 0.87307, 1.,      1.,      1.,
+     1.,      0.84264, 0.79684, 0.99848, 0.9413,  1.,      0.95962, 0.,
+     1.,      0.83768, 0.86882, 1.,      0.93692, 1.,      1.,      1.,
+     0.92926, 1.,      0.89185, 1.,      0.89574, 1.,      0.93506, 1.,
+     0.89062, 0.,      0.75825, 1.,      0.,      1.,      0.90242, 0.97733,
+     1.,      0.,      0.,      1.,      0.,      1.,      0.,      0.,
+     0.,      0.94991, 0.64226, 0.7257,  0.,      1.,      0.89846, 0.,
+     0.,      0.,      0.9519,  0.84609, 0.62217, 0.,      0.,      1.,
+     0.88992, 0.73724, 0.,      0.79885, 0.56603, 0.,      0.86906, 0.8683,
+     0.91287, 0.77979, 0.85627, 0.,      0.,      0.,      0.,      0.,
+     0.,      0.88752, 0.,      0.86883, 0.,      0.,      0.,      0.,
+     1.,      1.,      0.85374, 0.8228,  0.,      0.,      0.8786,  0.65012,
+     0.57587, 0.,      0.86814, 0.,      0.58327, 0.,      0.69125, 0.54648,
+     0.7966,  0.83748, 0.,      0.,      0.81177, 0.,      0.,      0.93506,
+     0.87029, 0.87158, 0.96135, 0.,      0.,      0.82916, 1.,      0.67883,
+     1.,      0.,      0.,      0.,      0.87394, 1.,      0.99598, 0.86772,
+     0.93828, 0.78505, 0.80244, 0.,      0.,      0.82404, 0.89412, 0.92884,
+     0.,      0.,      1.,      0.787,   0.83293, 0.,      1.,      0.94409,
+     0.95743, 1.,      0.8309,  0.,      0.91741, 0.79801, 0.,      0.73568,
+     1.,      0.87014, 0.,      0.96997, 0.89496, 0.99598, 0.66224, 0.72274,
+     0.,      0.,      0.,      0.,      0.,      1.,      0.,      0.90284,
+     0.,      0.,      0.,      0.89167, 0.,      0.86814, 0.,      0.,
+     0.89892, 0.88752, 1.,      0.,      1.,      0.96345, 0.64734, 0.7148,
+     0.,      1.,      0.89892, 1.,      0.85124, 0.,      0.98369, 0.775,
+     0.60722, 0.,      0.,      1.,      0.89892, 0.92841, 1.,      0.,
+     1.,      0.95436, 0.99697, 0.,      0.,      0.95448, 0.,      0.89907,
+     0.,      0.,      0.91847, 0.,      0.,      0.56061, 0.,      1.,
+     0.,      0.89892, 0.65149, 0.74772, 0.7241,  0.78318, 0.98109, 1.,
+     0.,      0.8097,  0.64453, 0.,      0.72274, 0.93955, 0.,      0.,
+     0.,      0.,      0.,      0.86538, 0.75092, 1.,      0.76538, 0.83855,
+     0.97512, 0.54772, 0.,      0.83991, 0.99697, 0.,      0.,      0.,
+     0.8097,  0.71735, 0.86547, 0.,      0.83745, 0.90874, 0.,      0.67624,
+     0.,      0.83042, 0.91608, 0.89165, 0.8634,  0.65254, 0.,      0.92202,
+     0.66112, 1.,      0.86518, 0.,      0.97968, 0.,      0.64734, 0.81245,
+     0.64731, 0.89469, 0.81508, 0.83068, 0.,      1.,      0.64226, 0.95241,
+     0.,      0.91608, 0.83071, 0.87916, 0.80256, 0.,      0.92556, 0.74343,
+     0.,      0.99333, 0.,      0.,      1.,      0.,      0.,      1.,
+     0.91847, 0.74029, 0.,      0.,      0.},
+    {1,  10, -1, 8,  5,  -1, 7,  2,  -1, -1, 1,  11, 4,  8,  5,  14, 7,  2,  -1,
+     -1, 1,  11, 4,  8,  5,  -1, 7,  -1, -1, -1, 1,  -1, 13, -1, 7,  -1, 1,  -1,
+     -1, 12, 10, 5,  11, 2,  2,  -1, -1, 11, 1,  1,  -1, -1, 2,  -1, -1, 1,  11,
+     -1, 7,  8,  8,  2,  8,  8,  5,  7,  7,  7,  5,  -1, 11, -1, 1,  12, -1, -1,
+     10, -1, 1,  1,  11, 2,  7,  8,  4,  11, 2,  -1, 7,  8,  11, 8,  -1, -1, 2,
+     -1, -1, 5,  8,  10, 5,  1,  13, -1, -1, -1, -1, 11, 2,  14, 5,  5,  2,  -1,
+     10, -1, -1, 14, 2,  -1, -1, -1, -1, -1, 5,  -1, 1,  -1, 12, -1, 1,  11, 4,
+     -1, -1, 14, 7,  2,  -1, 12, 1,  11, 4,  8,  5,  -1, 7,  2,  -1, 12, 1,  11,
+     4,  8,  5,  -1, 7,  2,  -1, 12, 1,  -1, 14, 14, 7,  14, 1,  12, -1, 12, -1,
+     5,  -1, 2,  2,  8,  14, 11, 1,  1,  4,  4,  2,  10, 4,  1,  11, 4,  7,  8,
+     8,  -1, -1, 8,  5,  7,  7,  7,  -1, 12, 11, 14, 1,  -1, -1, 4,  -1, 4,  1,
+     1,  11, 2,  7,  8,  4,  -1, 2,  -1, 11, 8,  -1, 11, 2,  7,  -1, 5,  8,  11,
+     5,  1,  14, -1, 7,  12, 7,  -1, 2,  14, 5,  5,  2,  4,  10, 4,  4,  14, 14,
+     -1, 10, 10, 5,  12, 1,  -1, -1, -1, 1,  10, 4,  8,  5,  13, 7,  2,  -1, -1,
+     1,  -1, 4,  8,  5,  -1, 7,  2,  -1, -1, 1,  -1, 4,  8,  5,  13, 7,  -1, -1,
+     12, 1,  12, 13, -1, 7,  -1, 1,  -1, -1, -1, -1, 5,  10, 2,  2,  8,  -1, -1,
+     1,  1,  4,  4,  2,  9,  4,  1,  -1, 4,  7,  8,  8,  2,  8,  8,  5,  7,  7,
+     7,  5,  -1, 10, -1, 1,  -1, 13, 4,  9,  4,  1,  1,  10, 2,  7,  8,  4,  -1,
+     2,  5,  7,  8,  10, 8,  -1, 10, 2,  7,  -1, 5,  -1, 10, 5,  1,  13, 8,  7,
+     -1, 7,  10, 2,  13, 5,  5,  2,  4,  9,  4,  4,  -1, 2,  6,  14, 5,  -1, -1,
+     5,  6,  1,  -1, -1, 8,  1,  11, 4,  -1, 5,  -1, 7,  0,  -1, 12, 1,  11, 4,
+     8,  5,  -1, -1, 0,  -1, 12, 1,  11, 4,  -1, 5,  -1, 7,  0,  -1, 12, 1,  12,
+     -1, -1, -1, -1, 1,  -1, -1, 12, 9,  5,  11, 0,  -1, 8,  -1, 11, 1,  1,  4,
+     4,  0,  -1, 4,  1,  3,  4,  -1, -1, 8,  0,  8,  8,  5,  7,  7,  7,  5,  12,
+     11, -1, 1,  12, -1, 4,  -1, 4,  1,  1,  11, 0,  7,  8,  4,  -1, 0,  5,  7,
+     8,  11, -1, 12, 11, -1, 7,  -1, 5,  8,  11, 5,  1,  -1, -1, 7,  -1, -1, 11,
+     0,  -1, 5,  5,  0,  4,  -1, 4,  -1, -1, 0,  12, -1, 5,  -1, -1, 5,  -1, 1,
+     -1, 12, -1, 1,  3,  4,  -1, 5,  -1, 7,  2,  -1, -1, 1,  3,  -1, -1, 5,  13,
+     7,  2,  10, -1, 1,  3,  -1, -1, 5,  13, 7,  2,  10, -1, 1,  -1, -1, 13, 7,
+     13, 1,  -1, -1, -1, 10, 5,  3,  2,  2,  -1, 13, 3,  1,  1,  4,  4,  2,  -1,
+     4,  1,  3,  4,  -1, -1, -1, 2,  -1, -1, 5,  7,  7,  7,  5,  -1, 3,  13, 1,
+     12, -1, 4,  10, 4,  1,  1,  3,  2,  7,  -1, -1, 3,  2,  5,  7,  -1, 3,  -1,
+     -1, 3,  2,  7,  10, 5,  -1, 10, 5,  1,  13, -1, 7,  12, 7,  3,  2,  13, 5,
+     5,  2,  4,  -1, 4,  4,  -1, 2,  12, 13, 5,  -1, 10, 5,  -1, 1,  10, 12, -1,
+     1,  10, 4,  8,  5,  -1, 7,  2,  9,  6,  1,  10, 4,  8,  5,  -1, 7,  2,  -1,
+     6,  1,  10, 4,  8,  -1, 14, 7,  -1, 9,  6,  1,  6,  -1, 14, 7,  -1, 1,  -1,
+     -1, 6,  9,  5,  -1, -1, -1, -1, 14, -1, 1,  1,  4,  4,  2,  9,  -1, 1,  10,
+     -1, 7,  8,  8,  2,  8,  8,  -1, 7,  7,  7,  5,  6,  10, -1, 1,  6,  -1, 4,
+     -1, 4,  1,  1,  10, 2,  7,  8,  4,  -1, 2,  5,  7,  -1, -1, -1, 6,  10, 2,
+     7,  -1, 5,  8,  10, -1, 1,  -1, 8,  7,  6,  7,  10, 2,  -1, -1, -1, 2,  4,
+     -1, 4,  4,  14, 2,  6,  -1, -1, 9,  -1, -1, 6,  1,  -1, -1, 9,  1,  10, 4,
+     -1, 5,  14, -1, 2,  -1, 12, 1,  10, 4,  8,  5,  14, -1, 2,  -1, -1, 1,  10,
+     4,  8,  5,  14, 7,  2,  -1, -1, 1,  12, -1, 14, 7,  14, 1,  -1, 9,  12, -1,
+     5,  10, 2,  2,  8,  14, 10, 1,  1,  4,  4,  2,  -1, 4,  1,  3,  4,  7,  8,
+     -1, 2,  -1, -1, 5,  7,  -1, 1,  5,  12, 10, -1, 1,  12, -1, 4,  -1, 4,  1,
+     1,  10, 2,  7,  8,  -1, 10, 2,  5,  7,  8,  10, 8,  12, 10, 2,  7,  -1, 5,
+     8,  10, -1, 1,  -1, -1, 7,  12, 7,  10, 2,  14, 5,  5,  2,  4,  11, -1, 4,
+     -1, 2,  12, 14, 5,  -1, -1, 5,  -1, 1,  -1, 12, -1, 3,  4,  8,  5,  13, 7,
+     2,  -1, 12, 1,  3,  4,  8,  5,  -1, 7,  2,  9,  12, 1,  3,  4,  8,  5,  -1,
+     7,  2,  -1, 12, 1,  12, 13, 13, 7,  13, 1,  -1, 9,  12, 9,  5,  3,  2,  2,
+     -1, -1, 3,  4,  2,  9,  4,  1,  3,  4,  7,  8,  8,  2,  -1, -1, -1, 7,  7,
+     7,  5,  12, 3,  13, 1,  12, 13, 4,  -1, 4,  1,  1,  3,  2,  7,  -1, 4,  3,
+     -1, 7,  8,  3,  -1, 12, 3,  2,  7,  -1, 5,  8,  3,  5,  1,  13, -1, 7,  12,
+     7,  3,  2,  13, 5,  5,  2,  4,  -1, 4,  4,  13, 2,  -1, -1, -1, 5,  -1, 1,
+     9,  12, 9,  1,  10, 4,  8,  5,  14, 7,  2,  -1, -1, 1,  10, 4,  8,  5,  -1,
+     7,  2,  -1, -1, 1,  10, 4,  8,  5,  -1, 7,  2,  -1, -1, 1,  -1, -1, -1, 7,
+     -1, 1,  -1, -1, -1, -1, 5,  10, -1, 2,  8,  13, 10, -1, -1, -1, -1, 4,  1,
+     10, 4,  -1, 8,  8,  -1, -1, 8,  5,  7,  7,  7,  -1, -1, 10, -1, 1,  -1, 14,
+     4,  -1, 4,  1,  1,  10, 2,  7,  8,  4,  10, -1, 5,  7,  8,  10, -1, -1, 10,
+     2,  7,  -1, 5,  8,  10, 5,  1,  -1, -1, 7,  -1, 7,  10, 2,  -1, 5,  5,  2,
+     4,  -1, 4,  4,  -1, -1, -1, -1, 5,  -1, -1, 5,  -1, 1,  -1, -1, -1, 1,  11,
+     4,  8,  5,  -1, 7,  2,  -1, -1, 1,  11, 4,  8,  5,  -1, 7,  2,  -1, -1, 1,
+     -1, 4,  -1, 5,  14, 7,  2,  -1, -1, 1,  12, -1, -1, 7,  -1, 1,  -1, -1, 12,
+     -1, 5,  10, 2,  2,  -1, -1, -1, 1,  1,  4,  4,  2,  -1, 4,  1,  10, 4,  7,
+     -1, 8,  2,  -1, 8,  5,  7,  7,  7,  5,  12, 10, 14, 1,  -1, -1, 4,  -1, 4,
+     1,  1,  10, 2,  7,  8,  4,  -1, 2,  5,  7,  8,  10, -1, 12, 10, 2,  7,  -1,
+     5,  -1, -1, 5,  1,  -1, -1, 7,  12, 7,  -1, 2,  14, 5,  5,  2,  4,  -1, 4,
+     4,  -1, -1, 12, -1, 5,  -1, -1, 5,  12, 1,  -1, -1, 10, 1,  -1, -1, 8,  5,
+     13, 7,  2,  10, -1, 1,  -1, -1, 8,  5,  -1, 7,  2,  10, 12, 1,  -1, 4,  -1,
+     5,  -1, -1, 2,  10, 12, 1,  12, -1, -1, 7,  13, 1,  12, 10, 12, 10, 5,  10,
+     2,  2,  8,  -1, 10, 1,  1,  4,  4,  2,  10, -1, 1,  11, 4,  7,  8,  8,  2,
+     8,  8,  5,  7,  7,  7,  5,  12, 10, -1, 1,  12, -1, 4,  10, 4,  1,  1,  11,
+     2,  7,  8,  4,  10, 2,  5,  -1, 8,  10, -1, -1, 10, 2,  7,  10, 5,  8,  10,
+     5,  1,  -1, 8,  -1, 12, -1, 10, 2,  -1, 5,  5,  2,  -1, -1, 4,  4,  -1, 2,
+     -1, -1, 5,  10, 10, 5,  -1, 1,  10, 1,  11, 4,  8,  5,  13, 7,  2,  9,  12,
+     1,  11, 4,  8,  5,  13, 7,  2,  9,  12, 1,  11, 4,  8,  5,  -1, 7,  2,  9,
+     12, 1,  12, 13, 13, 7,  13, 1,  12, 9,  12, 9,  5,  11, 2,  2,  8,  13, 11,
+     1,  1,  4,  4,  2,  -1, 4,  1,  11, 4,  7,  8,  8,  2,  8,  8,  5,  7,  7,
+     7,  5,  12, 11, 13, 1,  12, -1, 4,  -1, 4,  1,  1,  11, 2,  7,  8,  4,  11,
+     2,  5,  7,  8,  11, 8,  12, 11, 2,  7,  -1, 5,  8,  11, 5,  1,  13, 8,  7,
+     12, 7,  11, 2,  13, 5,  5,  2,  4,  -1, 4,  4,  -1, 2,  12, 13, 5,  -1, -1,
+     5,  -1, 1,  -1, -1, -1, 1,  10, 4,  -1, 5,  14, -1, -1, -1, 6,  1,  10, -1,
+     -1, 5,  14, 7,  -1, 1,  10, -1, 8,  5,  14, 7,  2,  -1, -1, -1, -1, -1, -1,
+     7,  -1, 1,  -1, -1, -1, -1, 5,  10, 2,  2,  -1, -1, 10, 1,  1,  -1, 4,  -1,
+     10, -1, 1,  10, 4,  7,  -1, -1, 2,  -1, -1, 5,  7,  7,  7,  -1, -1, 10, 14,
+     1,  12, -1, -1, -1, 1,  10, 2,  7,  8,  4,  10, -1, -1, 7,  8,  10, -1, -1,
+     10, 2,  7,  -1, 5,  8,  10, 5,  1,  -1, 8,  7,  -1, 7,  10, 2,  -1, 5,  5,
+     2,  4,  4,  -1, -1, -1, -1, -1, 5,  -1, 1,  -1, -1, -1, 1,  -1, 4,  -1, -1,
+     13, 7,  2,  -1, 12, 1,  10, 4,  -1, 5,  13, 7,  2,  -1, 12, 1,  10, -1, -1,
+     5,  13, 7,  2,  -1, 12, 1,  12, -1, -1, 7,  -1, 1,  -1, -1, 12, -1, -1, 10,
+     -1, 2,  -1, 13, 10, 1,  1,  4,  4,  2,  -1, 4,  1,  -1, 4,  7,  -1, -1, -1,
+     -1, -1, 5,  7,  7,  7,  5,  12, 10, -1, 1,  12, -1, -1, -1, 4,  1,  1,  -1,
+     2,  7,  -1, 4,  -1, 2,  5,  7,  8,  10, -1, 12, 10, 2,  7,  -1, 5,  -1, 10,
+     5,  1,  13, 8,  7,  -1, 7,  10, 2,  -1, 5,  5,  2,  4,  -1, 4,  4,  -1, 2,
+     -1, -1, 5,  -1, -1, 5,  12, 1,  -1, -1, -1}},
+   {1797,
+    5,
+    10,
+    Digits::parents,
+    Digits::children,
+    Digits::lambdas,
+    Digits::sizes,
+    Common::CLUSTER_SELECTION_METHOD::EOM,
+    false,
+    50.0,
+    {1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      0., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 0.,      0., 1.,      0.,      0., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      0., 1.,      0.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      1., 0.,      0., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      0.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 0.99685, 1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 0.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      0., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      0., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      0., 1.,      1., 1., 0., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.83902, 1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      0., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 0.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      0., 1.,      1., 0., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      0., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      0., 0.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 0.,
+     1.,      0., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 0.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 0.,
+     1.,      1., 1.,      0., 1.,      0.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 0.,      1.,      1., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      0., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 0.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 0., 0.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 0.,      0., 1.,      1.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      0.99529, 0., 1.,      1., 0., 0., 1.,
+     0.,      1., 0.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      1., 0., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 0.,
+     1.,      1., 0.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      0.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      0., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 0.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      0., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     0.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 0.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      0., 0.,      0.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 0.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 0.,
+     0.,      0., 0.,      0., 0.99763, 1.,      1., 1.,      0., 0., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      1., 1.,      1., 0., 1., 0.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 0., 1., 1.,
+     1.,      1., 1.,      0., 0.,      1.,      1., 1.,      1., 0., 0., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 0.,      0., 1., 1., 1.,
+     0.99921, 1., 1.,      1., 1.,      0.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 0.99921, 1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 0.,      1.,      0., 1.,      0., 1., 0., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 0.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      0.,      1., 1.,      1., 1., 0., 1.,
+     1.,      1., 1.,      0., 1.,      1.,      1., 0.99921, 1., 1., 1., 1.,
+     1.,      1., 1.,      0., 0.,      1.,      0., 1.,      0., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 0.,
+     0.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 0.99921, 1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      1., 1.,      1., 1.,      1.,      1., 1.,      1., 1., 1., 1.,
+     1.,      0., 1.,      1., 1.,      1.,      1., 1.,      0.},
+    {0,  0,  -1, 0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  -1,
+     -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  -1, -1, 0,  -1, -1, 0,  0,
+     -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  -1,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  -1, -1, 0,  0,  0,  -1, 0,  0,  0,  0,  -1, 0,  -1, 0,  0,  0,  0,  0,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1,
+     0,  0,  0,  0,  0,  0,  -1, 0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  -1, 0,  0,  0,  0,
+     0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  1,  -1, 0,  0,  0,
+     -1, 0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  1,  -1, 0,  0,  0,  0,  0,  0,
+     0,  1,  0,  0,  0,  0,  0,  -1, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  1,  0,  0,
+     0,  0,  0,  0,  0,  -1, 0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     1,  0,  0,  0,  1,  0,  -1, 0,  -1, 0,  1,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,
+     0,  0,  0,  0,  0,  0,  -1, -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  -1, 0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  -1, 0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  0,  -1, 0,  0,  -1, 0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  -1, -1, -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     -1, 0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, 0,  0,
+     0,  0,  0,  0,  0,  0,  -1, -1, 0,  -1, -1, 0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  -1, -1, 0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,
+     0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  -1, 0,  -1, 0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,
+     -1, 0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, 0,  0,  0,  0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  -1, 0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, -1, -1, 0,  0,
+     0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  -1, -1, 0,
+     0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  -1, 0,  0,  0,  0,  -1, 0,  0,  -1, -1, 0,  -1, 0,  -1, -1, 0,  0,  0,
+     0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     -1, 0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  -1, 0,
+     0,  -1, -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, 0,  0,
+     0,  0,  0,  0,  -1, 0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  -1, 0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, -1, 0,  0,  0,  -1,
+     0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, -1, -1, -1, 0,
+     0,  0,  0,  -1, -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  -1, 0,  -1,
+     0,  -1, 0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  -1, -1, 0,  0,
+     0,  0,  -1, -1, 0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, 0,  0,  0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  -1, 0,  0,  -1, 0,  -1, 0,  -1, 0,  -1, 0,  0,  0,  0,  -1,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,  0,  0,  0,  -1,
+     0,  0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1, 0,
+     -1, 0,  -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, -1,
+     -1, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  -1, 0,  0,  0,  0,  0,  0,  -1}},
+   {150,
+    5,
+    10,
+    Iris::parents,
+    Iris::children,
+    Iris::lambdas,
+    Iris::sizes,
+    Common::CLUSTER_SELECTION_METHOD::LEAF,
+    false,
+    0.0,
+    {1.,      1.,      0.92582, 0.92582, 1.,      0.63246, 0.7746,  1.,
+     0.67937, 1.,      0.73855, 0.8165,  1.,      0.4899,  0.42008, 0.38255,
+     0.61237, 1.,      0.4714,  0.7746,  0.67937, 0.86603, 0.45486, 0.63246,
+     0.54772, 0.8165,  0.92582, 1.,      1.,      1.,      1.,      0.70711,
+     0.53452, 0.51075, 1.,      0.73855, 0.67937, 0.8165,  0.8165,  1.,
+     1.,      0.30861, 0.7746,  0.57735, 0.51075, 0.92582, 0.73855, 1.,
+     0.86603, 1.,      0.,      0.96609, 0.,      0.,      0.96609, 1.,
+     0.,      0.,      0.96609, 0.,      0.,      1.,      0.,      0.,
+     0.,      0.96609, 0.,      1.,      0.,      1.,      0.,      0.90749,
+     0.,      0.,      0.96609, 0.96609, 0.,      0.91287, 1.,      0.,
+     0.88192, 0.,      1.,      0.91287, 0.,      0.,      0.96609, 0.,
+     1.,      1.,      0.,      0.96609, 1.,      0.,      1.,      1.,
+     1.,      0.96609, 0.,      1.,      0.,      0.91287, 0.,      0.,
+     1.,      0.,      0.,      0.,      0.,      0.,      0.,      1.,
+     1.,      0.,      0.,      1.,      1.,      0.,      0.,      0.,
+     1.,      0.,      0.,      0.91287, 1.,      0.,      0.91287, 0.91287,
+     1.,      0.,      0.,      0.,      0.,      0.,      0.,      0.,
+     0.,      0.,      0.,      0.93934, 1.,      0.,      0.91287, 1.,
+     0.,      1.,      0.,      1.,      0.,      0.91287},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  -1, 2,  -1, -1, 2,  2,  -1,
+     -1, 2,  -1, -1, 2,  -1, -1, -1, 2,  -1, 2,  -1, 2,  -1, 2,  -1, -1, 2,  2,
+     -1, 1,  2,  -1, 2,  -1, 2,  1,  -1, -1, 2,  -1, 2,  2,  -1, 2,  2,  -1, 2,
+     2,  2,  2,  -1, 2,  -1, 1,  -1, -1, 1,  -1, -1, -1, -1, -1, -1, 1,  1,  -1,
+     -1, 1,  1,  -1, -1, -1, 1,  -1, -1, 1,  1,  -1, 1,  1,  1,  -1, -1, -1, -1,
+     -1, -1, -1, -1, -1, -1, 1,  1,  -1, 1,  1,  -1, 1,  -1, 1,  -1, 1}},
+   {150,
+    5,
+    10,
+    Iris::parents,
+    Iris::children,
+    Iris::lambdas,
+    Iris::sizes,
+    Common::CLUSTER_SELECTION_METHOD::LEAF,
+    false,
+    0.5,
+    {1.,      1.,      0.92582, 0.92582, 1.,      0.63246, 0.7746,  1.,
+     0.67937, 1.,      0.73855, 0.8165,  1.,      0.4899,  0.42008, 0.38255,
+     0.61237, 1.,      0.4714,  0.7746,  0.67937, 0.86603, 0.45486, 0.63246,
+     0.54772, 0.8165,  0.92582, 1.,      1.,      1.,      1.,      0.70711,
+     0.53452, 0.51075, 1.,      0.73855, 0.67937, 0.8165,  0.8165,  1.,
+     1.,      0.30861, 0.7746,  0.57735, 0.51075, 0.92582, 0.73855, 1.,
+     0.86603, 1.,      0.8165,  1.,      0.83205, 0.97333, 1.,      1.,
+     0.92582, 0.53882, 1.,      0.78784, 0.58835, 1.,      0.72761, 0.97333,
+     0.78784, 1.,      1.,      1.,      0.6,     1.,      0.90453, 1.,
+     0.97333, 0.92582, 1.,      1.,      1.,      1.,      1.,      0.90453,
+     1.,      0.97333, 1.,      1.,      0.83205, 0.83205, 1.,      0.68825,
+     1.,      1.,      1.,      1.,      1.,      0.58835, 1.,      1.,
+     1.,      1.,      0.51832, 1.,      0.69749, 1.,      0.84853, 1.,
+     1.,      0.69749, 0.48038, 0.762,   0.67937, 0.52623, 0.90453, 1.,
+     1.,      0.7746,  0.66259, 1.,      1.,      0.41603, 0.43994, 0.647,
+     1.,      0.86603, 0.60609, 1.,      1.,      0.65465, 1.,      1.,
+     1.,      0.6,     0.78784, 0.41404, 0.90453, 0.92582, 0.60609, 0.60609,
+     0.84853, 0.92582, 0.97333, 1.,      1.,      0.8165,  1.,      1.,
+     0.97333, 1.,      0.88465, 1.,      0.67937, 1.},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}},
+   {1797,
+    5,
+    10,
+    Digits::parents,
+    Digits::children,
+    Digits::lambdas,
+    Digits::sizes,
+    Common::CLUSTER_SELECTION_METHOD::LEAF,
+    false,
+    0.0,
+    {1.,      0.58403, 0.,      0.85348, 0.,      0.,      0.,      0.,
+     0.,      0.,      0.73614, 1.,      0.69244, 0.89164, 0.,      0.91287,
+     0.,      0.,      0.,      0.,      0.75426, 1.,      0.82675, 0.82176,
+     0.,      0.,      0.,      0.,      0.,      0.,      0.75316, 0.,
+     0.96262, 0.,      0.,      0.,      0.75986, 0.,      0.,      0.86867,
+     0.5573,  1.,      0.93996, 0.,      0.,      0.,      0.,      1.,
+     0.82796, 0.8055,  0.,      0.,      0.,      0.,      0.,      0.81232,
+     1.,      0.,      0.,      0.8524,  0.87954, 0.,      0.94117, 0.94409,
+     0.,      0.95811, 0.,      0.,      0.,      0.,      0.9984,  0.,
+     0.72607, 0.85888, 0.,      0.,      0.5709,  0.,      0.67642, 1.,
+     0.86672, 1.,      0.,      0.89914, 0.76688, 0.82857, 0.,      0.,
+     0.96954, 0.94117, 0.94535, 0.93258, 0.,      0.,      0.,      0.,
+     0.,      0.,      0.8634,  0.70181, 0.,      0.70802, 0.88235, 0.,
+     0.,      0.,      0.,      0.94671, 0.,      0.87756, 0.,      0.,
+     0.,      0.,      0.54525, 0.,      0.,      1.,      0.,      0.,
+     0.,      0.,      0.,      0.,      1.,      0.,      0.84609, 0.,
+     0.88612, 0.,      0.87394, 0.83787, 0.86184, 0.,      0.,      1.,
+     0.93907, 0.,      0.,      1.,      0.7679,  0.91434, 0.76688, 0.84285,
+     0.,      0.,      0.97148, 0.,      0.,      0.99697, 0.72905, 0.92181,
+     0.67926, 0.82176, 1.,      0.,      0.,      0.,      0.,      0.98953,
+     0.84453, 0.,      1.,      0.89203, 0.90532, 1.,      0.90284, 0.93666,
+     0.,      0.90692, 0.,      0.,      0.,      1.,      0.,      0.98802,
+     0.93646, 0.83787, 0.88445, 0.73206, 0.8707,  0.86435, 0.,      0.54403,
+     0.8056,  0.90859, 1.,      0.80867, 0.,      0.83768, 0.8132,  0.,
+     0.,      0.88192, 0.,      0.96954, 0.,      0.96379, 0.,      0.89579,
+     1.,      1.,      0.91444, 0.,      0.,      0.68987, 0.,      0.76952,
+     0.79364, 0.74772, 0.87847, 0.,      0.,      0.92421, 0.85568, 0.,
+     0.,      0.,      0.89529, 0.98802, 0.,      0.87847, 0.,      0.,
+     0.,      1.,      0.79772, 0.89071, 1.,      1.,      0.99703, 0.,
+     0.,      0.92683, 0.,      0.,      0.,      0.88471, 0.,      0.,
+     0.,      0.82785, 0.58327, 0.74025, 0.73096, 0.9186,  0.9163,  0.,
+     0.58327, 0.56195, 0.,      0.85984, 0.94991, 0.,      0.,      0.,
+     0.79494, 0.71948, 0.89758, 1.,      1.,      0.93031, 1.,      0.,
+     0.,      0.,      0.90666, 0.,      0.93496, 0.88192, 0.9893,  0.,
+     0.9929,  1.,      0.,      0.,      0.94335, 0.,      0.81809, 1.,
+     0.,      0.98706, 0.,      0.,      0.,      0.92322, 0.7445,  0.94043,
+     0.94358, 0.,      0.,      0.,      0.70259, 0.,      0.,      0.,
+     0.,      0.98065, 0.7139,  0.,      1.,      0.95757, 0.,      0.,
+     0.78602, 0.96809, 0.81916, 0.78884, 0.,      1.,      0.93496, 0.93692,
+     0.,      0.87719, 0.,      0.82664, 0.95001, 0.,      0.86005, 0.9914,
+     0.97222, 0.,      0.,      0.,      0.,      0.,      0.89443, 0.,
+     0.94335, 0.,      0.99854, 0.89062, 1.,      0.86184, 0.83537, 0.94771,
+     0.55405, 0.,      0.,      1.,      0.82238, 0.,      0.,      0.,
+     0.94106, 0.98802, 0.71667, 1.,      0.,      0.85635, 0.,      0.91616,
+     0.,      0.,      0.,      0.8493,  0.,      0.7062,  0.88235, 0.94409,
+     1.,      0.,      0.,      0.56466, 0.,      0.88235, 0.,      1.,
+     0.,      0.7722,  0.96465, 0.76864, 0.91346, 0.,      0.,      1.,
+     0.96734, 1.,      0.,      0.,      0.964,   1.,      0.8265,  0.,
+     0.,      0.88552, 0.83839, 0.9413,  0.82785, 0.,      0.,      0.,
+     0.,      1.,      0.,      0.97654, 0.99236, 0.98738, 0.79562, 0.83871,
+     0.,      0.,      0.,      1.,      0.,      0.89798, 0.94991, 0.9413,
+     0.8056,  0.,      1.,      0.,      0.,      1.,      0.,      0.91613,
+     0.75316, 0.86668, 0.,      0.,      0.,      0.,      0.78107, 0.,
+     0.,      1.,      0.94516, 0.,      0.94945, 1.,      0.,      0.91876,
+     0.,      0.87956, 0.94991, 0.89907, 0.7257,  0.79173, 1.,      0.,
+     0.70849, 0.98985, 0.99258, 0.77309, 0.,      0.,      0.80399, 1.,
+     0.8132,  0.85895, 1.,      0.99368, 0.,      0.,      1.,      1.,
+     1.,      0.,      0.87052, 0.86668, 0.,      0.7257,  0.,      0.91644,
+     1.,      0.73409, 0.9536,  1.,      1.,      0.92011, 0.94465, 0.,
+     0.83902, 0.,      0.,      0.85348, 1.,      0.,      0.90354, 0.98738,
+     0.,      0.,      0.,      0.,      0.82961, 0.98738, 1.,      0.78107,
+     0.,      0.,      0.99788, 0.,      0.,      1.,      1.,      0.,
+     0.,      0.,      1.,      0.83118, 0.,      1.,      0.,      0.,
+     1.,      0.95071, 0.,      0.,      0.,      0.,      0.,      0.,
+     0.94119, 0.,      1.,      0.,      0.90284, 1.,      0.67926, 0.,
+     0.,      0.,      1.,      0.,      0.,      0.,      0.81094, 1.,
+     0.,      0.,      0.,      0.8926,  0.,      0.98362, 0.54403, 0.,
+     0.76673, 0.98245, 0.,      0.,      0.,      0.97461, 0.,      1.,
+     0.54403, 0.,      0.97518, 0.,      0.,      0.97733, 0.,      0.89892,
+     0.8524,  0.,      0.,      0.,      0.54403, 0.,      0.96044, 0.,
+     0.,      0.,      1.,      0.81691, 0.73307, 0.85723, 0.72869, 0.72869,
+     0.,      0.,      0.72869, 0.78478, 0.93002, 0.72869, 0.,      0.,
+     0.,      1.,      0.,      0.,      0.95757, 0.,      1.,      0.,
+     0.,      0.,      0.79566, 1.,      0.63311, 0.87167, 0.,      0.6886,
+     0.54403, 0.71409, 0.70439, 0.69468, 0.9147,  1.,      0.,      0.,
+     0.,      0.88104, 1.,      0.,      0.,      0.,      0.77182, 0.,
+     0.,      0.86995, 0.97142, 1.,      0.54403, 1.,      0.,      0.55405,
+     0.,      0.62922, 0.90106, 0.,      1.,      0.85505, 0.,      0.77044,
+     1.,      1.,      0.,      0.,      0.,      0.67504, 0.,      0.87328,
+     0.68987, 0.,      0.95967, 0.95202, 1.,      0.,      0.,      0.54403,
+     0.,      0.,      0.97518, 0.54403, 0.89798, 0.,      0.80957, 0.61237,
+     0.8097,  0.94703, 1.,      0.,      0.99762, 0.,      1.,      1.,
+     0.74557, 0.67006, 0.83569, 0.81602, 1.,      0.,      0.,      1.,
+     0.,      1.,      0.88091, 0.62217, 0.79076, 0.91741, 0.,      0.87756,
+     0.99762, 0.,      1.,      1.,      0.91444, 0.99002, 0.,      0.88265,
+     0.,      0.,      1.,      0.,      0.,      1.,      1.,      0.,
+     0.,      0.,      0.,      0.,      0.95934, 0.,      0.94119, 0.73409,
+     0.75995, 0.77399, 1.,      1.,      0.,      0.61316, 0.61324, 0.,
+     0.,      0.95001, 0.96219, 0.99708, 0.89914, 1.,      0.,      1.,
+     0.,      0.,      1.,      1.,      0.64631, 0.,      0.85081, 0.92227,
+     0.,      0.68924, 0.,      0.76253, 0.77142, 0.92041, 0.5471,  1.,
+     0.,      0.95001, 0.77854, 0.,      0.,      1.,      0.,      0.,
+     0.,      0.,      1.,      0.60055, 1.,      1.,      0.,      0.,
+     0.7995,  0.54835, 0.,      0.79236, 0.,      0.87135, 0.,      0.96989,
+     0.,      0.57161, 1.,      0.,      0.,      0.,      0.,      0.87457,
+     0.,      0.76167, 0.87457, 0.95934, 0.99445, 1.,      0.,      0.,
+     0.95368, 0.,      0.,      1.,      0.85081, 0.,      0.,      0.93892,
+     0.7017,  1.,      0.86184, 0.,      0.,      0.89523, 0.,      0.,
+     0.,      1.,      0.85561, 0.58478, 0.85813, 1.,      0.,      1.,
+     0.,      1.,      0.,      0.,      0.70259, 0.79472, 0.86184, 0.93258,
+     0.,      1.,      0.,      0.,      0.,      0.,      0.93063, 0.87067,
+     0.,      0.87959, 0.,      0.88368, 0.96809, 0.,      0.95476, 0.9173,
+     0.,      0.,      0.60722, 0.,      1.,      0.83564, 0.88471, 0.6735,
+     0.59663, 0.66629, 0.88925, 0.82785, 0.,      0.,      0.86184, 0.76907,
+     0.93002, 1.,      0.,      0.81226, 0.,      0.,      0.,      0.,
+     1.,      0.,      0.,      0.55404, 0.,      0.88401, 0.61412, 0.,
+     0.8236,  0.91496, 0.,      0.77854, 0.,      0.8097,  0.8179,  0.84453,
+     0.55277, 0.,      0.,      0.89287, 0.,      0.65359, 0.,      0.,
+     0.,      1.,      0.69921, 0.92284, 0.88612, 0.81857, 0.,      0.,
+     0.,      0.,      0.83768, 0.86358, 0.,      0.94771, 0.,      0.,
+     0.,      0.95465, 0.92173, 0.5416,  0.,      1.,      0.98267, 0.,
+     1.,      0.82785, 0.83882, 0.,      0.79076, 0.,      0.,      0.88088,
+     1.,      0.,      0.,      0.,      0.,      0.,      0.65514, 0.,
+     0.89253, 0.,      1.,      0.84026, 0.846,   0.,      0.90429, 0.96594,
+     0.,      0.,      0.89253, 0.80957, 1.,      0.766,   0.79861, 0.,
+     0.,      0.90532, 0.,      1.,      0.991,   0.96809, 0.86603, 0.88925,
+     0.84077, 0.,      0.,      0.97247, 0.,      0.,      0.95598, 0.90859,
+     0.92683, 1.,      1.,      0.98825, 0.98989, 0.96809, 0.,      1.,
+     1.,      0.93996, 0.,      0.83817, 0.,      0.,      0.,      0.,
+     1.,      0.82675, 0.,      1.,      0.85447, 1.,      1.,      0.85447,
+     0.,      0.99826, 0.846,   0.,      0.,      0.,      0.,      0.91616,
+     0.,      0.93907, 0.,      0.91149, 1.,      1.,      0.87567, 0.95333,
+     1.,      0.85447, 0.,      0.85447, 0.69296, 0.70529, 1.,      1.,
+     1.,      0.,      0.87198, 1.,      0.,      0.,      0.79421, 1.,
+     0.,      0.90466, 0.9474,  0.,      0.,      0.,      0.,      0.81602,
+     0.90901, 0.,      0.96115, 0.95232, 0.,      1.,      0.87881, 0.95953,
+     1.,      0.,      0.92101, 0.,      0.,      0.,      0.73634, 0.,
+     0.85447, 0.92402, 0.94112, 0.,      0.,      0.,      0.,      0.,
+     0.,      0.64591, 1.,      1.,      1.,      1.,      0.59251, 0.93496,
+     0.93399, 0.,      0.91287, 0.,      0.,      0.,      0.,      0.96345,
+     0.61677, 0.66971, 0.85675, 0.,      0.,      0.90889, 0.,      0.,
+     0.,      0.69642, 1.,      0.85447, 0.82273, 0.,      0.,      0.,
+     0.,      0.,      0.,      0.85561, 0.,      0.,      0.,      0.,
+     0.,      0.85723, 0.,      0.,      0.,      0.,      0.,      0.65465,
+     0.,      0.,      0.876,   0.97733, 0.89443, 0.,      0.,      0.,
+     0.,      0.76339, 0.85561, 0.56398, 0.85447, 0.,      0.8439,  0.90296,
+     0.,      0.,      0.88072, 0.,      0.,      0.,      0.,      0.,
+     0.,      1.,      0.,      0.88624, 0.,      0.8806,  0.79562, 0.,
+     0.79464, 0.77142, 0.76442, 0.83351, 0.,      0.,      0.92284, 0.85447,
+     0.83793, 0.,      0.,      0.,      0.91741, 0.55665, 0.,      0.,
+     0.82275, 0.,      0.,      0.,      0.,      0.88072, 0.74473, 1.,
+     0.83991, 0.,      0.,      0.,      0.,      0.,      0.89443, 0.,
+     0.,      0.,      0.,      0.,      0.98109, 0.,      0.66281, 0.81916,
+     0.,      0.,      0.,      0.,      0.,      0.,      0.,      0.,
+     0.,      0.85561, 0.,      0.,      0.,      0.87394, 0.95923, 0.93496,
+     0.8524,  1.,      0.,      0.,      1.,      0.,      0.,      0.87052,
+     1.,      0.77763, 0.81226, 0.,      0.,      0.,      0.,      0.,
+     0.,      0.79494, 0.,      0.73172, 0.,      0.,      0.9163,  0.,
+     0.,      0.,      0.,      0.79754, 1.,      0.,      0.,      0.,
+     0.,      0.7183,  0.,      0.,      0.9866,  0.,      0.,      0.72232,
+     0.,      1.,      0.,      0.,      0.,      0.64384, 0.73717, 0.77854,
+     0.87457, 0.99262, 0.,      0.86184, 0.83238, 0.95743, 0.85936, 0.,
+     0.,      0.85456, 0.,      0.,      0.81133, 0.,      0.,      1.,
+     0.,      0.,      0.89798, 0.89443, 0.8806,  0.72805, 0.,      0.,
+     0.77399, 0.,      0.66224, 0.83688, 0.86547, 1.,      0.97486, 0.,
+     0.93828, 0.73634, 0.,      0.,      0.,      0.,      0.92147, 0.89443,
+     0.,      0.96268, 0.89443, 0.,      0.,      0.,      1.,      0.,
+     0.,      0.,      0.64043, 0.,      0.,      1.,      0.90805, 0.97148,
+     0.,      0.,      0.89846, 0.,      0.,      1.,      0.82238, 0.,
+     0.76167, 0.70987, 0.,      0.,      0.98369, 0.,      0.,      0.,
+     0.,      0.,      0.99848, 0.64661, 0.,      0.,      0.54281, 0.64179,
+     0.,      0.,      0.80489, 0.,      0.89999, 0.,      0.,      0.58327,
+     0.,      0.70529, 0.,      0.,      0.86565, 0.,      0.,      0.,
+     0.,      0.58327, 0.88506, 0.79623, 0.,      0.70369, 0.,      0.,
+     0.,      0.,      0.,      0.58327, 0.90579, 0.77984, 0.90466, 0.,
+     0.,      0.,      0.88845, 0.74988, 0.87778, 0.58327, 0.85505, 0.58327,
+     0.,      1.,      0.,      0.,      0.8058,  0.,      1.,      0.92041,
+     0.94991, 0.72274, 0.70437, 0.,      0.5709,  0.,      0.86215, 0.94945,
+     0.81073, 1.,      0.846,   0.83871, 0.,      0.80129, 0.88918, 0.,
+     1.,      0.98953, 1.,      0.,      0.90919, 0.87604, 0.,      0.82217,
+     0.9173,  0.,      0.79562, 0.55086, 0.66913, 1.,      0.70081, 0.97822,
+     0.,      0.,      0.92837, 0.85447, 0.60553, 0.,      0.,      0.,
+     0.85456, 0.95743, 0.,      0.,      0.87604, 0.,      0.,      0.54281,
+     0.,      0.88918, 0.88906, 1.,      0.84298, 0.,      0.89914, 0.,
+     0.8657,  0.,      0.89715, 0.,      0.,      0.,      0.,      0.,
+     0.,      0.,      0.85447, 0.76167, 0.,      0.,      0.,      0.,
+     0.,      0.56128, 0.56603, 0.,      0.,      0.6904,  0.55665, 0.91642,
+     0.83226, 1.,      0.84181, 0.,      0.99132, 1.,      1.,      1.,
+     0.90354, 0.8605,  0.9413,  0.8461,  0.92559, 1.,      0.97871, 1.,
+     0.,      1.,      0.89253, 0.78728, 0.99521, 1.,      0.94409, 1.,
+     0.,      1.,      1.,      1.,      1.,      0.87052, 0.99848, 1.,
+     0.98847, 0.,      1.,      0.99236, 0.99848, 0.93996, 0.93541, 0.93996,
+     0.,      0.85949, 0.,      0.,      0.93258, 0.99708, 0.9413,  0.99743,
+     0.99236, 0.85813, 1.,      0.,      0.,      1.,      0.85723, 0.9413,
+     1.,      0.,      0.89536, 0.85348, 1.,      0.8904,  0.8904,  0.,
+     0.94306, 0.,      0.,      1.,      0.90019, 0.9413,  0.8926,  0.81932,
+     0.88088, 0.,      1.,      0.,      1.,      0.82217, 1.,      0.88066,
+     0.,      0.96379, 1.,      0.79269, 0.87307, 1.,      1.,      0.98595,
+     1.,      0.84264, 0.79684, 0.99848, 0.9413,  1.,      0.,      0.,
+     1.,      0.83768, 0.86882, 1.,      0.93692, 1.,      1.,      1.,
+     0.92926, 0.95811, 0.89185, 0.,      0.89574, 1.,      0.,      1.,
+     0.89062, 0.,      0.75825, 1.,      0.,      0.,      0.90242, 0.97733,
+     1.,      0.,      0.,      0.9947,  0.,      1.,      0.,      0.,
+     0.,      0.94991, 0.64226, 0.7257,  0.,      1.,      0.89846, 0.,
+     0.,      0.,      0.9519,  0.84609, 0.62217, 0.,      0.,      1.,
+     0.88992, 0.,      0.,      0.79885, 0.56603, 0.,      0.86906, 0.,
+     0.91287, 0.,      0.,      0.,      0.,      0.,      0.,      0.,
+     0.,      0.,      0.,      0.86883, 0.,      0.,      0.,      0.,
+     1.,      1.,      0.,      0.,      0.,      0.,      0.8786,  0.65012,
+     0.57587, 0.,      0.86814, 0.,      0.58327, 0.,      0.69125, 0.54648,
+     0.7966,  0.,      0.,      0.,      0.,      0.,      0.,      0.,
+     0.,      0.,      0.,      0.,      0.,      0.82916, 1.,      0.67883,
+     1.,      0.,      0.,      0.,      0.87394, 1.,      0.,      0.,
+     0.93828, 0.78505, 0.80244, 0.,      0.,      0.,      0.89412, 0.92884,
+     0.,      0.,      1.,      0.,      0.,      0.,      0.,      0.94409,
+     0.95743, 0.,      0.8309,  0.,      0.91741, 0.,      0.,      0.,
+     1.,      0.,      0.,      0.,      0.,      0.,      0.66224, 0.72274,
+     0.,      0.,      0.,      0.,      0.,      0.99461, 0.,      0.90284,
+     0.,      0.,      0.,      0.89167, 0.,      0.86814, 0.,      0.,
+     0.89892, 0.,      1.,      0.,      1.,      0.96345, 0.64734, 0.7148,
+     0.,      0.,      0.89892, 0.94507, 0.,      0.,      0.98369, 0.775,
+     0.60722, 0.,      0.,      0.,      0.89892, 0.,      1.,      0.,
+     1.,      0.95436, 0.99697, 0.,      0.,      0.,      0.,      0.89907,
+     0.,      0.,      0.91847, 0.,      0.,      0.56061, 0.,      1.,
+     0.,      0.89892, 0.65149, 0.74772, 0.7241,  0.78318, 0.98109, 0.,
+     0.,      0.8097,  0.64453, 0.,      0.72274, 0.,      0.,      0.,
+     0.,      0.,      0.,      0.,      0.,      0.91616, 0.,      0.,
+     0.97512, 0.54772, 0.,      0.83991, 0.99697, 0.,      0.,      0.,
+     0.8097,  0.71735, 0.86547, 0.,      0.,      0.,      0.,      0.67624,
+     0.,      0.,      0.,      0.,      0.8634,  0.65254, 0.,      0.92202,
+     0.66112, 0.,      0.,      0.,      0.,      0.,      0.64734, 0.,
+     0.64731, 0.89469, 0.81508, 0.,      0.,      0.95119, 0.64226, 0.,
+     0.,      0.,      0.,      0.,      0.80256, 0.,      0.92556, 0.74343,
+     0.,      0.,      0.,      0.,      0.,      0.,      0.,      0.,
+     0.91847, 0.74029, 0.,      0.,      0.},
+    {1,  13, -1, 11, -1, -1, -1, -1, -1, -1, 1,  14, 3,  11, -1, 17, -1, -1, -1,
+     -1, 1,  14, 3,  11, -1, -1, -1, -1, -1, -1, 1,  -1, 16, -1, -1, -1, 1,  -1,
+     -1, 15, 13, 10, 14, -1, -1, -1, -1, 14, 1,  1,  -1, -1, -1, -1, -1, 1,  14,
+     -1, -1, 11, 11, -1, 11, 11, -1, 19, -1, -1, -1, -1, 14, -1, 1,  15, -1, -1,
+     13, -1, 1,  1,  14, 6,  -1, 11, 3,  14, -1, -1, 19, 11, 14, 11, -1, -1, -1,
+     -1, -1, -1, 11, 13, -1, 1,  16, -1, -1, -1, -1, 14, -1, 17, -1, -1, -1, -1,
+     13, -1, -1, 17, -1, -1, -1, -1, -1, -1, 10, -1, 1,  -1, 15, -1, 1,  14, 3,
+     -1, -1, 17, 18, -1, -1, 15, 1,  14, 3,  11, -1, -1, 19, -1, -1, 15, 1,  14,
+     3,  11, 8,  -1, -1, -1, -1, 15, 1,  -1, 17, 17, 18, 17, 1,  15, -1, 15, -1,
+     -1, -1, 4,  -1, 11, 17, 14, 1,  1,  3,  3,  -1, 13, 3,  1,  14, 3,  -1, 11,
+     11, -1, -1, 11, -1, 19, -1, 18, -1, 15, 14, 17, 1,  -1, -1, 3,  -1, 3,  1,
+     1,  14, -1, -1, 11, 3,  -1, -1, -1, 14, 11, -1, 14, -1, -1, -1, 8,  11, 14,
+     8,  1,  17, -1, -1, 15, -1, -1, -1, 17, -1, -1, -1, 3,  13, 3,  3,  17, 17,
+     -1, 13, 13, -1, 15, 1,  -1, -1, -1, 1,  13, 3,  11, 10, 16, 18, -1, -1, -1,
+     1,  -1, 3,  11, 10, -1, 18, 6,  -1, -1, 1,  -1, 3,  11, -1, 16, -1, -1, -1,
+     15, 1,  15, 16, -1, -1, -1, 1,  -1, -1, -1, -1, 10, 13, -1, 7,  11, -1, -1,
+     1,  1,  3,  3,  -1, 12, 3,  1,  -1, 3,  -1, 11, 11, -1, 11, 11, 10, -1, -1,
+     -1, -1, -1, 13, -1, 1,  -1, 16, 3,  12, 3,  1,  1,  13, -1, -1, 11, 3,  -1,
+     -1, -1, 18, 11, 13, 11, -1, 13, -1, 18, -1, -1, -1, 13, -1, 1,  16, 11, 18,
+     -1, -1, 13, -1, 16, -1, 10, -1, 3,  12, 3,  3,  -1, -1, 5,  17, 10, -1, -1,
+     10, 5,  1,  -1, -1, 11, 1,  14, 3,  -1, -1, -1, -1, 0,  -1, 15, 1,  14, 3,
+     11, -1, -1, -1, 0,  -1, 15, 1,  14, 3,  -1, 8,  -1, -1, 0,  -1, 15, 1,  15,
+     -1, -1, -1, -1, 1,  -1, -1, 15, 12, -1, 14, 0,  -1, 11, -1, 14, 1,  1,  3,
+     3,  0,  -1, 3,  1,  2,  3,  -1, -1, 11, 0,  11, 11, 8,  19, -1, -1, 8,  15,
+     14, -1, 1,  15, -1, 3,  -1, 3,  1,  1,  14, 0,  19, 11, 3,  -1, 0,  -1, -1,
+     11, 14, -1, 15, 14, -1, -1, -1, -1, 11, 14, 8,  1,  -1, -1, 19, -1, -1, 14,
+     0,  -1, -1, -1, 0,  3,  -1, 3,  -1, -1, 0,  15, -1, -1, -1, -1, -1, -1, 1,
+     -1, 15, -1, 1,  2,  3,  -1, -1, -1, 19, -1, -1, -1, 1,  2,  -1, -1, -1, 16,
+     -1, 6,  13, -1, 1,  2,  -1, -1, -1, 16, -1, 4,  13, -1, 1,  -1, -1, 16, -1,
+     16, 1,  -1, -1, -1, 13, -1, 2,  -1, -1, -1, 16, 2,  1,  1,  3,  3,  -1, -1,
+     3,  1,  2,  3,  -1, -1, -1, 4,  -1, -1, 10, -1, 19, -1, -1, -1, 2,  16, 1,
+     15, -1, 3,  13, 3,  1,  1,  2,  6,  -1, -1, -1, 2,  6,  -1, -1, -1, 2,  -1,
+     -1, 2,  6,  19, 13, 9,  -1, 13, -1, 1,  16, -1, 19, 15, -1, 2,  6,  16, -1,
+     -1, -1, 3,  -1, 3,  3,  -1, 6,  15, 16, -1, -1, 13, -1, -1, 1,  13, 15, -1,
+     1,  13, 3,  11, 8,  -1, 18, -1, 12, 5,  1,  13, 3,  11, 8,  -1, -1, 4,  -1,
+     5,  1,  13, 3,  11, -1, 17, 18, -1, 12, 5,  1,  5,  -1, 17, -1, -1, 1,  -1,
+     -1, 5,  12, -1, -1, -1, -1, -1, 17, -1, 1,  1,  3,  3,  4,  12, -1, 1,  13,
+     -1, -1, 11, 11, 4,  11, 11, -1, 18, -1, -1, 8,  5,  13, -1, 1,  5,  -1, 3,
+     -1, 3,  1,  1,  13, 4,  -1, 11, 3,  -1, -1, 8,  -1, -1, -1, -1, 5,  13, 4,
+     18, -1, -1, 11, 13, -1, 1,  -1, 11, -1, 5,  -1, 13, 4,  -1, -1, -1, -1, 3,
+     -1, 3,  3,  17, 6,  5,  -1, -1, 12, -1, -1, 5,  1,  -1, -1, 12, 1,  13, 3,
+     -1, -1, 17, -1, -1, -1, 15, 1,  13, 3,  11, -1, 17, -1, 6,  -1, -1, 1,  13,
+     3,  11, -1, 17, -1, -1, -1, -1, 1,  15, -1, 17, -1, 17, 1,  -1, 12, 15, -1,
+     -1, 13, -1, 7,  11, 17, 13, 1,  1,  3,  3,  -1, -1, 3,  1,  2,  3,  -1, 11,
+     -1, -1, -1, -1, 9,  -1, -1, 1,  -1, 15, 13, -1, 1,  15, -1, 3,  -1, 3,  1,
+     1,  13, -1, -1, 11, -1, 13, -1, -1, -1, 11, 13, 11, 15, 13, -1, -1, -1, -1,
+     11, 13, -1, 1,  -1, -1, -1, 15, 18, 13, -1, 17, 9,  -1, 7,  3,  14, -1, 3,
+     -1, -1, 15, 17, -1, -1, -1, -1, -1, 1,  -1, 15, -1, 2,  3,  11, -1, 16, 18,
+     -1, -1, 15, 1,  2,  3,  11, -1, -1, 18, -1, 12, 15, 1,  2,  3,  11, -1, -1,
+     18, -1, -1, 15, 1,  15, 16, 16, 18, 16, 1,  -1, 12, 15, 12, -1, 2,  -1, -1,
+     -1, -1, 2,  3,  -1, 12, 3,  1,  2,  3,  -1, 11, 11, -1, -1, -1, -1, 18, -1,
+     18, -1, 15, 2,  16, 1,  15, 16, 3,  -1, 3,  1,  1,  2,  7,  18, -1, 3,  2,
+     -1, -1, 11, 2,  -1, 15, 2,  -1, -1, -1, -1, 11, 2,  -1, 1,  16, -1, 18, 15,
+     18, 2,  -1, 16, -1, -1, -1, 3,  -1, 3,  3,  16, -1, -1, -1, -1, -1, -1, 1,
+     12, 15, 12, 1,  13, 3,  11, -1, 17, -1, -1, -1, -1, 1,  13, 3,  11, -1, -1,
+     18, -1, -1, -1, 1,  13, 3,  11, -1, -1, -1, -1, -1, -1, 1,  -1, -1, -1, -1,
+     -1, 1,  -1, -1, -1, -1, -1, 13, -1, -1, 11, 16, 13, -1, -1, -1, -1, 3,  1,
+     13, 3,  -1, 11, 11, -1, -1, 11, -1, -1, -1, -1, -1, -1, 13, -1, 1,  -1, 17,
+     3,  -1, 3,  1,  1,  13, -1, -1, 11, 3,  13, -1, -1, -1, 11, 13, -1, -1, 13,
+     -1, -1, -1, -1, 11, 13, 10, 1,  -1, -1, -1, -1, -1, 13, -1, -1, -1, -1, -1,
+     3,  -1, 3,  3,  -1, -1, -1, -1, -1, -1, -1, -1, -1, 1,  -1, -1, -1, 1,  14,
+     3,  11, 10, -1, -1, 6,  -1, -1, 1,  14, 3,  11, -1, -1, -1, -1, -1, -1, 1,
+     -1, 3,  -1, -1, 17, -1, -1, -1, -1, 1,  15, -1, -1, -1, -1, 1,  -1, -1, 15,
+     -1, -1, 13, -1, 6,  -1, -1, -1, 1,  1,  3,  3,  6,  -1, 3,  1,  13, 3,  -1,
+     -1, 11, -1, -1, 11, -1, -1, 19, -1, -1, 15, 13, 17, 1,  -1, -1, 3,  -1, 3,
+     1,  1,  13, 6,  -1, 11, 3,  -1, -1, -1, -1, 11, 13, -1, 15, 13, -1, -1, -1,
+     10, -1, -1, -1, 1,  -1, -1, 19, 15, 19, -1, -1, 17, -1, -1, 4,  3,  -1, 3,
+     3,  -1, -1, 15, -1, -1, -1, -1, -1, 15, 1,  -1, -1, 13, 1,  -1, -1, 11, -1,
+     16, -1, -1, 13, -1, 1,  -1, -1, 11, -1, -1, -1, -1, 13, 15, 1,  -1, 3,  -1,
+     -1, -1, -1, -1, 13, 15, 1,  15, -1, -1, -1, 16, 1,  15, 13, 15, 13, -1, 13,
+     -1, -1, 11, -1, 13, 1,  1,  3,  3,  -1, 13, -1, 1,  14, 3,  19, 11, 11, -1,
+     11, 11, -1, 19, 19, 19, -1, 15, 13, -1, 1,  15, -1, 3,  13, 3,  1,  1,  14,
+     -1, -1, 11, 3,  13, -1, -1, -1, 11, 13, -1, -1, 13, -1, -1, 13, -1, 11, 13,
+     10, 1,  -1, 11, -1, 15, -1, 13, -1, -1, -1, -1, -1, -1, -1, 3,  3,  -1, -1,
+     -1, -1, -1, 13, 13, -1, -1, 1,  13, 1,  14, 3,  11, -1, 16, 18, 7,  12, 15,
+     1,  14, 3,  11, 9,  16, 18, -1, 12, 15, 1,  14, 3,  11, 9,  -1, 18, 7,  12,
+     15, 1,  15, 16, 16, -1, 16, 1,  15, 12, 15, 12, -1, 14, -1, -1, 11, 16, 14,
+     1,  1,  3,  3,  -1, -1, 3,  1,  14, 3,  -1, 11, 11, 7,  11, 11, -1, 18, -1,
+     -1, 9,  15, 14, 16, 1,  15, -1, 3,  -1, 3,  1,  1,  14, -1, 18, 11, 3,  14,
+     7,  9,  18, 11, 14, 11, 15, 14, 7,  -1, -1, 9,  11, 14, 9,  1,  16, 11, 18,
+     15, 19, 14, -1, 16, 9,  -1, 7,  3,  -1, 3,  3,  -1, -1, 15, 16, 9,  -1, -1,
+     9,  -1, 1,  -1, -1, -1, 1,  13, 3,  -1, 10, 17, -1, -1, -1, 5,  1,  13, -1,
+     -1, 10, 17, -1, -1, 1,  13, -1, 11, -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
+     -1, -1, 1,  -1, -1, -1, -1, 10, 13, -1, -1, -1, -1, 13, 1,  1,  -1, 3,  -1,
+     13, -1, 1,  13, 3,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 13, 17,
+     1,  15, -1, -1, -1, 1,  13, -1, -1, 11, 3,  13, -1, -1, -1, 11, 13, -1, -1,
+     13, -1, -1, -1, -1, 11, 13, -1, 1,  -1, 11, -1, -1, -1, 13, -1, -1, -1, -1,
+     -1, 3,  3,  -1, -1, -1, -1, -1, 10, -1, 1,  -1, -1, -1, 1,  -1, 3,  -1, -1,
+     16, -1, 6,  -1, 15, 1,  13, 3,  -1, -1, 16, 18, -1, -1, 15, 1,  13, -1, -1,
+     -1, 16, -1, 6,  -1, 15, 1,  15, -1, -1, -1, -1, 1,  -1, -1, 15, -1, -1, 13,
+     -1, 4,  -1, 16, 13, 1,  1,  3,  3,  -1, -1, 3,  1,  -1, 3,  -1, -1, -1, -1,
+     -1, -1, -1, -1, 18, -1, -1, 15, 13, -1, 1,  15, -1, -1, -1, 3,  1,  1,  -1,
+     -1, -1, -1, 3,  -1, -1, -1, -1, 11, 13, -1, 15, 13, -1, -1, -1, -1, -1, 13,
+     -1, 1,  16, 11, -1, -1, 18, 13, -1, -1, -1, -1, -1, 3,  -1, 3,  3,  -1, -1,
+     -1, -1, -1, -1, -1, -1, 15, 1,  -1, -1, -1}}};
+
+};  // namespace HDBSCAN
+};  // namespace ML
\ No newline at end of file
diff --git a/cpp/test/sg/hdbscan_test.cu b/cpp/test/sg/hdbscan_test.cu
new file mode 100644
index 0000000000..6b4a2fb4a8
--- /dev/null
+++ b/cpp/test/sg/hdbscan_test.cu
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) 2021, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hdbscan_inputs.hpp"
+
+#include <gtest/gtest.h>
+#include <raft/cudart_utils.h>
+#include <raft/cuda_utils.cuh>
+#include <vector>
+
+#include <hdbscan/detail/utils.h>
+#include <cuml/cluster/hdbscan.hpp>
+#include <hdbscan/detail/condense.cuh>
+#include <hdbscan/detail/extract.cuh>
+
+#include <metrics/adjusted_rand_index.cuh>
+
+#include <raft/sparse/hierarchy/detail/agglomerative.cuh>
+
+#include <raft/linalg/distance_type.h>
+#include <raft/linalg/transpose.h>
+#include <raft/sparse/op/sort.h>
+#include <raft/mr/device/allocator.hpp>
+#include <raft/sparse/coo.cuh>
+#include <rmm/device_uvector.hpp>
+
+#include "../prims/test_utils.h"
+
+namespace ML {
+namespace HDBSCAN {
+
+using namespace std;
+
+template <typename T, typename IdxT>
+::std::ostream& operator<<(::std::ostream& os,
+                           const HDBSCANInputs<T, IdxT>& dims) {
+  return os;
+}
+
+template <typename T, typename IdxT>
+class HDBSCANTest : public ::testing::TestWithParam<HDBSCANInputs<T, IdxT>> {
+ protected:
+  void basicTest() {
+    raft::handle_t handle;
+
+    params = ::testing::TestWithParam<HDBSCANInputs<T, IdxT>>::GetParam();
+
+    rmm::device_uvector<T> data(params.n_row * params.n_col,
+                                handle.get_stream());
+
+    // Allocate result labels and expected labels on device
+    raft::allocate(labels_ref, params.n_row);
+
+    raft::copy(data.data(), params.data.data(), data.size(),
+               handle.get_stream());
+    raft::copy(labels_ref, params.expected_labels.data(), params.n_row,
+               handle.get_stream());
+
+    rmm::device_uvector<IdxT> out_children(params.n_row * 2,
+                                           handle.get_stream());
+    rmm::device_uvector<T> out_deltas(params.n_row, handle.get_stream());
+
+    rmm::device_uvector<IdxT> out_sizes(params.n_row * 2, handle.get_stream());
+
+    rmm::device_uvector<IdxT> out_labels(params.n_row, handle.get_stream());
+
+    rmm::device_uvector<IdxT> mst_src(params.n_row - 1, handle.get_stream());
+    rmm::device_uvector<IdxT> mst_dst(params.n_row - 1, handle.get_stream());
+    rmm::device_uvector<T> mst_weights(params.n_row - 1, handle.get_stream());
+
+    rmm::device_uvector<T> out_probabilities(params.n_row, handle.get_stream());
+
+    Logger::get().setLevel(CUML_LEVEL_DEBUG);
+
+    HDBSCAN::Common::hdbscan_output<IdxT, T> out(
+      handle, params.n_row, out_labels.data(), out_probabilities.data(),
+      out_children.data(), out_sizes.data(), out_deltas.data(), mst_src.data(),
+      mst_dst.data(), mst_weights.data());
+
+    HDBSCAN::Common::HDBSCANParams hdbscan_params;
+    hdbscan_params.k = params.k;
+    hdbscan_params.min_cluster_size = params.min_cluster_size;
+    hdbscan_params.min_samples = params.min_pts;
+
+    hdbscan(handle, data.data(), params.n_row, params.n_col,
+            raft::distance::DistanceType::L2SqrtExpanded, hdbscan_params, out);
+
+    CUDA_CHECK(cudaStreamSynchronize(handle.get_stream()));
+
+    score = MLCommon::Metrics::compute_adjusted_rand_index(
+      out.get_labels(), labels_ref, params.n_row, handle.get_device_allocator(),
+      handle.get_stream());
+  }
+
+  void SetUp() override { basicTest(); }
+
+  void TearDown() override { CUDA_CHECK(cudaFree(labels_ref)); }
+
+ protected:
+  HDBSCANInputs<T, IdxT> params;
+  IdxT* labels_ref;
+  int k;
+
+  double score;
+};
+
+typedef HDBSCANTest<float, int> HDBSCANTestF_Int;
+TEST_P(HDBSCANTestF_Int, Result) { EXPECT_TRUE(score >= 0.85); }
+
+INSTANTIATE_TEST_CASE_P(HDBSCANTest, HDBSCANTestF_Int,
+                        ::testing::ValuesIn(hdbscan_inputsf2));
+
+template <typename T, typename IdxT>
+class ClusterCondensingTest
+  : public ::testing::TestWithParam<ClusterCondensingInputs<T, IdxT>> {
+ protected:
+  void basicTest() {
+    raft::handle_t handle;
+
+    params =
+      ::testing::TestWithParam<ClusterCondensingInputs<T, IdxT>>::GetParam();
+
+    rmm::device_uvector<IdxT> mst_src(params.n_row - 1, handle.get_stream());
+    rmm::device_uvector<IdxT> mst_dst(params.n_row - 1, handle.get_stream());
+    rmm::device_uvector<T> mst_data(params.n_row - 1, handle.get_stream());
+
+    raft::copy(mst_src.data(), params.mst_src.data(), params.mst_src.size(),
+               handle.get_stream());
+
+    raft::copy(mst_dst.data(), params.mst_dst.data(), params.mst_dst.size(),
+               handle.get_stream());
+
+    raft::copy(mst_data.data(), params.mst_data.data(), params.mst_data.size(),
+               handle.get_stream());
+
+    rmm::device_uvector<IdxT> expected_device(params.expected.size(),
+                                              handle.get_stream());
+    raft::copy(expected_device.data(), params.expected.data(),
+               params.expected.size(), handle.get_stream());
+
+    rmm::device_uvector<IdxT> out_children(params.n_row * 2,
+                                           handle.get_stream());
+
+    rmm::device_uvector<IdxT> out_size(params.n_row, handle.get_stream());
+
+    rmm::device_uvector<T> out_delta(params.n_row, handle.get_stream());
+
+    Logger::get().setLevel(CUML_LEVEL_DEBUG);
+
+    raft::sparse::op::coo_sort_by_weight(mst_src.data(), mst_dst.data(),
+                                         mst_data.data(), (IdxT)mst_src.size(),
+                                         handle.get_stream());
+
+    /**
+     * Build dendrogram of MST
+     */
+    raft::hierarchy::detail::build_dendrogram_host(
+      handle, mst_src.data(), mst_dst.data(), mst_data.data(), params.n_row - 1,
+      out_children.data(), out_delta.data(), out_size.data());
+
+    /**
+     * Condense Hierarchy
+     */
+    HDBSCAN::Common::CondensedHierarchy<IdxT, T> condensed_tree(handle,
+                                                                params.n_row);
+    HDBSCAN::detail::Condense::build_condensed_hierarchy(
+      handle, out_children.data(), out_delta.data(), out_size.data(),
+      params.min_cluster_size, params.n_row, condensed_tree);
+
+    CUDA_CHECK(cudaStreamSynchronize(handle.get_stream()));
+
+    rmm::device_uvector<IdxT> labels(params.n_row, handle.get_stream());
+    rmm::device_uvector<T> stabilities(condensed_tree.get_n_clusters(),
+                                       handle.get_stream());
+    rmm::device_uvector<T> probabilities(params.n_row, handle.get_stream());
+
+    HDBSCAN::detail::Extract::extract_clusters(
+      handle, condensed_tree, params.n_row, labels.data(), stabilities.data(),
+      probabilities.data(), HDBSCAN::Common::CLUSTER_SELECTION_METHOD::EOM,
+      false);
+
+    //    CUML_LOG_DEBUG("Evaluating results");
+    //    if (params.expected.size() == params.n_row) {
+    //      score = MLCommon::Metrics::compute_adjusted_rand_index(
+    //        labels.data(), expected_device.data(), params.n_row,
+    //        handle.get_device_allocator(), handle.get_stream());
+    //    } else {
+    //      score = 1.0;
+    //    }
+  }
+
+  void SetUp() override { basicTest(); }
+
+  void TearDown() override {}
+
+ protected:
+  ClusterCondensingInputs<T, IdxT> params;
+  int k;
+
+  double score;
+};
+
+typedef ClusterCondensingTest<float, int> ClusterCondensingTestF_Int;
+TEST_P(ClusterCondensingTestF_Int, Result) { EXPECT_TRUE(score == 1.0); }
+
+// This will be reactivate in 21.08 with better, contrived examples to
+// test Cluster Condensation correctly
+// INSTANTIATE_TEST_CASE_P(ClusterCondensingTest, ClusterCondensingTestF_Int,
+//                         ::testing::ValuesIn(cluster_condensing_inputs));
+
+template <typename T, typename IdxT>
+class ClusterSelectionTest
+  : public ::testing::TestWithParam<ClusterSelectionInputs<T, IdxT>> {
+ protected:
+  void basicTest() {
+    raft::handle_t handle;
+
+    params =
+      ::testing::TestWithParam<ClusterSelectionInputs<T, IdxT>>::GetParam();
+
+    Logger::get().setLevel(CUML_LEVEL_DEBUG);
+
+    rmm::device_uvector<IdxT> condensed_parents(params.condensed_parents.size(),
+                                                handle.get_stream());
+    rmm::device_uvector<IdxT> condensed_children(
+      params.condensed_children.size(), handle.get_stream());
+    rmm::device_uvector<T> condensed_lambdas(params.condensed_lambdas.size(),
+                                             handle.get_stream());
+    rmm::device_uvector<IdxT> condensed_sizes(params.condensed_sizes.size(),
+                                              handle.get_stream());
+
+    // outputs
+    rmm::device_uvector<T> stabilities(params.n_row, handle.get_stream());
+    rmm::device_uvector<T> probabilities(params.n_row, handle.get_stream());
+    rmm::device_uvector<IdxT> labels(params.n_row, handle.get_stream());
+
+    raft::copy(condensed_parents.data(), params.condensed_parents.data(),
+               condensed_parents.size(), handle.get_stream());
+
+    raft::copy(condensed_children.data(), params.condensed_children.data(),
+               condensed_children.size(), handle.get_stream());
+
+    raft::copy(condensed_lambdas.data(), params.condensed_lambdas.data(),
+               condensed_lambdas.size(), handle.get_stream());
+
+    raft::copy(condensed_sizes.data(), params.condensed_sizes.data(),
+               condensed_sizes.size(), handle.get_stream());
+
+    ML::HDBSCAN::Common::CondensedHierarchy<IdxT, T> condensed_tree(
+      handle, params.n_row, params.condensed_parents.size(),
+      condensed_parents.data(), condensed_children.data(),
+      condensed_lambdas.data(), condensed_sizes.data());
+
+    ML::HDBSCAN::detail::Extract::extract_clusters(
+      handle, condensed_tree, params.n_row, labels.data(), stabilities.data(),
+      probabilities.data(), params.cluster_selection_method,
+      params.allow_single_cluster, 0, params.cluster_selection_epsilon);
+
+    CUDA_CHECK(cudaStreamSynchronize(handle.get_stream()));
+
+    ASSERT_TRUE(raft::devArrMatch(
+      probabilities.data(), params.probabilities.data(), params.n_row,
+      raft::CompareApprox<float>(1e-4), handle.get_stream()));
+
+    rmm::device_uvector<IdxT> labels_ref(params.n_row, handle.get_stream());
+    raft::update_device(labels_ref.data(), params.labels.data(), params.n_row,
+                        handle.get_stream());
+    score = MLCommon::Metrics::compute_adjusted_rand_index(
+      labels.data(), labels_ref.data(), params.n_row,
+      handle.get_device_allocator(), handle.get_stream());
+    CUDA_CHECK(cudaStreamSynchronize(handle.get_stream()));
+  }
+
+  void SetUp() override { basicTest(); }
+
+  void TearDown() override {}
+
+ protected:
+  ClusterSelectionInputs<T, IdxT> params;
+  T score;
+};
+
+typedef ClusterSelectionTest<float, int> ClusterSelectionTestF_Int;
+TEST_P(ClusterSelectionTestF_Int, Result) { EXPECT_TRUE(score == 1.0); }
+
+INSTANTIATE_TEST_CASE_P(ClusterSelectionTest, ClusterSelectionTestF_Int,
+                        ::testing::ValuesIn(cluster_selection_inputs));
+
+}  // namespace HDBSCAN
+}  // end namespace ML
diff --git a/cpp/test/sg/umap_parametrizable_test.cu b/cpp/test/sg/umap_parametrizable_test.cu
index fe756f0889..293b8c8dba 100644
--- a/cpp/test/sg/umap_parametrizable_test.cu
+++ b/cpp/test/sg/umap_parametrizable_test.cu
@@ -217,6 +217,7 @@ class UMAPParametrizableTest : public ::testing::Test {
 
     device_buffer<float> embeddings1(alloc, stream,
                                      n_samples * umap_params.n_components);
+
     float* e1 = embeddings1.data();
 
     get_embedding(handle, X_d.data(), (float*)y_d.data(), e1, test_params,
diff --git a/docs/source/api.rst b/docs/source/api.rst
index a6fec30c0c..bfc52da5a1 100644
--- a/docs/source/api.rst
+++ b/docs/source/api.rst
@@ -165,8 +165,8 @@ Metrics (regression, classification, and distance)
   .. automodule:: cuml.metrics.pairwise_distances
     :members:
 
-Metrics (clustering and trustworthiness)
-----------------------------------------
+Metrics (clustering and manifold learning)
+------------------------------------------
   .. automodule:: cuml.metrics.trustworthiness
     :members:
 
@@ -557,6 +557,12 @@ Preprocessing
       add_dummy_feature, binarize, minmax_scale, normalize,
       PolynomialFeatures, robust_scale, scale
 
+Clustering
+----------
+
+.. autoclass:: cuml.experimental.cluster.HDBSCAN
+   :members:
+
 Linear Models
 -------------
 .. autoclass:: cuml.experimental.linear_model.Lars
diff --git a/python/cuml/cluster/agglomerative.pyx b/python/cuml/cluster/agglomerative.pyx
index a9b1db7a0d..df5ce36816 100644
--- a/python/cuml/cluster/agglomerative.pyx
+++ b/python/cuml/cluster/agglomerative.pyx
@@ -199,9 +199,7 @@ class AgglomerativeClustering(Base, ClusterMixin, CMajorInputTagMixin):
         cdef uintptr_t labels_ptr = self.labels_.ptr
         cdef uintptr_t children_ptr = self.children_.ptr
 
-        cdef linkage_output_int_float* linkage_output = \
-            new linkage_output_int_float()
-
+        cdef linkage_output_int_float linkage_output
         linkage_output.children = <int*>children_ptr
         linkage_output.labels = <int*>labels_ptr
 
@@ -214,13 +212,13 @@ class AgglomerativeClustering(Base, ClusterMixin, CMajorInputTagMixin):
         if self.connectivity == 'knn':
             single_linkage_neighbors(
                 handle_[0], <float*>input_ptr, <int> n_rows,
-                <int> n_cols, <linkage_output_int_float*> linkage_output,
+                <int> n_cols, <linkage_output_int_float*> &linkage_output,
                 <DistanceType> metric, <int>self.n_neighbors,
                 <int> self.n_clusters)
         elif self.connectivity == 'pairwise':
             single_linkage_pairwise(
                 handle_[0], <float*>input_ptr, <int> n_rows,
-                <int> n_cols, <linkage_output_int_float*> linkage_output,
+                <int> n_cols, <linkage_output_int_float*> &linkage_output,
                 <DistanceType> metric, <int> self.n_clusters)
         else:
             raise ValueError("'connectivity' can only be one of "
diff --git a/python/cuml/common/import_utils.py b/python/cuml/common/import_utils.py
index 1afd6a4bbf..7f46152e9a 100644
--- a/python/cuml/common/import_utils.py
+++ b/python/cuml/common/import_utils.py
@@ -123,6 +123,17 @@ def has_sklearn():
         return False
 
 
+def has_hdbscan_plots(raise_if_unavailable=True):
+    try:
+        from hdbscan.plots import SingleLinkageTree  # NOQA
+        return True
+    except ImportError:
+        if(raise_if_unavailable):
+            raise ImportError("hdbscan must be installed to use plots.")
+        else:
+            return False
+
+
 def has_shap(min_version="0.37"):
     try:
         import shap  # noqa
diff --git a/python/cuml/experimental/cluster/__init__.py b/python/cuml/experimental/cluster/__init__.py
new file mode 100644
index 0000000000..704913dc25
--- /dev/null
+++ b/python/cuml/experimental/cluster/__init__.py
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2021, NVIDIA CORPORATION.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+from cuml.experimental.cluster.hdbscan import HDBSCAN
diff --git a/python/cuml/experimental/cluster/hdbscan.pyx b/python/cuml/experimental/cluster/hdbscan.pyx
new file mode 100644
index 0000000000..b81d4bff0a
--- /dev/null
+++ b/python/cuml/experimental/cluster/hdbscan.pyx
@@ -0,0 +1,556 @@
+#
+# Copyright (c) 2021, NVIDIA CORPORATION.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# distutils: language = c++
+
+from libc.stdint cimport uintptr_t
+from libcpp cimport bool
+
+from cython.operator cimport dereference as deref
+
+import numpy as np
+import cupy as cp
+
+from cuml.common.array import CumlArray
+from cuml.common.base import Base
+from cuml.common.doc_utils import generate_docstring
+from cuml.raft.common.handle cimport handle_t
+from cuml.common import input_to_cuml_array
+from cuml.common.array_descriptor import CumlArrayDescriptor
+from cuml.common.mixins import ClusterMixin
+from cuml.common.mixins import CMajorInputTagMixin
+from cuml.common import logger
+from cuml.common.import_utils import has_hdbscan_plots
+
+import cuml
+from cuml.metrics.distance_type cimport DistanceType
+
+
+cdef extern from "cuml/cluster/hdbscan.hpp" namespace "ML::HDBSCAN::Common":
+
+    ctypedef enum CLUSTER_SELECTION_METHOD:
+        EOM "ML::HDBSCAN::Common::CLUSTER_SELECTION_METHOD::EOM"
+        LEAF "ML::HDBSCAN::Common::CLUSTER_SELECTION_METHOD::LEAF"
+
+    cdef cppclass CondensedHierarchy_int_float:
+        int *get_parents()
+        int *get_children()
+        float *get_lambdas()
+        int *get_sizes()
+        int get_n_edges()
+
+    cdef cppclass hdbscan_output[int, float]:
+        hdbscan_output(const handle_t &handle,
+                       int n_leaves,
+                       int *labels,
+                       float *probabilities,
+                       int *children,
+                       int *sizes,
+                       float *deltas,
+                       int *mst_src,
+                       int *mst_dst,
+                       float *mst_weights)
+        int get_n_leaves()
+        int get_n_clusters()
+        float *get_stabilities()
+        CondensedHierarchy_int_float &get_condensed_tree()
+
+    cdef cppclass HDBSCANParams:
+        int k
+        int min_samples
+        int min_cluster_size
+        int max_cluster_size,
+
+        float cluster_selection_epsilon,
+
+        bool allow_single_cluster,
+        CLUSTER_SELECTION_METHOD cluster_selection_method
+
+
+cdef extern from "cuml/cluster/hdbscan.hpp" namespace "ML":
+
+    void hdbscan(const handle_t & handle,
+                 const float * X,
+                 size_t m, size_t n,
+                 DistanceType metric,
+                 HDBSCANParams & params,
+                 hdbscan_output & output)
+
+_metrics_mapping = {
+    'l1': DistanceType.L1,
+    'cityblock': DistanceType.L1,
+    'manhattan': DistanceType.L1,
+    'l2': DistanceType.L2SqrtExpanded,
+    'euclidean': DistanceType.L2SqrtExpanded,
+    'cosine': DistanceType.CosineExpanded
+}
+
+
+def delete_hdbscan_output(obj):
+    cdef hdbscan_output *output
+    if hasattr(obj, "hdbscan_output_"):
+        output = <hdbscan_output*>\
+                  <uintptr_t> obj.hdbscan_output_
+        del output
+        del obj.hdbscan_output_
+
+
+class HDBSCAN(Base, ClusterMixin, CMajorInputTagMixin):
+
+    """
+    HDBSCAN Clustering
+
+    Recursively merges the pair of clusters that minimally increases a
+    given linkage distance.
+
+    Parameters
+    ----------
+    handle : cuml.Handle
+        Specifies the cuml.handle that holds internal CUDA state for
+        computations in this model. Most importantly, this specifies the CUDA
+        stream that will be used for the model's computations, so users can
+        run different models concurrently in different streams by creating
+        handles in several streams.
+        If it is None, a new one is created.
+
+    alpha : float, optional (default=1.0)
+        A distance scaling parameter as used in robust single linkage.
+        See [2]_ for more information.
+
+    verbose : int or boolean, default=False
+        Sets logging level. It must be one of `cuml.common.logger.level_*`.
+        See :ref:`verbosity-levels` for more info.
+
+    min_cluster_size : int, optional (default = 5)
+        The minimum number of samples in a group for that group to be
+        considered a cluster; groupings smaller than this size will be left
+        as noise.
+
+    min_samples : int, optional (default=None)
+        The number of samples in a neighborhood for a point
+        to be considered as a core point. This includes the point itself.
+        If 'None', it defaults to the min_cluster_size.
+
+    cluster_selection_epsilon : float, optional (default=0.0)
+        A distance threshold. Clusters below this value will be merged.
+        See [3]_ for more information. Note that this should not be used
+        if we want to predict the cluster labels for new points in future
+        (e.g. using approximate_predict), as the approximate_predict function
+        is not aware of this argument.
+
+    max_cluster_size : int, optional (default=0)
+        A limit to the size of clusters returned by the eom algorithm.
+        Has no effect when using leaf clustering (where clusters are
+        usually small regardless) and can also be overridden in rare
+        cases by a high value for cluster_selection_epsilon. Note that
+        this should not be used if we want to predict the cluster labels
+        for new points in future (e.g. using approximate_predict), as
+        the approximate_predict function is not aware of this argument.
+
+    metric : string or callable, optional (default='minkowski')
+        The metric to use when calculating distance between instances in a
+        feature array. If metric is a string or callable, it must be one of
+        the options allowed by metrics.pairwise.pairwise_distances for its
+        metric parameter.
+        If metric is "precomputed", X is assumed to be a distance matrix and
+        must be square.
+
+    p : int, optional (default=2)
+        p value to use if using the minkowski metric.
+
+    cluster_selection_method : string, optional (default='eom')
+        The method used to select clusters from the condensed tree. The
+        standard approach for HDBSCAN* is to use an Excess of Mass algorithm
+        to find the most persistent clusters. Alternatively you can instead
+        select the clusters at the leaves of the tree -- this provides the
+        most fine grained and homogeneous clusters. Options are:
+            * ``eom``
+            * ``leaf``
+
+    allow_single_cluster : bool, optional (default=False)
+        By default HDBSCAN* will not produce a single cluster, setting this
+        to True will override this and allow single cluster results in
+        the case that you feel this is a valid result for your dataset.
+
+    gen_min_span_tree : bool, optional (default=False)
+        Whether to populate the minimum_spanning_tree_ member for
+        utilizing plotting tools. This requires the `hdbscan` CPU Python
+        package to be installed.
+
+    gen_condensed_tree : bool, optional (default=False)
+        Whether to populate the condensed_tree_ member for
+        utilizing plotting tools. This requires the `hdbscan` CPU
+        Python package to be installed.
+
+    gen_single_linkage_tree_ : bool, optinal (default=False)
+        Whether to populate the single_linkage_tree_ member for
+        utilizing plotting tools. This requires the `hdbscan` CPU
+        Python package t be installed.
+
+    output_type : {'input', 'cudf', 'cupy', 'numpy', 'numba'}, default=None
+        Variable to control output type of the results and attributes of
+        the estimator. If None, it'll inherit the output type set at the
+        module level, `cuml.global_settings.output_type`.
+        See :ref:`output-data-type-configuration` for more info.
+
+
+    Attributes
+    ----------
+    labels_ : ndarray, shape (n_samples, )
+        Cluster labels for each point in the dataset given to fit().
+        Noisy samples are given the label -1.
+
+    probabilities_ : ndarray, shape (n_samples, )
+        The strength with which each sample is a member of its assigned
+        cluster. Noise points have probability zero; points in clusters
+        have values assigned proportional to the degree that they
+        persist as part of the cluster.
+
+    cluster_persistence_ : ndarray, shape (n_clusters, )
+        A score of how persistent each cluster is. A score of 1.0 represents
+        a perfectly stable cluster that persists over all distance scales,
+        while a score of 0.0 represents a perfectly ephemeral cluster. These
+        scores can be guage the relative coherence of the clusters output
+        by the algorithm.
+
+    condensed_tree_ : CondensedTree object
+        The condensed tree produced by HDBSCAN. The object has methods
+        for converting to pandas, networkx, and plotting.
+
+    single_linkage_tree_ : SingleLinkageTree object
+        The single linkage tree produced by HDBSCAN. The object has methods
+        for converting to pandas, networkx, and plotting.
+
+    minimum_spanning_tree_ : MinimumSpanningTree object
+        The minimum spanning tree of the mutual reachability graph generated
+        by HDBSCAN. Note that this is not generated by default and will only
+        be available if `gen_min_span_tree` was set to True on object creation.
+        Even then in some optimized cases a tree may not be generated.
+
+    """
+
+    labels_ = CumlArrayDescriptor()
+    probabilities_ = CumlArrayDescriptor()
+    outlier_scores_ = CumlArrayDescriptor()
+    probabilities_ = CumlArrayDescriptor()
+
+    # Single Linkage Tree
+    children_ = CumlArrayDescriptor()
+    lambdas_ = CumlArrayDescriptor()
+    sizes_ = CumlArrayDescriptor()
+
+    # Minimum Spanning Tree
+    mst_src_ = CumlArrayDescriptor()
+    mst_dst_ = CumlArrayDescriptor()
+    mst_weights_ = CumlArrayDescriptor()
+
+    def __init__(self, *,
+                 min_cluster_size=5,
+                 min_samples=None,
+                 cluster_selection_epsilon=0.0,
+                 max_cluster_size=0,
+                 metric='euclidean',
+                 alpha=1.0,
+                 p=2,
+                 cluster_selection_method='eom',
+                 allow_single_cluster=False,
+                 gen_min_span_tree=False,
+                 gen_condensed_tree=False,
+                 gen_single_linkage_tree=False,
+                 handle=None,
+                 verbose=False,
+                 connectivity='knn',
+                 n_neighbors=10,
+                 output_type=None):
+
+        super().__init__(handle,
+                         verbose,
+                         output_type)
+
+        if min_samples is None:
+            min_samples = min_cluster_size
+
+        if connectivity not in ["knn", "pairwise"]:
+            raise ValueError("'connectivity' can only be one of "
+                             "{'knn', 'pairwise'}")
+
+        if n_neighbors > 1023 or n_neighbors < 2:
+            raise ValueError("'n_neighbors' must be a positive number "
+                             "between 2 and 1023")
+
+        self.min_cluster_size = min_cluster_size
+        self.min_samples = min_samples
+        self.cluster_selection_epsilon = cluster_selection_epsilon
+        self.max_cluster_size = max_cluster_size
+        self.metric = metric
+        self.p = p
+        self.alpha = alpha
+        self.cluster_selection_method = cluster_selection_method
+        self.allow_single_cluster = allow_single_cluster
+        self.n_neighbors = n_neighbors
+        self.connectivity = connectivity
+
+        self.fit_called_ = False
+
+        self.n_clusters_ = None
+        self.n_leaves_ = None
+
+        self._condensed_tree = None
+        self._single_linkage_tree = None
+
+        self.gen_min_span_tree_ = gen_min_span_tree
+        self.gen_condensed_tree = gen_condensed_tree
+        self.gen_single_linkage_tree = gen_single_linkage_tree
+
+    def _build_condensed_tree(self):
+
+        if self.gen_condensed_tree:
+            raw_tree = np.recarray(shape=(self.condensed_parent_.shape[0],),
+                                   formats=[np.intp, np.intp, float, np.intp],
+                                   names=('parent', 'child', 'lambda_val',
+                                          'child_size'))
+            raw_tree['parent'] = self.condensed_parent_
+            raw_tree['child'] = self.condensed_child_
+            raw_tree['lambda_val'] = self.condensed_lambdas_
+            raw_tree['child_size'] = self.condensed_sizes_
+
+            if has_hdbscan_plots():
+                from hdbscan.plots import CondensedTree
+                self.condensed_tree_ = \
+                    CondensedTree(raw_tree,
+                                  self.cluster_selection_epsilon,
+                                  self.allow_single_cluster)
+
+    def _build_single_linkage_tree(self):
+
+        if self.gen_single_linkage_tree:
+            with cuml.using_output_type("numpy"):
+                raw_tree = np.column_stack(
+                    (self.children_[0, :self.n_leaves_-1],
+                     self.children_[1, :self.n_leaves_-1],
+                     self.lambdas_[:self.n_leaves_-1],
+                     self.sizes_[:self.n_leaves_-1]))
+
+            raw_tree = raw_tree.astype(np.float64)
+
+            if has_hdbscan_plots():
+                from hdbscan.plots import SingleLinkageTree
+                self.single_linkage_tree_ = SingleLinkageTree(raw_tree)
+
+    def _build_minimum_spanning_tree(self, X):
+        if self.gen_min_span_tree_:
+            with cuml.using_output_type("numpy"):
+                raw_tree = np.column_stack((self.mst_src_,
+                                            self.mst_dst_,
+                                            self.mst_weights_))
+
+            raw_tree = raw_tree.astype(np.float64)
+
+            if has_hdbscan_plots():
+                from hdbscan.plots import MinimumSpanningTree
+                self.minimum_spanning_tree_ = \
+                    MinimumSpanningTree(raw_tree, X.to_output("numpy"))
+
+    def __dealloc__(self):
+        delete_hdbscan_output(self)
+
+    def _cuml_array_from_ptr(self, ptr, buf_size, shape, dtype):
+
+        mem = cp.cuda.UnownedMemory(ptr=ptr, size=buf_size,
+                                    owner=self.hdbscan_output_,
+                                    device_id=-1)
+        mem_ptr = cp.cuda.memory.MemoryPointer(mem, 0)
+
+        return CumlArray(data=cp.ndarray(shape=shape,
+                                         dtype=dtype,
+                                         memptr=mem_ptr)).to_output('numpy')
+
+    def _construct_condensed_tree_attribute(self, ptr, dtype="int32"):
+        cdef hdbscan_output *hdbscan_output_ = \
+                <hdbscan_output*><size_t>self.hdbscan_output_
+
+        n_condensed_tree_edges = \
+            hdbscan_output_.get_condensed_tree().get_n_edges()
+
+        return self._cuml_array_from_ptr(
+            ptr, n_condensed_tree_edges * sizeof(float),
+            (n_condensed_tree_edges,), dtype
+        )
+
+    def _construct_output_attributes(self):
+
+        cdef hdbscan_output *hdbscan_output_ = \
+                <hdbscan_output*><size_t>self.hdbscan_output_
+
+        self.n_clusters_ = hdbscan_output_.get_n_clusters()
+
+        self.cluster_persistence_ = self._cuml_array_from_ptr(
+            <size_t>hdbscan_output_.get_stabilities(),
+            hdbscan_output_.get_n_clusters() * sizeof(float),
+            (1, hdbscan_output_.get_n_clusters()), "float32"
+        )
+
+        self.condensed_parent_ = self._construct_condensed_tree_attribute(
+            <size_t>hdbscan_output_.get_condensed_tree().get_parents())
+
+        self.condensed_child_ = self._construct_condensed_tree_attribute(
+            <size_t>hdbscan_output_.get_condensed_tree().get_children())
+
+        self.condensed_lambdas_ = \
+            self._construct_condensed_tree_attribute(
+                <size_t>hdbscan_output_.get_condensed_tree().get_lambdas(),
+                "float32")
+
+        self.condensed_sizes_ = self._construct_condensed_tree_attribute(
+            <size_t>hdbscan_output_.get_condensed_tree().get_sizes())
+
+    @generate_docstring()
+    def fit(self, X, y=None, convert_dtype=True) -> "HDBSCAN":
+        """
+        Fit HDBSCAN model from features.
+        """
+
+        X_m, n_rows, n_cols, self.dtype = \
+            input_to_cuml_array(X, order='C',
+                                check_dtype=[np.float32],
+                                convert_to_dtype=(np.float32
+                                                  if convert_dtype
+                                                  else None))
+
+        cdef uintptr_t input_ptr = X_m.ptr
+
+        cdef handle_t* handle_ = <handle_t*><size_t>self.handle.getHandle()
+
+        # Hardcode n_components_ to 1 for single linkage. This will
+        # not be the case for other linkage types.
+        self.n_connected_components_ = 1
+        self.n_leaves_ = n_rows
+
+        self.labels_ = CumlArray.empty(n_rows, dtype="int32")
+        self.children_ = CumlArray.empty((2, n_rows), dtype="int32")
+        self.probabilities_ = CumlArray.empty(n_rows, dtype="float32")
+        self.sizes_ = CumlArray.empty(n_rows, dtype="int32")
+        self.lambdas_ = CumlArray.empty(n_rows, dtype="float32")
+        self.mst_src_ = CumlArray.empty(n_rows-1, dtype="int32")
+        self.mst_dst_ = CumlArray.empty(n_rows-1, dtype="int32")
+        self.mst_weights_ = CumlArray.empty(n_rows-1, dtype="float32")
+
+        cdef uintptr_t labels_ptr = self.labels_.ptr
+        cdef uintptr_t children_ptr = self.children_.ptr
+        cdef uintptr_t sizes_ptr = self.sizes_.ptr
+        cdef uintptr_t lambdas_ptr = self.lambdas_.ptr
+        cdef uintptr_t probabilities_ptr = self.probabilities_.ptr
+        cdef uintptr_t mst_src_ptr = self.mst_src_.ptr
+        cdef uintptr_t mst_dst_ptr = self.mst_dst_.ptr
+        cdef uintptr_t mst_weights_ptr = self.mst_weights_.ptr
+
+        # If calling fit a second time, release
+        # any memory owned from previous trainings
+        delete_hdbscan_output(self)
+
+        cdef hdbscan_output *linkage_output = new hdbscan_output(
+            handle_[0], n_rows,
+            <int*>labels_ptr,
+            <float*>probabilities_ptr,
+            <int*>children_ptr,
+            <int*>sizes_ptr,
+            <float*>lambdas_ptr,
+            <int*>mst_src_ptr,
+            <int*>mst_dst_ptr,
+            <float*>mst_weights_ptr)
+
+        self.hdbscan_output_ = <size_t>linkage_output
+
+        cdef HDBSCANParams params
+        params.k = self.n_neighbors
+        params.min_samples = self.min_samples
+        # params.alpha = self.alpha
+        params.min_cluster_size = self.min_cluster_size
+        params.max_cluster_size = self.max_cluster_size
+        params.cluster_selection_epsilon = self.cluster_selection_epsilon
+        params.allow_single_cluster = self.allow_single_cluster
+
+        if self.cluster_selection_method == 'eom':
+            params.cluster_selection_method = CLUSTER_SELECTION_METHOD.EOM
+        elif self.cluster_selection_method == 'leaf':
+            params.cluster_selection_method = CLUSTER_SELECTION_METHOD.LEAF
+        else:
+            raise ValueError("Cluster selection method not supported. "
+                             "Must one of {'eom', 'leaf'}")
+
+        cdef DistanceType metric
+        if self.metric in _metrics_mapping:
+            metric = _metrics_mapping[self.metric]
+        else:
+            raise ValueError("'affinity' %s not supported." % self.affinity)
+
+        print("Calling HDBSCAN")
+
+        if self.connectivity == 'knn':
+            hdbscan(handle_[0],
+                    <float*>input_ptr,
+                    <int> n_rows,
+                    <int> n_cols,
+                    <DistanceType> metric,
+                    params,
+                    deref(linkage_output))
+        else:
+            raise ValueError("'connectivity' can only be one of "
+                             "{'knn', 'pairwise'}")
+
+        self.handle.sync()
+
+        print("Done")
+
+        self.fit_called_ = True
+
+        self._construct_output_attributes()
+
+        self._build_minimum_spanning_tree(X_m)
+        self._build_condensed_tree()
+        self._build_single_linkage_tree()
+
+        return self
+
+    @generate_docstring(return_values={'name': 'preds',
+                                       'type': 'dense',
+                                       'description': 'Cluster indexes',
+                                       'shape': '(n_samples, 1)'})
+    def fit_predict(self, X, y=None) -> CumlArray:
+        """
+        Fit the HDBSCAN model from features and return
+        cluster labels.
+        """
+        return self.fit(X).labels_
+
+    def get_param_names(self):
+        return super().get_param_names() + [
+            "n_neighbors",
+            "metric",
+            "min_cluster_size",
+            "max_cluster_size",
+            "min_samples",
+            "cluster_selection_epsilon",
+            "cluster_selection_method",
+            "p",
+            "allow_single_cluster",
+            "connectivity",
+            "n_neighbors",
+            "alpha",
+            "gen_min_span_tree",
+            "gen_single_linkage_tree",
+            "gen_condensed_tree"
+        ]
diff --git a/python/cuml/test/test_hdbscan.py b/python/cuml/test/test_hdbscan.py
new file mode 100644
index 0000000000..967b319b57
--- /dev/null
+++ b/python/cuml/test/test_hdbscan.py
@@ -0,0 +1,206 @@
+# Copyright (c) 2021, NVIDIA CORPORATION.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import pytest
+
+
+from cuml.experimental.cluster import HDBSCAN
+from sklearn.datasets import make_blobs
+
+from cuml.metrics import adjusted_rand_score
+from cuml.test.utils import get_pattern
+
+import numpy as np
+
+from cuml.common import logger
+
+import hdbscan
+
+from sklearn import datasets
+
+import cupy as cp
+
+test_datasets = {
+ "digits": datasets.load_digits(),
+ "boston": datasets.load_boston(),
+ "diabetes": datasets.load_diabetes(),
+ "cancer": datasets.load_breast_cancer(),
+}
+
+dataset_names = ['noisy_circles', 'noisy_moons', 'varied']
+
+
+def assert_cluster_counts(sk_agg, cuml_agg, digits=25):
+    sk_unique, sk_counts = np.unique(sk_agg.labels_, return_counts=True)
+    sk_counts = np.sort(sk_counts)
+
+    cu_unique, cu_counts = cp.unique(cuml_agg.labels_, return_counts=True)
+    cu_counts = cp.sort(cu_counts).get()
+
+    np.testing.assert_almost_equal(sk_counts, cu_counts, decimal=-1 * digits)
+
+
+@pytest.mark.parametrize('nrows', [500])
+@pytest.mark.parametrize('ncols', [25])
+@pytest.mark.parametrize('nclusters', [2, 5])
+@pytest.mark.parametrize('min_samples', [25, 60])
+@pytest.mark.parametrize('allow_single_cluster', [True, False])
+@pytest.mark.parametrize('min_cluster_size', [30, 50])
+@pytest.mark.parametrize('cluster_selection_epsilon', [0.0])
+@pytest.mark.parametrize('max_cluster_size', [0])
+@pytest.mark.parametrize('cluster_selection_method', ['eom', 'leaf'])
+@pytest.mark.parametrize('connectivity', ['knn'])
+def test_hdbscan_blobs(nrows, ncols, nclusters,
+                       connectivity,
+                       cluster_selection_epsilon,
+                       cluster_selection_method,
+                       allow_single_cluster,
+                       min_cluster_size,
+                       max_cluster_size,
+                       min_samples):
+
+    X, y = make_blobs(int(nrows),
+                      ncols,
+                      nclusters,
+                      cluster_std=0.7,
+                      shuffle=False,
+                      random_state=42)
+
+    cuml_agg = HDBSCAN(verbose=logger.level_info,
+                       allow_single_cluster=allow_single_cluster,
+                       n_neighbors=min_samples+1,
+                       min_samples=min_samples,
+                       max_cluster_size=max_cluster_size,
+                       min_cluster_size=min_cluster_size,
+                       cluster_selection_epsilon=cluster_selection_epsilon,
+                       cluster_selection_method=cluster_selection_method)
+
+    cuml_agg.fit(X)
+    sk_agg = hdbscan.HDBSCAN(
+        allow_single_cluster=allow_single_cluster,
+        approx_min_span_tree=False,
+        gen_min_span_tree=True,
+        min_samples=min_samples,
+        min_cluster_size=min_cluster_size,
+        cluster_selection_epsilon=cluster_selection_epsilon,
+        cluster_selection_method=cluster_selection_method,
+        algorithm="generic")
+
+    sk_agg.fit(cp.asnumpy(X))
+
+    assert_cluster_counts(sk_agg, cuml_agg)
+
+    assert(adjusted_rand_score(cuml_agg.labels_, sk_agg.labels_) >= 0.95)
+    assert(len(np.unique(sk_agg.labels_)) == len(cp.unique(cuml_agg.labels_)))
+
+
+@pytest.mark.parametrize('dataset', test_datasets.values())
+@pytest.mark.parametrize('cluster_selection_epsilon', [0.0, 50.0, 150.0])
+@pytest.mark.parametrize('min_samples_cluster_size_bounds', [(150, 150, 0),
+                                                             (50, 25, 0)])
+@pytest.mark.parametrize('allow_single_cluster', [True, False])
+@pytest.mark.parametrize('cluster_selection_method', ['eom', 'leaf'])
+@pytest.mark.parametrize('connectivity', ['knn'])
+def test_hdbscan_sklearn_datasets(dataset,
+                                  connectivity,
+                                  cluster_selection_epsilon,
+                                  cluster_selection_method,
+                                  min_samples_cluster_size_bounds,
+                                  allow_single_cluster):
+
+    min_samples, min_cluster_size, max_cluster_size = \
+        min_samples_cluster_size_bounds
+
+    X = dataset.data
+
+    cuml_agg = HDBSCAN(verbose=logger.level_info,
+                       allow_single_cluster=allow_single_cluster,
+                       n_neighbors=min_samples,
+                       gen_min_span_tree=True,
+                       min_samples=min_samples,
+                       max_cluster_size=max_cluster_size,
+                       min_cluster_size=min_cluster_size,
+                       cluster_selection_epsilon=cluster_selection_epsilon,
+                       cluster_selection_method=cluster_selection_method)
+
+    cuml_agg.fit(X)
+
+    sk_agg = hdbscan.HDBSCAN(
+        allow_single_cluster=allow_single_cluster,
+        approx_min_span_tree=False,
+        gen_min_span_tree=True,
+        min_samples=min_samples,
+        min_cluster_size=min_cluster_size,
+        cluster_selection_epsilon=cluster_selection_epsilon,
+        cluster_selection_method=cluster_selection_method,
+        algorithm="generic")
+
+    sk_agg.fit(cp.asnumpy(X))
+
+    assert_cluster_counts(sk_agg, cuml_agg)
+
+    assert(len(np.unique(sk_agg.labels_)) == len(cp.unique(cuml_agg.labels_)))
+    assert(adjusted_rand_score(cuml_agg.labels_, sk_agg.labels_) > 0.85)
+
+
+@pytest.mark.parametrize('nrows', [1000])
+@pytest.mark.parametrize('dataset', dataset_names)
+@pytest.mark.parametrize('min_samples', [15])
+@pytest.mark.parametrize('cluster_selection_epsilon', [0.0])
+@pytest.mark.parametrize('min_cluster_size', [25])
+@pytest.mark.parametrize('allow_single_cluster', [True, False])
+@pytest.mark.parametrize('max_cluster_size', [0])
+# TODO: Need to test leaf selection method
+@pytest.mark.parametrize('cluster_selection_method', ['eom'])
+@pytest.mark.parametrize('connectivity', ['knn'])
+def test_hdbscan_cluster_patterns(dataset, nrows,
+                                  connectivity,
+                                  cluster_selection_epsilon,
+                                  cluster_selection_method,
+                                  min_cluster_size,
+                                  allow_single_cluster,
+                                  max_cluster_size,
+                                  min_samples):
+
+    # This also tests duplicate data points
+    X, y = get_pattern(dataset, nrows)[0]
+
+    cuml_agg = HDBSCAN(verbose=logger.level_info,
+                       allow_single_cluster=allow_single_cluster,
+                       n_neighbors=min_samples,
+                       min_samples=min_samples,
+                       max_cluster_size=max_cluster_size,
+                       min_cluster_size=min_cluster_size,
+                       cluster_selection_epsilon=cluster_selection_epsilon,
+                       cluster_selection_method=cluster_selection_method)
+
+    cuml_agg.fit(X)
+
+    sk_agg = hdbscan.HDBSCAN(
+        allow_single_cluster=allow_single_cluster,
+        approx_min_span_tree=False,
+        gen_min_span_tree=True,
+        min_samples=min_samples,
+        min_cluster_size=min_cluster_size,
+        cluster_selection_epsilon=cluster_selection_epsilon,
+        cluster_selection_method=cluster_selection_method,
+        algorithm="generic")
+
+    sk_agg.fit(cp.asnumpy(X))
+
+    assert_cluster_counts(sk_agg, cuml_agg)
+
+    assert(len(np.unique(sk_agg.labels_)) == len(cp.unique(cuml_agg.labels_)))
+    assert(adjusted_rand_score(cuml_agg.labels_, sk_agg.labels_) > 0.95)