From 218ecff0e90e15e56dd8ec5e61bcd45dd7bd28cf Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Wed, 8 May 2024 11:36:38 +0100
Subject: [PATCH 01/13] impl layer_name only for exploded edges

---
 python/tests/test_graphdb.py                  | 14 ++++++
 raphtory-graphql/src/model/graph/edge.rs      |  8 +++-
 raphtory/src/core/utils/errors.rs             |  3 ++
 raphtory/src/db/api/view/edge.rs              | 23 +++++++--
 raphtory/src/python/graph/edge.rs             |  2 +-
 raphtory/src/python/graph/edges.rs            | 48 ++++++++++++++-----
 .../graph/views/graph_view_modules/export.rs  |  6 +--
 .../src/python/types/wrappers/iterators.rs    |  2 +
 8 files changed, 82 insertions(+), 24 deletions(-)

diff --git a/python/tests/test_graphdb.py b/python/tests/test_graphdb.py
index a882ed9f2e..8dd72b630c 100644
--- a/python/tests/test_graphdb.py
+++ b/python/tests/test_graphdb.py
@@ -1435,6 +1435,20 @@ def test_layer_name():
     assert g.edge(0, 1).layer_names == ["_default"]
     assert g.edge(0, 2).layer_names == ["awesome layer"]
 
+    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() or "
+                 ".explode(). If you want to retrieve the layers for this edge you can use .layer_names.")
+    with pytest.raises(Exception) as e:
+        g.edges.layer_name()
+    assert str(e.value) == error_msg
+
+    assert list(g.edges.explode().layer_name) == ['_default', 'awesome layer']
+
+    with pytest.raises(Exception) as e:
+        g.edge(0, 2).layer_name()
+    assert str(e.value) == error_msg
+
+    assert list(g.edge(0, 2).explode().layer_name) == ['awesome layer']
+
 
 def test_window_size():
     g = Graph()
diff --git a/raphtory-graphql/src/model/graph/edge.rs b/raphtory-graphql/src/model/graph/edge.rs
index 17a1e2da3f..d62acee95a 100644
--- a/raphtory-graphql/src/model/graph/edge.rs
+++ b/raphtory-graphql/src/model/graph/edge.rs
@@ -1,4 +1,5 @@
 use crate::model::graph::{node::Node, property::GqlProperties};
+use async_graphql::Error;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
 use raphtory::{
@@ -122,8 +123,11 @@ impl Edge {
         self.ee.layer_names().map(|x| x.into()).collect()
     }
 
-    async fn layer_name(&self) -> Option<String> {
-        self.ee.layer_name().map(|x| x.into())
+    async fn layer_name(&self) -> Result<String, Error> {
+        match self.ee.layer_name().map(|x| x.into()) {
+            Ok(name) => Ok(name),
+            Err(e) => Err(Error::new(e.to_string())),
+        }
     }
 
     async fn explode(&self) -> Vec<Edge> {
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
index c63ac5b4d2..5016744fed 100644
--- a/raphtory/src/core/utils/errors.rs
+++ b/raphtory/src/core/utils/errors.rs
@@ -114,6 +114,9 @@ pub enum GraphError {
         "Failed to load the graph as the bincode version {0} is different to installed version {1}"
     )]
     BincodeVersionError(u32, u32),
+
+    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). If you want to retrieve the layers for this edge you can use .layer_names.")]
+    LayerNameAPIError,
 }
 
 #[derive(thiserror::Error, Debug, PartialEq)]
diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index e58e13f128..38ec8d4e5b 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -6,6 +6,7 @@ use crate::{
     core::{
         entities::{edges::edge_ref::EdgeRef, VID},
         storage::timeindex::{AsTime, TimeIndexEntry},
+        utils::errors::GraphError,
         ArcStr,
     },
     db::api::{
@@ -121,7 +122,7 @@ pub trait EdgeViewOps<'graph>: TimeOps<'graph> + LayerOps<'graph> + Clone {
     fn date_time(&self) -> Self::ValueType<Option<DateTime<Utc>>>;
 
     /// Gets the layer name for the edge if it is restricted to a single layer
-    fn layer_name(&self) -> Self::ValueType<Option<ArcStr>>;
+    fn layer_name(&self) -> Self::ValueType<Result<ArcStr, GraphError>>;
 
     /// Gets the TimeIndexEntry if the edge is exploded
     fn time_and_index(&self) -> Self::ValueType<Option<TimeIndexEntry>>;
@@ -266,8 +267,12 @@ impl<'graph, E: BaseEdgeViewOps<'graph>> EdgeViewOps<'graph> for E {
     }
 
     /// Gets the layer name for the edge if it is restricted to a single layer
-    fn layer_name(&self) -> Self::ValueType<Option<ArcStr>> {
-        self.map(|g, e| e.layer().map(|l_id| g.get_layer_name(*l_id)))
+    fn layer_name(&self) -> Self::ValueType<Result<ArcStr, GraphError>> {
+        self.map(|g, e| {
+            e.layer()
+                .map(|l_id| g.get_layer_name(*l_id))
+                .ok_or_else(|| GraphError::LayerNameAPIError)
+        })
     }
 
     /// Gets the TimeIndexEntry if the edge is exploded
@@ -339,6 +344,16 @@ mod test_edge_view {
             .collect();
         assert_eq!(prop_values, expected_prop_values);
         assert_eq!(actual_layers, expected_layers);
+
+        assert!(g.edge(1, 2).unwrap().layer_name().is_err());
+        assert!(g.edges().layer_name().all(|l| l.is_err()));
+        assert!(g
+            .edge(1, 2)
+            .unwrap()
+            .explode()
+            .layer_name()
+            .all(|l| l.is_ok()));
+        assert!(g.edges().explode().layer_name().all(|l| l.is_ok()));
     }
 
     #[test]
@@ -368,7 +383,7 @@ mod test_edge_view {
                 (2, 3, None),
                 (1, 2, None),
                 (1, 2, Some(true)),
-                (2, 3, Some(true))
+                (2, 3, Some(true)),
             ]
         )
     }
diff --git a/raphtory/src/python/graph/edge.rs b/raphtory/src/python/graph/edge.rs
index 362adfe5a9..737f6550b2 100644
--- a/raphtory/src/python/graph/edge.rs
+++ b/raphtory/src/python/graph/edge.rs
@@ -281,7 +281,7 @@ impl PyEdge {
     /// Returns:
     ///     (List<str>) The name of the layer
     #[getter]
-    pub fn layer_name(&self) -> Option<ArcStr> {
+    pub fn layer_name(&self) -> Result<ArcStr, GraphError> {
         self.edge.layer_name().map(|v| v.clone())
     }
 
diff --git a/raphtory/src/python/graph/edges.rs b/raphtory/src/python/graph/edges.rs
index 18d2ad528b..fc2ed477c5 100644
--- a/raphtory/src/python/graph/edges.rs
+++ b/raphtory/src/python/graph/edges.rs
@@ -1,5 +1,5 @@
 use crate::{
-    core::{ArcStr, Prop},
+    core::{utils::errors::GraphError, ArcStr, Prop},
     db::{
         api::view::{
             internal::CoreGraphOps, BoxedIter, DynamicGraph, IntoDynBoxed, IntoDynamic,
@@ -16,11 +16,12 @@ use crate::{
         types::{
             repr::{iterator_repr, Repr},
             wrappers::iterators::{
-                ArcStringVecIterable, BoolIterable, I64VecIterable, NestedArcStringVecIterable,
-                NestedBoolIterable, NestedI64VecIterable, NestedOptionArcStringIterable,
-                NestedOptionI64Iterable, NestedU64U64Iterable, NestedUtcDateTimeIterable,
-                NestedVecUtcDateTimeIterable, OptionArcStringIterable, OptionI64Iterable,
-                OptionUtcDateTimeIterable, OptionVecUtcDateTimeIterable, U64U64Iterable,
+                ArcStringIterable, ArcStringVecIterable, BoolIterable, I64VecIterable,
+                NestedArcStringIterable, NestedArcStringVecIterable, NestedBoolIterable,
+                NestedI64VecIterable, NestedOptionI64Iterable, NestedU64U64Iterable,
+                NestedUtcDateTimeIterable, NestedVecUtcDateTimeIterable, OptionArcStringIterable,
+                OptionI64Iterable, OptionUtcDateTimeIterable, OptionVecUtcDateTimeIterable,
+                U64U64Iterable,
             },
         },
         utils::{
@@ -29,6 +30,7 @@ use crate::{
         },
     },
 };
+use futures_util::{FutureExt, TryStreamExt};
 use itertools::Itertools;
 use pyo3::{
     prelude::PyModule, pyclass, pymethods, types::PyDict, IntoPy, PyObject, PyResult, Python,
@@ -225,9 +227,14 @@ impl PyEdges {
     /// Returns:
     ///  The name of the layer
     #[getter]
-    fn layer_name(&self) -> OptionArcStringIterable {
-        let edges = self.edges.clone();
-        (move || edges.layer_name()).into()
+    fn layer_name(&self) -> Result<ArcStringIterable, GraphError> {
+        match self.edges.layer_name().next() {
+            Some(Err(err)) => Err(err),
+            _ => {
+                let edges = self.edges.clone();
+                Ok((move || edges.layer_name().map(|layer| layer.unwrap())).into())
+            }
+        }
     }
 
     /// Get the layer names that all edges belong to - assuming they only belong to one layer
@@ -256,7 +263,7 @@ impl PyEdges {
     ///
     /// Returns:
     ///     If successful, this PyObject will be a Pandas DataFrame.
-    #[pyo3(signature = (include_property_history=true, convert_datetime=false, explode=false))]
+    #[pyo3(signature = (include_property_history = true, convert_datetime = false, explode = false))]
     pub fn to_df(
         &self,
         include_property_history: bool,
@@ -413,9 +420,24 @@ impl PyNestedEdges {
 
     /// Returns the name of the layer the edges belong to - assuming they only belong to one layer
     #[getter]
-    fn layer_name(&self) -> NestedOptionArcStringIterable {
-        let edges = self.edges.clone();
-        (move || edges.layer_name()).into()
+    fn layer_name(&self) -> Result<NestedArcStringIterable, GraphError> {
+        match self.edges.layer_name().flatten().next() {
+            Some(Err(err)) => Err(err),
+            _ => {
+                let edges = self.edges.clone();
+                Ok((move || {
+                    edges
+                        .layer_name()
+                        .map(|layer_name_iter| {
+                            layer_name_iter
+                                .map(|layer_name| layer_name.unwrap())
+                                .into_dyn_boxed()
+                        })
+                        .into_dyn_boxed()
+                })
+                .into())
+            }
+        }
     }
 
     /// Returns the names of the layers the edges belong to
diff --git a/raphtory/src/python/graph/views/graph_view_modules/export.rs b/raphtory/src/python/graph/views/graph_view_modules/export.rs
index d18aa6cc15..a8189135b1 100644
--- a/raphtory/src/python/graph/views/graph_view_modules/export.rs
+++ b/raphtory/src/python/graph/views/graph_view_modules/export.rs
@@ -231,10 +231,8 @@ impl PyGraphView {
                         }
                     }
                 }
-                let layer = e.layer_name();
-                if layer.is_some() {
-                    properties.set_item("layer", layer)?;
-                }
+                let layer = e.layer_name()?;
+                properties.set_item("layer", layer)?;
                 if include_update_history.unwrap_or(true) {
                     if explode_edges.unwrap_or(true) {
                         properties.set_item("update_history", e.time())?;
diff --git a/raphtory/src/python/types/wrappers/iterators.rs b/raphtory/src/python/types/wrappers/iterators.rs
index 39b77297a4..c35240652a 100644
--- a/raphtory/src/python/types/wrappers/iterators.rs
+++ b/raphtory/src/python/types/wrappers/iterators.rs
@@ -108,12 +108,14 @@ py_iterable_comp!(NestedBoolIterable, BoolIterableCmp, NestedBoolIterableCmp);
 py_iterable!(StringIterable, String);
 py_iterable_comp!(StringIterable, String, StringIterableCmp);
 py_iterable!(OptionArcStringIterable, Option<ArcStr>);
+py_iterable!(ArcStringIterable, ArcStr);
 py_iterable_comp!(
     OptionArcStringIterable,
     Option<ArcStr>,
     OptionArcStringIterableCmp
 );
 py_nested_iterable!(NestedOptionArcStringIterable, Option<ArcStr>);
+py_nested_iterable!(NestedArcStringIterable, ArcStr);
 py_iterable_comp!(
     NestedOptionArcStringIterable,
     OptionArcStringIterableCmp,

From 744d24ce675ba72ab09ec6255c5115815a4d283d Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Wed, 8 May 2024 12:54:39 +0100
Subject: [PATCH 02/13] impl time api only for exploded edges

---
 python/tests/test_graphdb.py                  | 52 ++++++++++++++-----
 raphtory-graphql/src/model/graph/edge.rs      |  7 ++-
 raphtory/src/core/utils/errors.rs             |  5 +-
 raphtory/src/db/api/view/edge.rs              | 11 ++--
 raphtory/src/db/graph/graph.rs                |  4 +-
 raphtory/src/python/graph/edge.rs             |  2 +-
 raphtory/src/python/graph/edges.rs            | 30 ++++++++---
 .../graph/views/graph_view_modules/export.rs  |  2 +-
 raphtory/src/search/mod.rs                    |  2 +-
 9 files changed, 84 insertions(+), 31 deletions(-)

diff --git a/python/tests/test_graphdb.py b/python/tests/test_graphdb.py
index 8dd72b630c..f4ae71c48a 100644
--- a/python/tests/test_graphdb.py
+++ b/python/tests/test_graphdb.py
@@ -1436,7 +1436,7 @@ def test_layer_name():
     assert g.edge(0, 2).layer_names == ["awesome layer"]
 
     error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() or "
-                 ".explode(). If you want to retrieve the layers for this edge you can use .layer_names.")
+                 ".explode(). If you want to retrieve the layers for this edge you can use .layer_names")
     with pytest.raises(Exception) as e:
         g.edges.layer_name()
     assert str(e.value) == error_msg
@@ -1449,6 +1449,44 @@ def test_layer_name():
 
     assert list(g.edge(0, 2).explode().layer_name) == ['awesome layer']
 
+    with pytest.raises(Exception) as e:
+        g.nodes.neighbours.edges.layer_name()
+    assert str(e.value) == error_msg
+
+    assert [list(iterator) for iterator in g.nodes.neighbours.edges.explode().layer_name] == [
+        ["_default", "awesome layer"],
+        ["_default", "awesome layer"],
+        ["_default", "awesome layer"]
+    ]
+
+def test_time():
+    g = Graph()
+
+    g.add_edge(0, 0, 1)
+    g.add_edge(0, 0, 2)
+    g.add_edge(1, 0, 2)
+
+    error_msg = ("The time function is only available once an edge has been exploded via .explode_layers() or "
+                 ".explode(). You may want to retrieve the history for this edge via .history(), "
+                 "or the earliest/latest time via earliest_time or latest_time")
+    with pytest.raises(Exception) as e:
+        g.edges.time()
+    assert str(e.value) == error_msg
+
+    assert list(g.edges.explode().time) == [0, 0, 1]
+
+    with pytest.raises(Exception) as e:
+        g.edge(0, 2).time()
+    assert str(e.value) == error_msg
+
+    assert list(g.edge(0, 2).explode().time) == [0, 1]
+
+    with pytest.raises(Exception) as e:
+        g.nodes.neighbours.edges.time()
+    assert str(e.value) == error_msg
+
+    assert [list(iterator) for iterator in g.nodes.neighbours.edges.explode().time] == [[0, 0, 1], [0, 0, 1], [0, 0, 1]]
+
 
 def test_window_size():
     g = Graph()
@@ -1824,11 +1862,6 @@ def test_starend_edges():
     g.add_edge(2, 1, 2)
     g.add_edge(3, 1, 2)
 
-    old_time_way = []
-    for e in g.edges:
-        old_time_way.append(e.time)
-    assert old_time_way == list(g.edges.time)
-
     old_latest_time_way = []
     for e in g.edges:
         old_latest_time_way.append(e.latest_time)
@@ -1840,20 +1873,13 @@ def test_starend_edges():
         old_earliest_time_way.append(e.earliest_time)
     assert old_earliest_time_way == list(g.edges.earliest_time)
 
-    old_start_nested_way = []
-    old_end_nested_way = []
-    old_time_nested_way = []
     old_latest_time_nested_way = []
     old_earliest_time_nested_way = []
     for edges in g.nodes.edges:
         for edge in edges:
-            old_time_nested_way.append(edge.time)
             old_latest_time_nested_way.append(edge.latest_time)
             old_earliest_time_nested_way.append(edge.earliest_time)
 
-    assert old_time_nested_way == [
-        item for sublist in g.nodes.edges.time.collect() for item in sublist
-    ]
     assert old_latest_time_nested_way == [
         item for sublist in g.nodes.edges.latest_time.collect() for item in sublist
     ]
diff --git a/raphtory-graphql/src/model/graph/edge.rs b/raphtory-graphql/src/model/graph/edge.rs
index d62acee95a..1761ce6258 100644
--- a/raphtory-graphql/src/model/graph/edge.rs
+++ b/raphtory-graphql/src/model/graph/edge.rs
@@ -95,8 +95,11 @@ impl Edge {
         self.ee.history().last().cloned()
     }
 
-    async fn time(&self) -> Option<i64> {
-        self.ee.time()
+    async fn time(&self) -> Result<i64, Error> {
+        match self.ee.time().map(|x| x.into()) {
+            Ok(name) => Ok(name),
+            Err(e) => Err(Error::new(e.to_string())),
+        }
     }
 
     async fn start(&self) -> Option<i64> {
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
index 5016744fed..daee9937bd 100644
--- a/raphtory/src/core/utils/errors.rs
+++ b/raphtory/src/core/utils/errors.rs
@@ -115,8 +115,11 @@ pub enum GraphError {
     )]
     BincodeVersionError(u32, u32),
 
-    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). If you want to retrieve the layers for this edge you can use .layer_names.")]
+    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). If you want to retrieve the layers for this edge you can use .layer_names")]
     LayerNameAPIError,
+
+    #[error("The time function is only available once an edge has been exploded via .explode_layers() or .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]
+    TimeAPIError,
 }
 
 #[derive(thiserror::Error, Debug, PartialEq)]
diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index 38ec8d4e5b..396baacba4 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -117,7 +117,7 @@ pub trait EdgeViewOps<'graph>: TimeOps<'graph> + LayerOps<'graph> + Clone {
     fn latest_time(&self) -> Self::ValueType<Option<i64>>;
 
     /// Gets the time stamp of the edge if it is exploded
-    fn time(&self) -> Self::ValueType<Option<i64>>;
+    fn time(&self) -> Self::ValueType<Result<i64, GraphError>>;
 
     fn date_time(&self) -> Self::ValueType<Option<DateTime<Utc>>>;
 
@@ -258,8 +258,8 @@ impl<'graph, E: BaseEdgeViewOps<'graph>> EdgeViewOps<'graph> for E {
     }
 
     /// Gets the time stamp of the edge if it is exploded
-    fn time(&self) -> Self::ValueType<Option<i64>> {
-        self.map(|_, e| e.time_t())
+    fn time(&self) -> Self::ValueType<Result<i64, GraphError>> {
+        self.map(|_, e| e.time_t().ok_or_else(|| GraphError::TimeAPIError))
     }
 
     fn date_time(&self) -> Self::ValueType<Option<DateTime<Utc>>> {
@@ -354,6 +354,11 @@ mod test_edge_view {
             .layer_name()
             .all(|l| l.is_ok()));
         assert!(g.edges().explode().layer_name().all(|l| l.is_ok()));
+
+        assert!(g.edge(1, 2).unwrap().time().is_err());
+        assert!(g.edges().time().all(|l| l.is_err()));
+        assert!(g.edge(1, 2).unwrap().explode().time().all(|l| l.is_ok()));
+        assert!(g.edges().explode().time().all(|l| l.is_ok()));
     }
 
     #[test]
diff --git a/raphtory/src/db/graph/graph.rs b/raphtory/src/db/graph/graph.rs
index c1506f7202..6e37ade193 100644
--- a/raphtory/src/db/graph/graph.rs
+++ b/raphtory/src/db/graph/graph.rs
@@ -1684,7 +1684,7 @@ mod db_tests {
                 e.explode().iter().filter_map(|e| {
                     e.edge
                         .layer()
-                        .zip(e.time())
+                        .zip(Some(e.time().unwrap()))
                         .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
                 })
             })
@@ -1714,7 +1714,7 @@ mod db_tests {
                 e.explode().iter().filter_map(|e| {
                     e.edge
                         .layer()
-                        .zip(e.time())
+                        .zip(Some(e.time().unwrap()))
                         .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
                 })
             })
diff --git a/raphtory/src/python/graph/edge.rs b/raphtory/src/python/graph/edge.rs
index 737f6550b2..dae72ccb83 100644
--- a/raphtory/src/python/graph/edge.rs
+++ b/raphtory/src/python/graph/edge.rs
@@ -263,7 +263,7 @@ impl PyEdge {
     /// Returns:
     ///     (int) The time of an exploded edge
     #[getter]
-    pub fn time(&self) -> Option<i64> {
+    pub fn time(&self) -> Result<i64, GraphError> {
         self.edge.time()
     }
 
diff --git a/raphtory/src/python/graph/edges.rs b/raphtory/src/python/graph/edges.rs
index fc2ed477c5..e2c25bbcae 100644
--- a/raphtory/src/python/graph/edges.rs
+++ b/raphtory/src/python/graph/edges.rs
@@ -16,7 +16,7 @@ use crate::{
         types::{
             repr::{iterator_repr, Repr},
             wrappers::iterators::{
-                ArcStringIterable, ArcStringVecIterable, BoolIterable, I64VecIterable,
+                ArcStringIterable, ArcStringVecIterable, BoolIterable, I64Iterable, I64VecIterable,
                 NestedArcStringIterable, NestedArcStringVecIterable, NestedBoolIterable,
                 NestedI64VecIterable, NestedOptionI64Iterable, NestedU64U64Iterable,
                 NestedUtcDateTimeIterable, NestedVecUtcDateTimeIterable, OptionArcStringIterable,
@@ -147,9 +147,14 @@ impl PyEdges {
     /// Returns:
     ///   Time of edge
     #[getter]
-    fn time(&self) -> OptionI64Iterable {
-        let edges = self.edges.clone();
-        (move || edges.time()).into()
+    fn time(&self) -> Result<I64Iterable, GraphError> {
+        match self.edges.time().next() {
+            Some(Err(err)) => Err(err),
+            _ => {
+                let edges = self.edges.clone();
+                Ok((move || edges.time().map(|t| t.unwrap())).into())
+            }
+        }
     }
 
     /// Returns all properties of the edges
@@ -413,9 +418,20 @@ impl PyNestedEdges {
 
     /// Returns the times of exploded edges
     #[getter]
-    fn time(&self) -> NestedOptionI64Iterable {
-        let edges = self.edges.clone();
-        (move || edges.time()).into()
+    fn time(&self) -> Result<NestedOptionI64Iterable, GraphError> {
+        match self.edges.time().flatten().next() {
+            Some(Err(err)) => Err(err),
+            _ => {
+                let edges = self.edges.clone();
+                Ok((move || {
+                    edges
+                        .time()
+                        .map(|t_iter| t_iter.map(|t| t.unwrap()).into_dyn_boxed())
+                        .into_dyn_boxed()
+                })
+                .into())
+            }
+        }
     }
 
     /// Returns the name of the layer the edges belong to - assuming they only belong to one layer
diff --git a/raphtory/src/python/graph/views/graph_view_modules/export.rs b/raphtory/src/python/graph/views/graph_view_modules/export.rs
index a8189135b1..8b91ad7a9f 100644
--- a/raphtory/src/python/graph/views/graph_view_modules/export.rs
+++ b/raphtory/src/python/graph/views/graph_view_modules/export.rs
@@ -235,7 +235,7 @@ impl PyGraphView {
                 properties.set_item("layer", layer)?;
                 if include_update_history.unwrap_or(true) {
                     if explode_edges.unwrap_or(true) {
-                        properties.set_item("update_history", e.time())?;
+                        properties.set_item("update_history", e.time()?)?;
                     } else {
                         properties.set_item("update_history", e.history())?;
                     }
diff --git a/raphtory/src/search/mod.rs b/raphtory/src/search/mod.rs
index 141f8205b5..d7bcd9f824 100644
--- a/raphtory/src/search/mod.rs
+++ b/raphtory/src/search/mod.rs
@@ -445,7 +445,7 @@ impl<'graph, G: GraphViewOps<'graph>> IndexedGraph<G> {
 
         // add all time events
         for e in e_ref.explode() {
-            if let Some(t) = e.time() {
+            if let Ok(t) = e.time() {
                 document.add_i64(time_field, t);
             }
         }

From fb5c448bc0e33cf9a5d50630d770445d836812b1 Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Wed, 8 May 2024 14:14:41 +0100
Subject: [PATCH 03/13] dep impl

---
 raphtory/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/raphtory/Cargo.toml b/raphtory/Cargo.toml
index 47cde45f44..7ac2e8370c 100644
--- a/raphtory/Cargo.toml
+++ b/raphtory/Cargo.toml
@@ -77,6 +77,7 @@ tokio = { workspace = true } # for vector testing
 dotenv = { workspace = true } # for vector testing
 streaming-stats = { workspace = true }
 proptest = { workspace = true }
+futures-util = { workspace = true }
 
 [features]
 default = []

From 4e04fcc4a3e3668d56c5b609c6137c274febaf6b Mon Sep 17 00:00:00 2001
From: miratepuffin <b.a.steer@qmul.ac.uk>
Date: Wed, 8 May 2024 17:17:06 +0100
Subject: [PATCH 04/13] rmv import

---
 raphtory/src/python/graph/edges.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/raphtory/src/python/graph/edges.rs b/raphtory/src/python/graph/edges.rs
index e2c25bbcae..5eed35478a 100644
--- a/raphtory/src/python/graph/edges.rs
+++ b/raphtory/src/python/graph/edges.rs
@@ -30,7 +30,6 @@ use crate::{
         },
     },
 };
-use futures_util::{FutureExt, TryStreamExt};
 use itertools::Itertools;
 use pyo3::{
     prelude::PyModule, pyclass, pymethods, types::PyDict, IntoPy, PyObject, PyResult, Python,

From c06212642f8fea5bc62adbbd8b4e7ecccca2a737 Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Wed, 8 May 2024 17:41:50 +0100
Subject: [PATCH 05/13] fix notebook

---
 python/tests/notebook.ipynb | 96 +++++++++++++++++++++++--------------
 1 file changed, 60 insertions(+), 36 deletions(-)

diff --git a/python/tests/notebook.ipynb b/python/tests/notebook.ipynb
index ecd97f830d..e11946767e 100644
--- a/python/tests/notebook.ipynb
+++ b/python/tests/notebook.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -25,7 +25,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -35,10 +35,10 @@
     {
      "data": {
       "text/plain": [
-       "Graph(number_of_edges=0, number_of_nodes=0, number_of_temporal_edges=0, earliest_time=\"None\", latest_time=\"None\")"
+       "Graph(number_of_nodes=0, number_of_edges=0, number_of_temporal_edges=0, earliest_time=None, latest_time=None)"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -52,19 +52,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[[['_default'], ['layer1'], ['layer2']],\n",
-       " [['_default']],\n",
-       " [['layer1']],\n",
-       " [['layer2']]]"
+       "NestedArcStringVecIterable([[[_default], [layer1], [layer2]], [[_default]], [[layer1]], [[layer2]]])"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -98,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -107,13 +104,13 @@
      "text": [
       "True True False\n",
       "True False\n",
-      "3 5\n",
+      "702 142\n",
       "True True False\n",
       "True False\n",
-      "4 7\n",
-      "Node(name=Ben, earliest_time=\"5\", latest_time=\"8\")\n",
-      "Edge(source=Haaroon, target=Hamza, earliest_time=7, latest_time=7, properties={property3: test, property1: 1, property2: 9.8, First-Met: {\"toad\": Str(ArcStr(\"01/01/1990\"))}})\n",
-      "Graph(number_of_edges=5, number_of_nodes=8, number_of_temporal_edges=7, earliest_time=\"0\", latest_time=\"8\")\n",
+      "703 144\n",
+      "Node(name=Ben, earliest_time=5, latest_time=8)\n",
+      "Edge(source=Haaroon, target=Hamza, earliest_time=7, latest_time=7, properties={property3: test, property1: 1, property2: 9.8, First-Met: {ArcStr(\"toad\"): Str(ArcStr(\"01/01/1990\"))}})\n",
+      "Graph(number_of_nodes=146, number_of_edges=705, number_of_temporal_edges=2653, earliest_time=0, latest_time=32674)\n",
       "True\n"
      ]
     }
@@ -178,7 +175,7 @@
     {
      "data": {
       "text/plain": [
-       "[None, None, None, None, None]"
+       "[['_default'], ['layer1'], ['layer2']]"
       ]
      },
      "execution_count": 5,
@@ -187,25 +184,14 @@
     }
    ],
    "source": [
-    "list(g.edges.layer_name)"
+    "list(g.edges.layer_names)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "NestedOptionI64Iterable([[0, 0, 0], [0], [0], [0], [], [0], [0, 0], [0]])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "g.nodes.edges.start"
    ]
@@ -218,7 +204,7 @@
     {
      "data": {
       "text/plain": [
-       "<networkx.classes.multidigraph.MultiDiGraph at 0x13c515110>"
+       "<networkx.classes.multidigraph.MultiDiGraph at 0x105d32a40>"
       ]
      },
      "execution_count": 7,
@@ -243,6 +229,16 @@
    "execution_count": 8,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
@@ -255,7 +251,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAG1CAYAAAAWb5UUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA2h0lEQVR4nO3de3hU5bn+8XsOORESTQIkbKwC0YBIOASSQn8l0KCIG+0Wcbu3AgqiUBBQFLFQKgoXiICAhSoHURSk26p4qu4ialuLG2MCUlEOAeWoJCEkIRxCwsys3x+YkSEBQjLJTPJ+P9clZN61Zq3nWWsa7q71zozNsixLAAAAhrAHugAAAID6RPgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIziDHQBwciyLHk8Zn3wtd1uM67ns9E//dM//ZusMRwDu90mm81WrXUJP1XweCwVFp4IdBn1xum0KyYmUiUlJ+VyeQJdTr2jf/qnf/o3tX+p8RyD2NhIORzVCz/c9gIAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwijPQBZjG6fTNmy6XJ0CVAABgJsJPPXI67fpk8/c6dOSEJKllXKQyUloRgAAAqEeEn3p26MgJ7TtUEugyAAAwFnN+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGCUgIef4uJiPf7440pPT1dKSoruvPNOZWdne5cPHz5c7dq18/lv6NCh3uVlZWV68skn1bNnT3Xt2lWPPPKICgsLA9EKAABoAJyBLuDhhx/W4cOHNX/+fMXFxWnVqlUaMWKE3nrrLbVt21Y7d+7UE088oeuvv977nJCQEO/PTzzxhLKzs7Vo0SKFhoZq2rRpGj9+vFavXh2IdgAAQJALaPjZt2+fPvvsM61Zs0bdunWTJP3+97/XP//5T7333nsaMmSIjhw5os6dO6t58+aVnp+Xl6e3335bS5YsUffu3SVJ8+fPV//+/fXll1+qa9eu9doPAAAIfgG97RUTE6Nly5YpOTnZO2az2WSz2VRSUqKdO3fKZrOpTZs2VT5/06ZNkqQePXp4x9q0aaP4+HhlZWXVbfEAAKBBCuiVn+joaPXu3dtnbN26ddq3b5+mTJminJwcRUVFafr06frss8/UpEkT9e/fX2PGjFFoaKjy8vIUExOjsLAwn220aNFCubm5tarN6fR/LnQ47LLpTLiTJJtscjgCPu3KW0Mw1BII9E//Z/9tGvo3u3/JzGMQ8Dk/Z9u8ebMmT56sfv36qU+fPpoyZYrKysrUqVMnDR8+XNu3b9ecOXP0ww8/aM6cOSotLVVoaGil7YSFhamsrKzGddjtNsXERNamlfNyOO1yOh3en6OjI+pkPzURTLUEAv3Tv8no3+z+JbOOQdCEn48++kgTJ05USkqK5s2bJ0maPn26HnvsMV122WWSpKSkJIWEhGjChAmaNGmSwsPDVV5eXmlbZWVlioio+Un0eCyVlJys8fPPx+Gwy+3yyOVyS5LcLo9KSkrldnv8vq9LrSs6OiIoagkE+qd/+qd/U/uXGs8xiI6OqPbVq6AIP6tXr9bMmTPVv39/Pf30096rOU6n0xt8KlxzzTWSpNzcXCUkJKi4uFjl5eU+V4Dy8/MVHx9fq5pcrrp5AViyZFmW92e321Nn+7pUwVRLINA//dM//ZvMpGMQ8Bt8a9as0YwZMzR48GDNnz/fJ8QMHTpUkydP9ll/69atCgkJUevWrdWtWzd5PB7vxGdJ2rNnj/Ly8pSamlpvPQAAgIYjoFd+9uzZo1mzZumGG27QqFGjVFBQ4F0WHh6uG2+8UbNmzVKnTp30y1/+Ulu3btWcOXM0YsQINW3aVE2bNtWAAQM0depUzZo1SxEREZo2bZrS0tLUpUuXwDUGAACCVkDDz7p163T69GmtX79e69ev91k2cOBAzZ49WzabTatWrdKsWbPUvHlzDRs2TCNHjvSuN2PGDM2aNUtjx46VJKWnp2vq1Kn12gcAAGg4bFbFBBR4ud0eFRae8Pt2nU67Xl2fo32HSiRJV7WM1uAbkgJ+j9XptCsmJlJFRScCXksg0D/90z/9m9q/1HiOQWxsZLUnPAd8zg8AAEB9IvwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjBDz8FBcX6/HHH1d6erpSUlJ05513Kjs727t848aNuu2229S5c2f1799f77//vs/zy8rK9OSTT6pnz57q2rWrHnnkERUWFtZ3GwAAoIEIePh5+OGH9eWXX2r+/Pl68803de2112rEiBH67rvv9O2332rUqFHq1auX1q5dq//8z//UpEmTtHHjRu/zn3jiCW3YsEGLFi3Syy+/rO+++07jx48PYEcAACCYOQO583379umzzz7TmjVr1K1bN0nS73//e/3zn//Ue++9pyNHjqhdu3aaMGGCJCkxMVHbtm3TCy+8oJ49eyovL09vv/22lixZou7du0uS5s+fr/79++vLL79U165dA9YbAAAITgG98hMTE6Nly5YpOTnZO2az2WSz2VRSUqLs7Gz17NnT5zk9evTQpk2bZFmWNm3a5B2r0KZNG8XHxysrK6t+mgAAAA1KQK/8REdHq3fv3j5j69at0759+zRlyhS99dZbSkhI8FneokULlZaWqqioSHl5eYqJiVFYWFildXJzc2tVm9Pp/1zocNhl05lwJ0k22eRwBPzOo7eGYKglEOif/s/+2zT0b3b/kpnHIKDh51ybN2/W5MmT1a9fP/Xp00enTp1SaGiozzoVj8vLy1VaWlppuSSFhYWprKysxnXY7TbFxETW+PkX4nDa5XQ6vD9HR0fUyX5qIphqCQT6p3+T0b/Z/UtmHYOgCT8fffSRJk6cqJSUFM2bN0/SmRBTXl7us17F44iICIWHh1daLp15B1hERM1PosdjqaTkZI2ffz4Oh11ul0cul1uS5HZ5VFJSKrfb4/d9XWpd0dERQVFLINA//dM//Zvav9R4jkF0dES1r14FRfhZvXq1Zs6cqf79++vpp5/2Xs1p2bKl8vPzfdbNz89XkyZNFBUVpYSEBBUXF6u8vNznClB+fr7i4+NrVZPLVTcvAEuWLMvy/ux2e+psX5cqmGoJBPqnf/qnf5OZdAwCfoNvzZo1mjFjhgYPHqz58+f7hJju3bvriy++8Fn/888/V0pKiux2u7p16yaPx+Od+CxJe/bsUV5enlJTU+utBwAA0HAENPzs2bNHs2bN0g033KBRo0apoKBAhw8f1uHDh3Xs2DENHTpUX331lebNm6dvv/1WL774ov7617/qvvvukyTFx8drwIABmjp1qjIzM/XVV1/p4YcfVlpamrp06RLI1gAAQJAK6G2vdevW6fTp01q/fr3Wr1/vs2zgwIGaPXu2nnvuOc2dO1cvv/yyrrjiCs2dO9fn7e8zZszQrFmzNHbsWElSenq6pk6dWq99AACAhsNmVUxAgZfb7VFh4Qm/b9fptOvV9Tnad6hEknRVy2gNviEp4PdYnU67YmIiVVR0IuC1BAL90z/907+p/UuN5xjExkZWe8JzwOf8AAAA1CfCDwAAMArhBwAAGIXwAwAAjBIUH3JoKru96u/2asgTzgAACHaEnwBqEdNE67MP6lDBce9Yy7hIZaS0IgABAFBHCD8BlltwwvvWdwAAUPeY8wMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCh1En5yc3PrYrMAAAC1VqPwc+211+qrr76qcll2drZuuummWhUFAABQV5zVXfHFF1/UyZMnJUmWZen111/Xp59+Wmm9L7/8UqGhof6rEAAAwI+qHX7Kysq0ePFiSZLNZtPrr79eaR273a6oqCiNHj3afxUCAAD4UbXDz+jRo72hpn379vrzn/+sTp061VlhAAAAdaHa4edsO3bs8HcdAAAA9aJG4UeSPvvsM/3tb39TaWmpPB6PzzKbzaZZs2bVujgAAAB/q1H4efHFFzVnzhyFhYUpNjZWNpvNZ/m5jwEAAIJFjcLP6tWrdcstt2jmzJm8swsAADQoNfqcn4KCAt1+++0EHwAA0ODUKPx06NBBu3bt8nctAAAAda5Gt72mTJmihx56SE2aNFHnzp0VERFRaZ1/+7d/q3VxAAAA/laj8HPnnXfK4/FoypQp553cvH379loVBgAAUBdqFH5mzJjBO7oAAECDVKPwc9ttt/m7DknS0qVLtWHDBq1atco7NnXq1EpfpdGqVSt98sknkiSPx6PFixfr9ddf17Fjx5SamqrHH39cP/vZz+qkRgAA0LDVKPxkZWVddJ3U1NRL2uarr76qhQsXqnv37j7jO3fu1G9+8xsNGTLEO+ZwOLw/P/fcc1qzZo1mz56thIQEzZ07V/fdd5/ee+893o0GAAAqqVH4GTp0qGw2myzL8o6dexusunN+8vLyNG3aNGVmZqp169Y+yyzL0u7duzVy5Eg1b9680nPLy8v14osvauLEierTp48kacGCBerVq5c+/PBD3XzzzZfWGAAAaPRqFH5eeeWVSmMnT55Udna23nnnHS1atKja2/rmm28UEhKid999V3/84x/1/fffe5ft379fJ0+eVNu2bat87o4dO3TixAn17NnTOxYdHa0OHTooKyuL8AMAACqpUfhJS0urcrxPnz5q0qSJnn/+eS1durRa28rIyFBGRkaVy3JyciRJq1at0qeffiq73a709HRNmDBBUVFRys3NlSS1bNnS53ktWrTwLqspp7NGH4F0QQ6HXTbZvFfJbD/+cfZVM5tscjj8v++L1XX236ahf/o/+2/T0L/Z/UtmHoMaf7Hp+XTv3l3Lly/3y7ZycnJkt9vVokULLVmyRPv379ecOXO0a9cuvfzyyyotLZWkSnN7wsLCdPTo0Rrv1263KSYmsla1n4/DaZfTeWbOkt1hl8Px0+OK5dHRlT83qT4Ear/Bgv7p32T0b3b/klnHwO/h55NPPlFkpH+Cw+jRo3XXXXcpJiZGkpSUlKTmzZvrjjvu0NatWxUeHi7pzNyfip8lqaysrMoPXqwuj8dSScnJ2hVfBYfDLrfLI5fLfWY/bo/c7p8eS5Lb5VFJSancbo/f93+huqKjI+p9v8GC/umf/unf1P6lxnMMoqMjqn31qkbh5+6776405vF4lJubq++//173339/TTZbid1u9wafCtdcc40kKTc313u7Kz8/X1deeaV3nfz8fLVr165W+3a56uYFYMnyThS3fvzj7InjlqwfA1H9vwADtd9gQf/0T//0bzKTjkGNbvBZllXpP7vdrqSkJE2fPl0PPfSQX4qbNGmShg0b5jO2detWSdLVV1+t9u3bq2nTpsrMzPQuLykp0bZt2y75rfYAAMAMNbryc/aHENalG2+8UWPGjNHixYv161//Wnv27NH06dN18803KzExUZI0ZMgQzZs3T7GxsWrVqpXmzp2rhIQE9evXr15qBAAADUut5vx8+umn+uKLL1RSUqLY2Fh169ZNvXr18ldt6tu3rxYuXKhly5Zp+fLlioqK0i233OJzZWn8+PFyuVyaOnWqTp06pdTUVK1YsUIhISF+qwMAADQeNuvsCSfVVF5erjFjxmjDhg1yOByKiYlRUVGRPB6PevTooaVLlzboT1d2uz0qLDzh9+06nXa9uj5H+w6VSJJ+3rGl8o6c1N5DP70z7aqW0Rp8Q1K93nd1Ou2KiYlUUdEJY+73no3+6Z/+6d/U/qXGcwxiYyOrPeG5RnN+Fi1apE2bNmnOnDn66quvtGHDBv3rX//SU089pS1btuj555+vyWYBAADqXI3Cz1/+8heNHTtWv/71r73fs+V0OnXrrbdq7Nixeu+99/xaJAAAgL/UKPwUFhaqQ4cOVS7r0KGD8vLyalUUAABAXalR+Lnyyiu1adOmKpdlZWVV+roJAACAYFGjd3v993//t2bPnq3w8HANGDBAzZo1U0FBgf7yl79o+fLlGjt2rL/rBAAA8IsahZ8777xT27Zt07x58/TMM894xy3L0sCBAzVy5Ei/FQgAAOBPNQo/5eXlmjlzpu6991598cUXOnr0qGw2m66//nrvhw8CAAAEo0ua87Nz504NGjRIL730kiQpMTFRd955p+666y49++yzevjhh7Vnz546KRQAAMAfqh1+Dh48qLvvvlsFBQVq06aNz7KQkBBNmjRJxcXFuuuuu3i3FwAACFrVDj/Lli3T5Zdfrrfeekv9+/f3WRYREaFhw4bpjTfeUFhYmJYuXer3QgEAAPyh2uFn48aNuu+++xQbG3vedZo3b657771Xn332mV+KAwAA8Ldqh5/8/Hy1bt36ouslJSUpNze3NjUBAADUmWqHn9jYWOXn5190vaKiIl122WW1KgoAAKCuVDv8pKamau3atRdd7+233z7vV18AAAAEWrXDz9ChQ5WZmanZs2errKys0vLy8nLNmTNHn376qQYPHuzXIgEAAPyl2h9ymJycrMmTJ2vWrFl655131LNnT11xxRVyu9364YcflJmZqaKiIj344IPq1atXXdYMAABQY5f0Cc+DBw9W+/bttWLFCn388cfeK0CRkZH65S9/qXvvvVedO3euk0IBAAD84ZK/3qJbt27q1q2bJKmwsFBOp1PR0dF+LwwAAKAu1Oi7vSpc6DN/AAAAgtElfbcXAABAQ0f4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAozgDXQB82e02ORy+mdTl8gSoGgAAGh/CT5BpEdNE67MP6lDBcUlSy7hIZaS0IgABAOAnhJ8glFtwQvsOlQS6DAAAGiXm/AAAAKMEVfhZunSphg4d6jO2fft2DRkyRF26dFFGRoZeeeUVn+Uej0d/+MMf1KtXL3Xp0kX333+/Dhw4UJ9lAwCABiRows+rr76qhQsX+owVFRVp+PDhuvLKK/Xmm2/qgQce0Lx58/Tmm29613nuuee0Zs0azZgxQ//zP/8jj8ej++67T+Xl5fXcAQAAaAgCPucnLy9P06ZNU2Zmplq3bu2z7M9//rNCQkI0ffp0OZ1OJSYmat++fVq2bJkGDRqk8vJyvfjii5o4caL69OkjSVqwYIF69eqlDz/8UDfffHP9NwQAAIJawK/8fPPNNwoJCdG7776rzp07+yzLzs5WWlqanM6fMlqPHj20d+9eFRQUaMeOHTpx4oR69uzpXR4dHa0OHTooKyur3noAAAANR8Cv/GRkZCgjI6PKZbm5uUpKSvIZa9GihSTp0KFDys3NlSS1bNmy0joVy2rK6fR/LnQ47LLJJpvNJkmy/fhHxeOqxmyq/Lk/dVHX2X+bhv7p/+y/TUP/ZvcvmXkMAh5+LuTUqVMKDQ31GQsLC5MklZWVqbS0VJKqXOfo0aM13q/dblNMTGSNn38hDqddTqfjzH4cdjkcPz2uaszhtCs6OqJOajlXfe0nWNE//ZuM/s3uXzLrGAR1+AkPD680cbmsrEyS1KRJE4WHh0uSysvLvT9XrBMRUfOT6PFYKik5WePnn4/DYZfb5ZHL5T6zH7dHbvdPj6sac7s8Kikpldtddx9y6HCcCVh1vZ9gRf/0T//0b2r/UuM5BtHREdW+ehXU4SchIUH5+fk+YxWP4+Pj5XK5vGNXXnmlzzrt2rWr1b7r6hOVLVmyLOvHn8/8UfG4qjFL1o9hqO5fkPW1n2BF//RP//RvMpOOQVDf4EtNTdWmTZvkdv90ZeTzzz9XmzZtFBcXp/bt26tp06bKzMz0Li8pKdG2bduUmpoaiJIBAECQC+rwM2jQIB0/fly/+93vtHv3bq1du1YrV67UqFGjJJ2Z6zNkyBDNmzdPH3/8sXbs2KEJEyYoISFB/fr1C3D1AAAgGAX1ba+4uDi98MILmjlzpgYOHKjmzZtr0qRJGjhwoHed8ePHy+VyaerUqTp16pRSU1O1YsUKhYSEBLByAAAQrIIq/MyePbvSWKdOnfTaa6+d9zkOh0OPPvqoHn300bosLWDs9qrf6m7KfVkAAPwtqMIPKmsR00Trsw/qUMFx71jLuEhlpLQiAAEAUAOEnwYgt+CE9h0qCXQZAAA0CkE94RkAAMDfCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGIfwAAACjEH4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4AQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMQvgBAABGcQa6APiP0+mbZV0uT4AqAQAgeDWI8JOXl6f09PRK40899ZRuu+02bd++XTNnztTXX3+t2NhYDRs2THfffXcAKg0cp9OuTzZ/r0NHTkiSWsZFKiOlFQEIAIBzNIjws2PHDoWFhemjjz6SzWbzjkdFRamoqEjDhw9XRkaGnnzySW3ZskVPPvmkIiMjNWjQoABWXf8OHTmhfYdKAl0GAABBrUGEn5ycHLVu3VotWrSotOzll19WSEiIpk+fLqfTqcTERO3bt0/Lli0zLvwAAICLaxATnnfu3KnExMQql2VnZystLU1O5085rkePHtq7d68KCgrqq0QAANBANJgrPzExMRo8eLD27Nmjq666SqNHj1Z6erpyc3OVlJTks37FFaJDhw6pWbNmNdrnuZOH/cHhsMsmm/fWne3HP86+lXfuWNXr2ORw+NZXeduV17lQXWf/bRr6p/+z/zYN/Zvdv2TmMQj68ONyufTdd9/p6quv1m9/+1s1bdpU77//vkaOHKmXXnpJp06dUmhoqM9zwsLCJEllZWU12qfdblNMTGSta6+Kw2mX0+k4sx+HXQ7HT4+rGqtqHYfTrujoiAtu+3zrXMilrt/Y0D/9m4z+ze5fMusYBH34cTqdyszMlMPhUHh4uCSpY8eO2rVrl1asWKHw8HCVl5f7PKci9DRp0qRG+/R4LJWUnKxd4VVwOOxyuzxyudxn9uP2yO3+6XFVY1Wt43Z5VFJSKrfbc95tV7XOheqKjo6o9vqNDf3TP/3Tv6n9S43nGERHR1T76lXQhx9JioysfBXmmmuu0YYNG5SQkKD8/HyfZRWP4+Pja7zPunqLuCVLlmX9+POZPyoeVzVW9TrWj4HIt0bfbVe9zoVc6vqNDf3TP/3Tv8lMOgZBf4Nv165dSklJUWZmps/4119/rauvvlqpqanatGmT3O6frox8/vnnatOmjeLi4uq7XAAAEOSCPvwkJiaqbdu2mj59urKzs/Xtt9/qqaee0pYtWzR69GgNGjRIx48f1+9+9zvt3r1ba9eu1cqVKzVq1KhAlw4AAIJQ0N/2stvtWrJkiZ555hk99NBDKikpUYcOHfTSSy953+X1wgsvaObMmRo4cKCaN2+uSZMmaeDAgQGuHAAABKOgDz+S1KxZMz311FPnXd6pUye99tpr9VgRAABoqIL+thcAAIA/EX4AAIBRCD8AAMAohB8AAGAUwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEaxNdbwH+cTt+863J5AlQJAACBQfgxiNNp1yebv9ehIyckSS3jIpWR0irAVQEAUL8IP4Y5dOSE9h0qCXQZAAAEDOGnkbLbbXI4fG9xnfsYAAATEX4aqRYxTbQ++6AOFRz3jl3XNk422QJYFQAAgUf4acRyC3xvcSXERQawGgAAggPhpwHilhYAADVH+GmAuKUFAEDNEX4aKG5pAQBQM9wrAQAARiH8AAAAoxB+AACAUQg/AADAKIQfAABgFMIPAAAwCuEHAAAYhfADAACMwocc4qKczsoZ2eXyBKASAABqj/CDSs4OOw6HXeuzDujQkRPesZZxkcpIaUUAAgA0SIQf+HA67fpk8/fesHNd2zjlHjnp81UaAAA0ZIQfVHLoyE/fG8Z3hgEAGhsmPAMAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIW3uuOS2e02ORy+uZkPPAQANBSEH1yyFjFNtD77oA4VHJfEJz4DABoWwg9qJLfgBJ/6DABokJjzAwAAjEL4AQAARuG2l8HOnbh87iTmQDn7W+UlJlMDAPyL8GOwionLuQUn5HDa5XZ51KFtrGyyBaymc79VnsnUAAB/I/wYLrfghPbllsjpdMjlcis+ronftn3uFRypeldxzv5W+UvZdk32BQAwD+EHdeLcKziS/67inLvt69rGqbCkzPvWe3/uCwDQ+BB+UGtVfeihw2Gv1hWcmjp72wlxkco7cpK33gMAqoXwg1o790MPpTNXY6ozd+jc21fBMukaANB4EX7gF+d+6GFCXGSldap6d9n6rAM+t8aqG5oAAKgpwg/qzblXiK5rG6fcc25XVRWa/KWmE7Cruy1/bbs+OZ12byB1OOx1WrM/jz8A1EajCD8ej0eLFy/W66+/rmPHjik1NVWPP/64fvaznwW6NJzj7CtEdRl0znWhCdi13VZDnXBd0UfukZNyOO1qfnmEMrr+W53UXJcT4AHgUjWK8PPcc89pzZo1mj17thISEjR37lzdd999eu+99xQaGhro8hAAVd1i8+cE7ItNuK5qEngw/iN/6MgJ7c89JqfTIXcd13fu8W8oxwhA49Pgw095eblefPFFTZw4UX369JEkLViwQL169dKHH36om2++ObAFolbO906yi6nqFlt9ziU6d/+tmjVV3+5XyO2+9H/cqwoEjeFTsM89Rv68EhSMt9gawzkDGosGH3527NihEydOqGfPnt6x6OhodejQQVlZWYSfBq427yS72C226n69R03/kTp3/1X1cfbtsurePjv3FtL5glVd/eNa3WBx9nrnO7bnTpSvzv6qs69zJ9JXN1jVNDRdrMbanLNL7f98CFu+Ko5Zbee8BWPQDjbBeIxslmVZAa2glj788EONGzdO//rXvxQeHu4df/DBB3Xq1CktXbr0krdpWZY8Hv8fFptNKi1zy/XjL7zQEIc8Hsv7uKqx6qxT0+ed/dhmkyyr9tupyxrrYh2bJLdlySbJkuR02GV5LLl/PP8Ou02hIY4fl3rPpErLXPVSo9NhV0SY86L7t0nems9f97l+2o7NJjnsVe2r8nPKT7ursS/f9ZzOM/+wXKj/8/V69nZquq+qt/3T8+12mzweq5q9XfiYVPc1U71zVrP+z34NX7yPn/q/cJ+NyVnHzCbZJNlt1TnXF9jOj6r3mgk2dfkaON8xssvf6cNut8lmq94V/gZ/5ae0tFSSKs3tCQsL09GjR2u0TZvNJoejbm6RREbwOTYNk+/rITIipIHs/8Kv46q3c+HnhIed79eG7YLrhYU4Lrjd6m6ndvs6f292u63avZ2rOjXW9JzVpP/qbvtsdrvtgssbm5qe67raTjCoq9dA9V+f9afB/0tccbWnvLzcZ7ysrEwRERGBKAkAAASxBh9+WrZsKUnKz8/3Gc/Pz1d8fHwgSgIAAEGswYef9u3bq2nTpsrMzPSOlZSUaNu2bUpNTQ1gZQAAIBgF3424SxQaGqohQ4Zo3rx5io2NVatWrTR37lwlJCSoX79+gS4PAAAEmQYffiRp/Pjxcrlcmjp1qk6dOqXU1FStWLFCISH1PSkVAAAEuwb/VncAAIBL0eDn/AAAAFwKwg8AADAK4QcAABiF8AMAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwYpLi7W448/rvT0dKWkpOjOO+9Udna2d/nw4cPVrl07n/+GDh0awIr9Ky8vr1J/7dq109q1ayVJ27dv15AhQ9SlSxdlZGTolVdeCXDF/pWZmVll/+3atVPfvn0lSc8//3yVyxu6pUuXVnotX+x8ezwe/eEPf1CvXr3UpUsX3X///Tpw4EB9lu03VfX/ySefaNCgQeratasyMjL09NNP69SpU97lmzZtqvK1cPZXCTUUVfU/derUSr1lZGR4lzfm8z906NDz/i54++23JUlut1udOnWqtHzRokUB6sLPLBhj+PDh1s0332xlZWVZ3333nfXkk09anTp1sr799lvLsiyrZ8+e1po1a6z8/Hzvf0VFRYEt2o/+/ve/W8nJyVZeXp5Pj6WlpVZhYaH185//3Jo8ebK1e/du64033rCSk5OtN954I9Bl+01ZWZlP3/n5+daHH35otWvXztvngw8+aD366KOV1mvIVq9ebbVv394aMmSId6w653vRokXWz3/+c+tvf/ubtX37duvee++1+vXrZ5WVlQWijRqrqv+srCzr2muvtZ5//nlrz5491t///ncrPT3d+u1vf+td59VXX7Wuv/76Sq+FxtC/ZVnW7bffbs2fP9+ntyNHjniXN+bzX1RU5NN3Xl6eddddd1kDBgywjh8/blmWZe3evdtKSkqytm/f7rNuxfKGjvBjiL1791pJSUlWdna2d8zj8VjXX3+9tXDhQqugoMBKSkqyvvnmmwBWWbeWLVtm3XLLLVUuW7JkifXLX/7SOn36tHfsmWeesfr161df5dW7EydOWL/61a98/sG76aabrJdeeilwRflRbm6uNWrUKKtLly5W//79fX75X+x8l5WVWV27drVeffVV7/KjR49anTp1st577736a6IWLtT/I488Yg0bNsxn/bfeesu67rrrvP+4T5s2zfrNb35TrzX704X693g8VpcuXawPP/ywyuc29vN/rlWrVlkdO3b0/h9hy7Ks999/30pJSamPUgOC216GiImJ0bJly5ScnOwds9lsstlsKikp0c6dO2Wz2dSmTZsAVlm3du7cqcTExCqXZWdnKy0tTU7nT19316NHD+3du1cFBQX1VWK9WrJkiUpLS/XYY49JksrLy7V37161bds2wJX5xzfffKOQkBC9++676ty5s8+yi53vHTt26MSJE+rZs6d3eXR0tDp06KCsrKx666E2LtT/vffe6z3vFex2u06fPq3jx49LuvD/XhqCC/W/f/9+nTx58ryv9cZ+/s9WWFiohQsXavTo0T7Ho6Gf/4tpFF9siouLjo5W7969fcbWrVunffv2acqUKcrJyVFUVJSmT5+uzz77TE2aNFH//v01ZswYhYaGBqhq/8rJyVFMTIwGDx6sPXv26KqrrtLo0aOVnp6u3NxcJSUl+azfokULSdKhQ4fUrFmzQJRcZwoLC7Vy5Uo98sgjuvzyyyVJu3fvltvt1rp16zRz5kyVlZUpNTVVjz76qPdYNCQZGRk+czjOdrHznZubK0lq2bJlpXUqlgW7C/XfoUMHn8enT5/WypUr1bFjR8XGxkqSdu3apZiYGN12223Ky8tTUlKSJkyYoE6dOtV57f5wof5zcnIkSatWrdKnn34qu92u9PR0TZgwQVFRUY3+/J9t+fLlCg8P14gRI3zGc3Jy5HK5NGLECO3YsUPx8fG655579B//8R91VXK94sqPoTZv3qzJkyerX79+6tOnj3JyclRWVqZOnTrphRde0OjRo/X6669r6tSpgS7VL1wul7777jsdPXpU48aN07Jly9SlSxeNHDlSGzdu1KlTpyqFvLCwMElSWVlZIEquU2vWrFFUVJT+67/+yztW8Q9CRESEnn32Wc2cOVPfffed7r77bp+JsI3Bxc53aWmpJFW5TmN7PbhcLk2aNEm7du3StGnTJJ0JgMeOHdPJkyc1depUPffcc2rWrJmGDBmi3bt3B7ji2svJyZHdbleLFi20ZMkS/fa3v9WGDRs0ZswYeTweY87/8ePH9ec//1kjRozwvv4r7Nq1S8XFxRo6dKhWrFihG2+8UZMnT9Ybb7wRoGr9iys/Bvroo480ceJEpaSkaN68eZKk6dOn67HHHtNll10mSUpKSlJISIgmTJigSZMmNfgrH06nU5mZmXI4HAoPD5ckdezYUbt27dKKFSsUHh6u8vJyn+dU/JJr0qRJvddb195++23deuut3mMhSbfeeqvS09O9/89fkq655hqlp6frk08+0b//+78HotQ6cbHzXXFcysvLfY5RWVmZIiIi6q/QOnb8+HE99NBD+uKLL7R48WLvVZ2WLVsqKytLERERCgkJkSQlJydr27ZtWrVqlZ588slAll1ro0eP1l133aWYmBhJZ37fNW/eXHfccYe2bt1qzPn/6KOPVF5erkGDBlVa9pe//EVut1uRkZGSpPbt2+uHH37QihUrdPvtt9d3qX7HlR/DrF69WuPGjdOvfvUrLVmyxJv2nU6nN/hUuOaaaySpwVzmvZjIyEifX2TSmR7z8vKUkJCg/Px8n2UVj+Pj4+utxvqwY8cOHThwQLfcckulZWcHH+nMZf7LL7+80bwGKlzsfFfc7qhqncbyesjPz9fgwYO1ZcsWrVixotJt8ejoaG/wkc7MCUpMTFReXl59l+p3drvdG3wqnP37zoTzL50JP71791Z0dHSlZeHh4d7gUyEpKanR/C4g/BhkzZo1mjFjhgYPHqz58+f7XNIdOnSoJk+e7LP+1q1bFRISotatW9dzpf63a9cupaSkVPqMkq+//lpXX321UlNTtWnTJrndbu+yzz//XG3atFFcXFx9l1unsrOzFRcXp/bt2/uML1iwQDfeeKMsy/KOHTx4UEVFRbr66qvru8w6dbHz3b59ezVt2tTn9VJSUqJt27YpNTU1ECX71dGjR3XPPfeosLBQr776aqWePv30U3Xt2tXnc21cLpd27NjRKF4LkyZN0rBhw3zGtm7dKkm6+uqrG/35r5Cdne0zqbtCSUmJ0tLSvJ+BVmHr1q3ekNjQEX4MsWfPHs2aNUs33HCDRo0apYKCAh0+fFiHDx/WsWPHdOONN+qdd97Rn/70Jx04cEAffPCB5syZoxEjRqhp06aBLr/WEhMT1bZtW02fPl3Z2dn69ttv9dRTT2nLli0aPXq0Bg0apOPHj+t3v/uddu/erbVr12rlypUaNWpUoEv3u23btlX5wYU33HCDvv/+ez3xxBPas2ePsrKyNG7cOKWkpKhXr14BqLTuXOx8h4aGasiQIZo3b54+/vhj7dixQxMmTFBCQoL69esX4Opr76mnntKBAwc0d+5cxcbGen8XHD58WG63WykpKYqJidFjjz2mr7/+Wjt37tRjjz2m4uLiSqGhIbrxxhu1ceNGLV68WPv379c//vEPTZkyRTfffLMSExMb/fmXzszrKioqqvR/gqQzV/169OihBQsW6B//+If27t2rZcuW6d1339W4ceMCUK3/MefHEOvWrdPp06e1fv16rV+/3mfZwIEDNXv2bNlsNq1atUqzZs1S8+bNNWzYMI0cOTJAFfuX3W7XkiVL9Mwzz+ihhx5SSUmJOnTooJdeesn7rp8XXnhBM2fO1MCBA9W8eXNNmjRJAwcODHDl/nf48GHvO7zO1rFjRy1fvlzPPvusbrvtNoWGhqpv37567LHHZLPZ6r/QOhQXF3fR8z1+/Hi5XC5NnTpVp06dUmpqqlasWOFzK6ghcrvd+uCDD3T69Gndc889lZZ//PHHuuKKK7Ry5UrNmzdPI0aMUFlZmbp166bVq1c3+Pl/ktS3b18tXLhQy5Yt0/LlyxUVFaVbbrlFDz30kHedxnr+Kxw+fFiSqvxdIEmzZs3SokWLNG3aNB05ckSJiYneT7xuDGzW2de4AQAAGjluewEAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjEL4ARD01q5dq3bt2ungwYOBLgVAI0D4AQAARiH8AAAAoxB+AAQVj8ej5557Tn369FHnzp01ZswYHT161GednJwcjRo1SikpKUpJSdEDDzzg8w3kkvTtt9/q/vvvV0pKin7xi19owYIFmjx5soYOHepdp127dlq8eLFuu+02derUSYsXL5Yk/fDDD3r44YeVlpamzp0765577tG2bdt8tl9WVqY5c+aod+/e6tixo2655RZ98MEHdXRUAPgT3+0FIKg8/fTTeuWVVzR69Gh17txZ//u//6t3331Xp0+f1scff6zTp09r0KBBatu2rUaNGiWXy6Xnn39ehYWFeueddxQXF6fCwkINGDBAcXFxGjdunNxut5599ln98MMP6tKli1atWiXpTPgJCQnRI488ojZt2qhVq1aKi4vTrbfeqoiICI0dO1YRERF6+eWX9fXXX+uNN95QYmKiLMvS/fffr82bN2v8+PFKTEzU+vXr9dprr+npp5/WrbfeGtiDCODCLAAIEkePHrWuu+46a+7cuT7jI0aMsJKSkqwDBw5YDz/8sPWLX/zCOnbsmHd5UVGR1a1bN2v27NmWZVnWwoULreTkZCs3N9e7zsGDB63rrrvOGjJkiHcsKSnJuueee3z2NX/+fCs5Odk6ePCgd6ysrMzq27evNW7cOMuyLGvDhg1WUlKS9f777/s8d+LEidb/+3//zzp9+nTtDgSAOsVtLwBBY8uWLTp9+rR+9atf+YzfdNNN3p8///xzpaWlKTw8XC6XSy6XS02bNlX37t31f//3f951unbtqvj4eO/zWrVqpa5du1ba57XXXuvzeOPGjbr22msVHx/v3b7dbld6erp3+xs3bpTNZlPv3r2967hcLmVkZOjw4cPatWuX344JAP9zBroAAKhQMbcnJibGZ7x58+ben4uLi/XBBx9UOb8mNjZWklRYWKjrrruu0vJmzZqpoKDAZ6xJkyY+j4uLi7Vv374qny9JpaWlKi4ulmVZSklJqXKd/Pz8SqEKQPAg/AAIGhWh58iRI2rbtq13vLi42PtzVFSUfvGLX2j48OGVnu90nvmVlpCQUCnkVGz3YqKiopSWlqZJkyZVuTw0NFRRUVFq0qSJXnnllSrXueqqqy66HwCBw20vAEGja9euCg8P11//+lef8b/97W/en9PS0rR7925de+21Sk5OVnJysjp27KiVK1dq/fr1kqTU1FRt2bJFhw8f9j4vPz9fW7ZsuWgNaWlp2rNnj9q0aePdfnJyst555x298cYbcjgcSktL08mTJ2VZls86OTk5+uMf/yiXy+WfAwKgThB+AASNyMhIjRkzRmvWrNG8efO0YcMGzZw50yf8jBkzRvv379eoUaP00Ucf6Z///KfGjRun999/X+3bt5ck3X333YqMjNSIESO0bt06rVu3Tvfff79Onz4tm812wRqGDRsmj8ejYcOG6YMPPtDGjRv1+9//XqtWrVKbNm0kSb1791Zqaqq31szMTC1fvlxPPPGE7Ha79/YbgODEW90BBJ1Vq1bp5ZdfVl5enrp27aqbbrpJTzzxhD7++GNdccUV+uabb7RgwQJt3rxZlmUpKSlJI0eOVN++fb3b2LVrl2bOnKkvv/xSkZGRuuuuu7RhwwZdfvnlWrJkiaQzb3UfO3asxo0b57P//fv365lnntHGjRtVVlam1q1ba+jQobr99tu965w8eVLPPvus/vrXv+rIkSOKj4/XgAED9MADDygsLKx+DhSAGiH8AGh0/vWvf6m4uFi9e/f2jrlcLvXp00cDBgzQ5MmTA1gdgEBjwjOARueHH37QhAkT9MADDygtLU2lpaV67bXXdOzYMd1xxx2BLg9AgHHlB0Cj9Kc//Ulr1qzRgQMHFBISos6dO+vBBx9UcnJyoEsDEGCEHwAAYBTe7QUAAIxC+AEAAEYh/AAAAKMQfgAAgFEIPwAAwCiEHwAAYBTCDwAAMArhBwAAGIXwAwAAjPL/AXNlE7/xOS7+AAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -306,6 +302,20 @@
    "execution_count": 10,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
@@ -318,7 +328,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -354,6 +364,20 @@
    "execution_count": 11,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/shivamkapoor/opt/miniconda3/envs/pyraphtory/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
@@ -366,7 +390,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHPCAYAAABAw5B5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUWUlEQVR4nO3deXgT1f4G8Hcmabq3tKW07FvZEVABQa8goLiwXAFFvOCCG7sXQRDZUUGQTX6iF7AgKmWVRREVBQS9CEgR5CKL7HtbutC9SZM5vz/SBEIqQpp0ksn7eR4f6SSdfvslpG/PnDNHEkIIEBEREWmArHYBRERERO7CYENERESawWBDREREmsFgQ0RERJrBYENERESawWBDREREmsFgQ0RERJrBYENERESawWBDREREmqFXuwA1CCGgKO6/4bIsSx45ry9jT5yxJ87YE2fsiTP2xJk/9USWJUiS9LfP88tgoygCmZn5bj2nXi8jKioUOTkFMJsVt57bV7EnztgTZ+yJM/bEGXvizN96Eh0dCp3u74MNL0URERGRZjDYEBERkWaoHmxSU1PRoEEDp//WrVsHADhy5Aj69euHFi1aoGPHjvjss89UrpiIiIi8lepzbI4ePYrAwEBs2bLFYVJQeHg4srKy0L9/f3Ts2BFTpkzBgQMHMGXKFISGhqJXr14qVk1ERETeSPVg8+eff6JWrVqoVKmS02OffvopAgIC8NZbb0Gv16Nu3bo4e/YsFi1axGBDRERETlS/FHXs2DHUrVu31MeSk5PRunVr6PXX8lebNm1w5swZpKenl1eJRERE5CO8YsQmKioKffv2xenTp1GzZk0MGjQI7dq1Q0pKCurXr+/wfNvIzuXLl1GxYkWXv65e795Mp9PJDv8n9qQ07Ikz9sQZe+KMPXHGnpRO1WBjNptx6tQpJCQkYMyYMQgLC8OmTZvwyiuv4JNPPkFRUREMBoPD5wQGBgIAjEajy19XliVERYWWqfa/EhER7JHz+jL2xBl74ow9ccaeOGNPnLEnjlQNNnq9Hnv27IFOp0NQUBAAoGnTpjh+/DgWL16MoKAgmEwmh8+xBZqQkBCXv66iCOTkFLheeCl0OhkREcHIySmExaL9GyXdCvbEGXvijD1xxp44Y0+c+VtPIiKCb2l0SvVLUaGhziMn9erVw3//+1/Ex8cjLS3N4THbx3FxcWX6up66S6PFovjFHSBvB3vijD1xxp44Y0+csSfO2BNHql6YO378OO666y7s2bPH4fihQ4eQkJCAVq1aYd++fbBYLPbHdu/ejdq1ayMmJqa8yyUiIiIvp2qwqVu3LurUqYO33noLycnJOHnyJN59910cOHAAgwYNQq9evZCXl4dx48bhxIkTWLduHZYuXYoBAwaoWTYRERF5KVUvRcmyjAULFmD27NkYPnw4cnJy0LhxY3zyySf21VCJiYmYOnUqevTogdjYWIwePRo9evRQs2wiIiLyUqrPsalYsSLefffdv3y8WbNmWLVqVTlWRERE5N9OXszG3qNpUBQBWZYgX7czgCIEFCEgS9eOK0IAAGRJQmyFIDxwZ1WH3QTKk+rBhoiIiLzL0u+O4uKVfJc/v3GtaMRFu756uSwYbIiIiMhBQZEZANC6USVUCAuELF83YqMICCEgSZL9uKKUjNjIEmIrBKNSlHr31mGwISIiIge2S0uPtamJGnHhKldze3gfZiIiInIglGtzZnwNgw0RERE5KMk1kGQGGyIiIvJx9jkzvpdrOMeGiIiIrC6n5+PHAxdhMlvv+C/7YLJhsCEiIiIAwOffH8PRc1cBABKAIIPvxQTfq5iIiIg8IiPHCABo1bAS7qofi8hQg8oV3T4GGyIiIgIA5BWaAADd7quFarFhKlfjGk4eJiIiIhSbFRQarXNrKoQFqlyN6xhsiIiICDn51tEaWZYQGuS7F3QYbIiIiAhX863za8KCA1TbwNIdfDeSERERkcv+dyoDR85k2T9Ou1oIAAgPCVCrJLdgsCEiIvIzQgh8tP4QjMUWp8cqRgapUJH7MNgQERH5GYsi7KHmwburQa+3zkwRQqDDXdXULK3MGGyIiIj8jNmi2P/8xAN1YQjQqViNe3HyMBERkZ8xW4T9zzqd704ULg2DDRERkZ+xlGxyKQGQfXgFVGkYbIiIiPyMpeRSlE4n+fTS7tIw2BAREfmZs6m5AACdTnsxQHvfEREREd3Uxp1nAABms3LzJ/ogBhsiIiI/Y5s8/GibmipX4n4MNkRERH6m2Gy9h03T2tEqV+J+DDZERER+xlRyCSpQQ/evsWGwISIi8jOmkrsOB+i1FwO09x0RERHRTdlGbAwB2osB3FKBiIhIo/YdS8PJizkAAEVYJwzLkoRiW7DRa+9SFIMNERGRBhUazfjPhj/sgeZGep2EIAODDREREfmAgiIzFCEgSxI6t64OpWQbBVm23mm4XrVITW1+acNgQ0REpEGmkiXdwYE69O6QoHI15Ud7s4aIiIgIpmLbBGHtjcrcDIMNERGRBhlLlnQbNLik+2b867slIiLyE7ZLUf42YsM5NkRERB4khMCO3y8hLbPQ4fiNq5VkSUKxRYEQApIkIeDvdt6WgMDAABiNxVAUAYsi7J+rkyWkZVm/nhbvVXMzDDZEREQedDE9H599d0y1rx8ebFDta6uBwYaIiMiD8guLAQChQXrc37yK/bht+bWNLEswmxX7Em39LcyNCQoKQFGRdcRGUYT9c21LugP0Mu5tGu/G78b7MdgQERF5kLkkwESFB7p12bVeLyMqKhRZWfkwl9xJmDh5mIiIyKMsFmvo0P3dnBlyC3aZiIjIg8wW64iNXiepXIl/YLAhIiLyIHPJiI1e5o/c8sAuExEReYgQAj/sPQ+AIzblhcGGiIjIQ05fzsXJSzkAgNDgAJWr8Q8MNkRERB6SV2iy/7lnuzoqVuI/GGyIiIg8pLhkGXZCtUhUigpRuRr/wGBDRETkIaaSYONvG1GqiZ0mIiLyENuIzd/u+0Ruw04TERF5iD3Y+NkO22pisCEiIvIQk9kCgJeiyhM7TURE5CH2ERsGm3LDThMREXkIg035Y6eJiIg8xFRsWxXFOTblhcGGiIjIQ4otHLEpb+w0ERGRhxQXc/JweWOniYiIPMTEOTblTq92AURERFpTUGTG1t8u4GxqLgAGm/LEYENERORm//3fZaz/6ZT947Bgg4rV+BcGGyIiIjez7epdMy4cbZrEoVndGJUr8h9eNTZ2+vRp3HnnnVi3bp392JEjR9CvXz+0aNECHTt2xGeffaZihURERH/Ptsy7ca0oPNy6Bi9FlSOv6XRxcTFef/11FBQU2I9lZWWhf//+qFGjBtauXYshQ4Zg1qxZWLt2rYqVEhER3RxvzKcer7kU9cEHHyAsLMzh2OrVqxEQEIC33noLer0edevWxdmzZ7Fo0SL06tVLpUqJiIhuzrZHFINN+fOKju/duxerVq3C9OnTHY4nJyejdevW0Ouv5a82bdrgzJkzSE9PL+8yiYiIboltxIZ3HC5/qo/Y5OTkYPTo0Rg/fjwqV67s8FhKSgrq16/vcKxSpUoAgMuXL6NixYouf129m1O0Tic7/J/Yk9KwJ87YE2fsiTNf64nZIgAAQYE6t/+8sfG1npQX1YPN5MmTceedd6Jbt25OjxUVFcFgcFwiFxgYCAAwGo0uf01ZlhAVFery599MRESwR87ry9gTZ+yJM/bEGXvizFd6Ikr+XyEy2GM/b2x8pSflRdVgs2HDBiQnJ2Pjxo2lPh4UFASTyeRwzBZoQkJCXP66iiKQk1Pw90+8DTqdjIiIYOTkFMJSsjeIv2NPnLEnztgTZ+yJM1/rSUFhMQCg2GhGVla+R76Gr/WkrCIigm9pdErVYLN27VpkZGTggQcecDg+adIkfPPNN4iPj0daWprDY7aP4+LiyvS1zWbPvAgsFsVj5/ZV7Ikz9sQZe+KMPXHmKz0xluwRJcuSx+v1lZ6UF1WDzaxZs1BUVORwrHPnznj11VfRvXt3fPnll1i5ciUsFgt0OusErN27d6N27dqIieHNjoiIyDtdmzzM+S/lTdWOx8XFoWbNmg7/AUBMTAzi4uLQq1cv5OXlYdy4cThx4gTWrVuHpUuXYsCAAWqWTUREdFNc7q0er+54TEwMEhMTcfr0afTo0QPz58/H6NGj0aNHD7VLIyIi+ktc7q0e1VdF3ejYsWMOHzdr1gyrVq1SqRoiIvIXaVkF+PngZXsouZEsSQCAYosCIYTT45IkQSdbn5NfZAbAERs1eF2wISIiUsMX208i+dgVt51PAhAaHOC289GtYbAhIiICkFNgvb1Is7oxiI92vqWIXDIaYzYrUEoZsZElyf4cWZZQMy4ckaEGp+eRZzHYEBER4dqO3O2aV8Fd9WNVroZcxYt/REREAEy2Cb8B/NHoy/i3R0REBMBUclO9wACuZPJlDDZERETgEm2t4BwbIiLyW0II7Pj9EtIyC+1LtHkpyrcx2BARkd+6eCUfn3137f5pXKLt+xhsiIjIbxUYraM0oUF63N+8CmrFhyMihEu0fRmDDRER+S2LYr0fTWRYIHp3SFC5GnIHXkgkIiK/pZQEG9t2CeT7GGyIiMhv2UZsbHs8ke9jsCEiIr9lH7FhsNEMzrEhIiK/tPN/l7H3SBoAjthoCYMNERH5new8IxZvOmL/OCSIPw61gn+TRETkd3ILigEAAXoZnVtVR9sm8SpXRO7CYENERH6nqGRfqLDgAPRqX1flasidOHmYiIj8TpGpZPsEPX8Mag3/RomIyO8YTdzJW6sYbIiIyO8U2oKNgcFGazjHhoiINOdsSg52/ZFa6h2FFSFwLjUXAIONFjHYEBGR5izedAQXruT/7fMiQ7nhpdYw2BARkeZk5hgBAPc3q4zQ4ACHx2x3Gw7QSehwV7Vyr408i8GGiIg0pdhsQYHRuurpyQ4JCLsh2JC2cfIwERFpSlaudbRGr5MRyjsK+x0GGyIi0hRbsIkIDYBUyuRh0jYGGyIi0pTMkmBTITRQ5UpIDRyjIyIin2S2KNi67wKy80wOx09cygYARIUz2PgjBhsiIvJJh05nYtW2E3/5eFx0SDlWQ96CwYaIiHxSboF1pCa2QhDublDJftxiURAYoEPn1jXUKo1UxGBDREQ+qdisAABqxIWjd4cElashb8HJw0RE5JNMxdZgwx266Xp8NRARkU8yma0bWRq4Qzddh8GGiIh80rURGwYbuoZzbIiIqNwoisDmX88hM7cIQvz182w31hMlT5IkCYGBehiNZvuxExesy7oNAfwdna5hsCEionLz+8l0rNl+0q3n5F5QdD0GGyIiKjenLuUAACrHhKBRzai/fJ5cMmKjlIzOyLKEwMAAGI3F9t25ZUlCeKgB9zer7OGqyZcw2BARUbk5n5YHAGjTOB7d7qt1y5+n18uIigpFVlY+zCXLvIlKwwuTRERUbi5n5AMAasaHq1wJaRWDDRERlQuzRUFGtnWDyqoVQ1WuhrSKwYaIiMpFamYBFCFgCJARHcENKskzOMeGiPxSenYhfvr9EgqNFvvy4dJIkoQAnfV3wGKLAiGE01Lk65974/HrPx+wToZVFAFZvmFyrCTBogj7+UOCA1BkNMNicZ5PYjvn9Z97Y30BOtnp4xu/nu3Ptq8LwF6bJEnQldT4V88t7Xu+/uMbH0vPLgIAxFUItj9G5G4MNkTklzbuPIOfD15Wuwy/VIPza8iDGGyIyC8VGM0AgIY1KqDKTeZ7yJIEfcleRGazAkUIp6XI1z/3xuPXfz5gHRG5/hzXj3TYH5MlBAcbYCwqhrmUERvbOe3LnktGVq6vT6+XnT62fX3b59j+bPu6ttplSbL+Zxux+YvnlvY9X/9xaY8F6GU82LL6X/abqKwYbIjIL1ks1h+2bZrEo13zKipX44hLm4lcx8nDROSXLIrjCAMRaQODDRH5JUWxjoTodAw2RFrCYENEfsk2YmNb+UNE2sBgQ0R+icGGSJsYbIjIL1luWFFERNrAYENEfunaiA3fBom0hP+iicgv2ZZ781IUkbYw2BCRX7LdNI7BhkhbGGyIyC/Z9mDicm8ibWGwISK/xMnDRNrELRWISJN+PngJ51Lz/nIH7tyCYgCAnpOHiTSFwYaINCc1qwCffHP0lp4boOeIDZGWMNgQkebk5ltHY4ID9WjbJM7hset3nK5SMRRVKoaVe31E5DmqB5uMjAxMnz4dP//8M4xGI1q1aoU33ngDdevWBQAcOXIEU6dOxaFDhxAdHY3nn38ezz77rMpVE5E3MxZbAAAxEUHo17mBytUQUXly68XlK1eu4I8//oDFYrnlzxkyZAjOnj2LRYsW4YsvvkBQUBCef/55FBYWIisrC/3790eNGjWwdu1aDBkyBLNmzcLatWvdWTYRaUyRyfoeFGTQqVwJEZU3l0ds8vLyMHXqVDRt2hR9+/bFt99+i1GjRsFisaBWrVpYsmQJKleufNNzZGdno2rVqhgwYADq168PABg8eDD++c9/4vjx49i1axcCAgLw1ltvQa/Xo27duvYQ1KtXL1dLJyKNM5WM2AQGcGIwkb9x+V/97NmzsXnzZkRGRgIAZs2ahYYNG2L+/PnQ6/WYNWvW354jMjISs2fPtoeazMxMLF26FPHx8UhISEBycjJat24Nvf5a/mrTpg3OnDmD9PR0V0snIo0rsgUbg+pX24monLn8r37r1q0YM2YMunbtikOHDuHixYsYPXo0OnXqBLPZjEmTJt3W+SZMmIDVq1fDYDDgP//5D0JCQpCSkmIPPTaVKlUCAFy+fBkVK1Z0tXzo9e79TU6nkx3+T+xJadgTZ57oSbHZevO9IIPO7f/WywNfJ87YE2fsSelcDjZXr15FnTp1AAA7duyAXq/HfffdB8A6EmM0Gm/rfM899xyeeuopJCUlYciQIVi+fDmKiopgMBgcnhcYGAgAt33+68myhKioUJc//2YiIoI9cl5fxp44Y0+cubMn5pJb11SICPLYv/XywNeJM/bEGXviyOVgU7VqVRw7dgwtW7bEli1b0KJFC4SFWZdN7tixA9WqVbut8yUkJAAApk6dit9//x3Lli1DUFAQTCaTw/NsgSYkJMTV0qEoAjk5BS5/fml0OhkREcHIySm036rd37EnztgTZ57oyZ9nMwEAsZFByMrKd8s5yxNfJ87YE2f+1pOIiOBbGp1yOdj06dMH06dPR1JSEk6dOoU5c+YAAIYOHYqtW7di/Pjxf3uOzMxM7Nq1Cw8//LB9Ho0sy0hISEBaWhri4+ORlpbm8Dm2j+Pi4pzOdzvMZs+8CCwWxWPn9lXsiTP2xJm7eiKEwOnLOQCAarGhPt1nvk6csSfO2BNHLl+Ye+655/Duu++iVatWmDNnDh577DEAQEBAACZPnoy+ffv+7TnS09MxYsQI7Nq1y36suLgYhw8fRt26ddGqVSvs27fPYfn47t27Ubt2bcTExLhaOhFpWFauEbkFxZAlCdVjefM9In9TpiUDXbt2RdeuXR2OzZ0795Y/v379+mjXrh3eeecdvPPOO4iMjMTChQuRk5OD559/HoGBgUhMTMS4cePw0ksv4eDBg1i6dCmmTJlSlrKJSMPOpuQCAKpUDIEhgPexIfI3ZQo2p0+fxo4dO1BQUABFcRwGkyQJQ4YM+dtzzJkzB7Nnz8Zrr72G3NxctGzZEklJSahSpQoAIDExEVOnTkWPHj0QGxuL0aNHo0ePHmUpm4g07GyqNdjUjA9XuRIiUoMkbtz69hZ9+eWXGDNmjNPOufYTSxKOHDlSpuI8xWJRkJnp3gmFer2MqKhQZGXl81pnCfbEGXviTK+Xse94Bv48mwmhWN9PlJL3Fdu+TgBQbFFK3albJ0v25ypC4ODJDKRkFqDvQ/XR6e7bW8TgLfg6ccaeOPO3nkRHh3p28vBHH32Ee++9F++88w7i4+MhSdwhl4huX1pWAeat2u/289auHOH2cxKR93M52Fy6dAmTJ0/+220TiIhuJr/IDMB6M70H7qwKwHpLBsB6zykbs1mxj+TYyJJkf44sS1AUASEE4qJDULsyL0UR+SOXg03t2rVx+fJld9ZCRH7IYrGGlfAQA3p3SFC5GiLydS4v9x45ciQ++ugj7Nmzp0x3ASYi/2YuubGYXsfL2URUdi6P2EydOhUZGRl4/vnnS31ckiQcPnzY1dMTkZ+wlFx20skMNkRUdi4Hm+7du7uzDiLyU5aSW0VwIz8icgeXg83QoUPdWQcR+SnbHBteiiIidyjTDfpMJhPWrl2LX3/9FTk5OYiKikLLli3x+OOPIygoyF01EpGG2ebY6GSO2BBR2bkcbHJycvDss8/i6NGjqFKlCmJjY3H69Gl8/fXXSEpKwvLlyxEezuWWRHRznGNDRO7k8q9Is2fPRkpKCpYtW4Zt27Zh1apV2LZtG5YtW4aMjAzMmzfPnXUSkUbZLkXpeCmKiNzA5WCzdetWDB8+HC1btnQ43rJlS7z66qv4/vvvy1wcEWmfWbEt9+alKCIqO5ffSfLz81G9evVSH6tevTquXr3q6qmJyI/YR2x4KYqI3MDlYFOnTh38+OOPpT72448/ombNmi4XRUT+w8zl3kTkRi5PHn7xxRcxcuRIWCwWdOnSBRUrVkR6ejq+/vprrF69GpMmTXJnnUTkRQqNZmzddwF5hcUArHs2lbb7dmkkSULAdSHmbGouAEDPERsicgOXg81jjz2GM2fOYMGCBVi5ciUAQAgBg8GAwYMH46mnnnJbkUTkXX45lIJ1P51y6zlDgwPcej4i8k9luo/N4MGD0a9fP+zfvx85OTmIjIxE8+bNERkZ6a76iMgL5RaYAADVK4WhUc0oyLJU6u7bpZElCXr9tREbWZYQERaENo1iPVYvEfmPMgUbAIiIiED79u3dUQsR+Yhis3VeTKOaUejTqV6ZzqXXy4iKCkVWVj7MJeclInLVbQWbRo0aYdWqVWjWrBkaNmwISfrra+LcBJNIu0zF1gBiCNCpXAkRkaPbCjZDhgxBXFyc/c83CzZEpF1GswUAYNBzJRMReZfbCjbXb3w5bNiwmz43JSXFtYqIyOvZLkVxxIaIvI3Lc2yuvyx1o+TkZLz88svYv39/mYoj8mU5BSZs23cBRSbr6IYsSbAIgYAAHYqLLdCVskTaNgr6d8duPH79EmrbBF655HFFCCiKgCxLsCii1PME6GR7LTd+XJpTl7IBcMSGiLzPbQWbJUuWoKCgAID1zXTNmjX46aefnJ63f/9+GAwG91RI5KO+//U8vtl9Vu0yPCo8hEu0ici73FawMRqNmD9/PgDrb3lr1qxxeo4sywgPD8egQYPcUyGRj7qUng8AaFI7GlUrhkKWJSiKQIBBj2KTudQl0tePstzs2I3Hr19CrZTsli2X3PBOUYT9ObY/33gevV6213Ljx6WRJQnREUFoVreia80hIvKQ2wo2gwYNsgeWhg0bYtWqVWjevLlHCiPydWlXCwEAD7eujqa1YwBwaTMRkae5fIH86NGjqF27tsOlqIsXLyIpKQl5eXluKY7IVylC4EpJsKkUFaJyNURE/sPlYHPq1Cl06dIFkydPth87d+4c3n33XfTs2ROXLl1yR31EPulqrhHFZgU6WUJMRKDa5RAR+Q2Xg817772HuLg4rFixwn6sbdu22LFjBypUqID33nvPLQUS+aK0LOtoTcXIIOhkrhwiIiovLi/3/u233zBz5kz7DftsYmJiMHDgQIwdO7bMxRH5AouiYPOv55GTb7JP6L2Qbr0cW7FCsJqlERH5HZeDjSRJKCwsLPUxs9mM4uJil4si8iVHz17FF9tPlvpYxYigcq6GiMi/uRxsWrVqhQ8//BCtW7dGdHS0/fjVq1exYMECtG7d2i0FEnm73ELrTtcVwgxo0yQegHWJdYBeRoc7q6pZGhGR33E52IwcORK9e/dGp06d0KJFC0RHRyMrKwsHDhyAwWDA7Nmz3Vknkdey3Vk4LjoEvTskqFwNEZF/c3lWY+3atfH111+jT58+KCgowKFDh5CTk4PevXtjw4YNqF27tjvrJPJaJhM3hCQi8hYuj9gAQFxcHN544w131ULkk4zFJRtC6rkhJBGR2soUbFJTU7Fv3z6YTCb7MUVRUFhYiOTkZMydO7fMBRJ5O1OxdcQmIIAjNkREanM52Hz33Xd4/fXXYTabnXYZBoA6deq4p0IiL3fwVAYAIDCAIzZERGpz+VfMBQsWoEmTJli3bh169uyJf/7zn9i0aRNGjRoFnU7H+9iQXxBC4Hya9Z41QQYGGyIitbk8YnP69GnMnj0bjRs3xj333IMlS5agbt26qFu3LtLT07FgwQLcd9997qyVyOuYrtvIstNd1VSshIiIgDKM2MiyjMjISABAzZo1cerUKSiK9U2+Xbt2OHHihHsqJPJiBUVmAIAkATGRvBkfEZHaXA42derUwW+//Wb/s8lkwtGjRwEAOTk5DhOKibSqwGgNNkEGnX1+GRERqcflS1F9+vTBpEmTUFBQgNdeew1t2rTBm2++iSeeeALLli1DkyZN3FknkVcqLAk2nDhMROQdXB6xefLJJzFu3Dj7yMzbb78No9GIqVOnwmw2Y9y4cW4rkshb2S5FBRnKdOcEIiJyE5ffjXft2oVevXohKMg6r6B69er49ttvkZWV5bB3FJHW/O9UBv44nQmzRUFqVgEAICSQwYaIyBu4PGIzbNgwfP/99w7HJEliqCFNU4TAR+sP4fu957Htt4v443QWACAiNEDlyoiICCjDiE1ERIR9tIbIXxhNFhhL7jTc4c4qkCQJOllGp5Zc6k1E5A1cDjYDBgzAO++8g9OnT6Nhw4YICQlxek6rVq3KVByRt7Ht5C1LEvp1bsCVUEREXsblYDNp0iQAsO8Hdf0bvG1rhSNHjpSxPCLvUmSyThYODuTybiIib+RysPnss8/cWQeRTyg0WkdsuAqKiMg7ufzu3Lp1a3fWQeQTbCM2QYG8bw0RkTcq06+dmZmZWLx4MX755RdcuXIFiYmJ2LJlCxo2bIgHH3zQXTUSeQUhBL779RwAIIg35CMi8kouL/c+f/48unfvjtWrVyMuLg4ZGRmwWCw4ffo0Xn31VWzfvt2NZRKp7+KVfBw6lQkACAnipSgiIm/k8rvzjBkzEBMTg88//xwhISFo2rQpAGD27NkwGo1YsGABHnjgAXfVSaQ6275QANC7Y4KKlRAR0V9xecRm165dGDx4MCIiIpxWhzz11FM4fvx4mYsj8iZCCABAfHQIqlYMU7kaIiIqjcvBBgD0+tIHfEwmE5fCkuaU5BrwpU1E5L1cDjYtW7bEwoULUVBQYD8mSRIURcGKFStw1113uaVAIm9hG7GRmWyIiLyWy3NsRo4ciaeffhqdO3fGPffcA0mSsHjxYpw8eRJnz57F8uXL3VknkeqUkv8z1xAReS+XR2zq16+PL774Avfccw/27NkDnU6HX375BTVq1MDKlSvRqFEjd9ZJpDrbiA0vsxIRea8yrVmtXbs2Zs+eXepjKSkpiI+PL8vpibwK59gQEXk/l0dsGjVqhIMHD5b6WHJyMh599FGXiyLyRhyxISLyfrc1YrNkyRL7ZGEhBNasWYOffvrJ6Xn79++HwWC4pXNevXoVc+bMwfbt25GXl4cGDRpg5MiRaNmyJQDrsvKZM2fi5MmTqFy5MoYNG4YuXbrcTtlEbqGUjNjIzDVERF7rtoKN0WjE/PnzAVh/a12zZo3Tc2RZRnh4OAYNGnRL5xwxYgSuXLmCOXPm2G/49+KLL2L9+vUQQmDAgAHo378/Zs6cie3bt2P06NGIjo5G27Ztb6d0ojLjiA0Rkfe7rWAzaNAge2Bp2LAhVq9ejWbNmrn8xc+ePYudO3di+fLluPvuuwEAEyZMwM8//4yNGzciIyMDDRo0wGuvvQYAqFu3Lg4fPozExEQGGyp3nGNDROT9XJ5jc/To0TKFGgCIiorCokWLcMcdd9iPSZIESZKQk5OD5ORkpwDTpk0b7Nu3z/7bM1F54YgNEZH3K9OqqJ07d+LHH39EYWEhFEVxeEySJEybNu2mnx8REYH27ds7HNu8eTPOnj2LsWPHYv369U4rqypVqoTCwkJkZWUhOjra5dr1+jLddNmJTic7/J+015Pdh1MBADpJcvn1o7WeuAN74ow9ccaeOGNPSudysFmyZAnee+89BAYGIjo62um3WFd+q/3tt9/w5ptvonPnznjggQdQVFTkNAnZ9rHJZHK1dMiyhKioUJc//2YiIoI9cl5fpoWeZGQXYt+xKwCAiPDAMr9+tNATd2NPnLEnztgTZ+yJI5eDzbJly9CtWzdMnTr1lldA3cyWLVvw+uuv46677sKsWbMAAIGBgU4BxvZxcLDrf5GKIpCTU/D3T7wNOp2MiIhg5OQUwmJR/v4T/ICWenL83FX7n3u2q4OsrHyXzqOlnrgLe+KMPXHGnjjzt55ERATf0uiUy8EmPT0dTzzxhFtCzbJlyzB16lQ88sgjmDFjhv2clStXRlpamsNz09LSEBISgvDw8DJ9TbPZMy8Ci0Xx2Ll9lRZ6kpFdCACoXy0ScRWCy/z9aKEn7saeOGNPnLEnztgTRy5fmGvcuDGOHz9e5gKWL1+Ot99+G3379sWcOXMcglLLli3x66+/Ojx/9+7duOuuuyDLvKZI5edqrhEAUCE8UOVKiIjoZlwesRk7diyGDx+OkJAQNG/evNRLQ1WqVLnpOU6fPo1p06bhoYcewoABA5Cenm5/LCgoCM888wx69OiBWbNmoUePHtixYwe+++47JCYmulo2kUuy8kqCTRiDDRGRN3M52Dz99NNQFAVjx479y4nCR44cuek5Nm/ejOLiYvzwww/44YcfHB7r0aMHpk+fjo8++ggzZ87Ep59+imrVqmHmzJm8hw2Vu6ySEZsojtgQEXk1l4PN22+/Xeb7eQwcOBADBw686XPatWuHdu3alenrEN2qnAITtiZfgLHYYj9mUQSOX8gGwGBDROTtXA42PXv2dGcdRF5h274L2PjLmb98PCqs7JPliYjIc24r2DRs2PCWR2kkScLhw4ddKopILQVGMwCgduVw1KtWAYD19gCKEKhUIRgJJceIiMg73VawGTJkCG8nT5qmlGzh3bR2DHq0q6NyNUREdLtuK9gMGzbMU3UQeQVbsNHJDPBERL6IN4Mhuo6lJNjIDDZERD6JwYboOhyxISLybWXa3ZvIVwghsHXfBaRkWvcI08kydLKEYosCIQQkSUKATsapyzkAOGJDROSrGGzIL5xPy8PyLbe+BUhIIP9pEBH5Ir57k1/ILSwGAIQE6dGmcRz0OhmyLMFsVqAIAVmSoNfLUBSBsOAAtGpUSeWKiYjIFQw25BdMJXcSjgoLRL/ODVSuhoiIPIWTh8kvFJsVAECAni95IiIt47s8+QWjyTpiYwjgS56ISMv4Lk9+wbapZYBep3IlRETkSZxjQ5p2/MJV7D2ShtMly7gNvBRFRKRpDDakaR9vPIz07CL7x+Eh3J2biEjLGGxI02y7dd/TuBKiw4PwYMvqKldERESexGBDmma2WFdDPX5/HcRFhahcDREReRonHJCmmS3WvZ8CdHypExH5A77bk2YpirBvamkI4GooIiJ/wGBDmmW7KR/AERsiIn/Bd3vSrGLLtWCj13O3biIif8BgQ5pl2x9KliToZL7UiYj8Ad/tSbMKiqxLvYMCOb+GiMhfMNiQZuUXFQMAgg28qwERkb9gsCHNyiu0jtiEBDHYEBH5CwYb0qy8QhMAICSQwYaIyF8w2JBm5RZYL0WFBgeoXAkREZUXBhvSrGvBhiM2RET+gsGGNKugZPJwWBBHbIiI/AWDDWmW7QZ9ej1f5kRE/oLv+KRZlpJ9ovS8OR8Rkd/gOz5plsU2YqPjdgpERP6CwYY0yzZio+MGmEREfoPv+KRZ9ktRHLEhIvIbDDakWRaLLdjwZU5E5C/4jk+aZVE4x4aIyN8w2JBmXbsUxZc5EZG/4Ds+aZZ98rDMERsiIn/BYEOaZZtjo+N9bIiI/Abf8Umzri335ogNEZG/YLAhzVJ4KYqIyO9w22PSjMycIuw4cAnFZgWKEMgtMAFgsCEi8icMNqQZ3+4+h62/XXA6HsrdvYmI/AaDDWlGflExAKBhjQqoERcOAYH4qBBUjQ1VuTIiIiovDDakGeaSTS/vblAJne6upnI1RESkBk4eJs0wlyzvDtDzZU1E5K/4E4A0w1yyhQInCxMR+S8GG9IMs9m2NxRf1kRE/opzbMgnJR9Nw6lLOSi2KBDCegkqJbMAADe9JCLyZww25HMKioqx4Ms/oJQEmhtxeTcRkf9isCGfk5VngiIEDAEy2jWrYg84siQhNioY9atXULdAIiJSDYMN+Zy8kjsKR4UH4V8P1Ve5GiIi8iacZUk+J7fAeiO+8BBeciIiIkcMNuRzcgtLgk0wgw0RETlisCGfY9vckiM2RER0I86xIZ9QbFbw3Z6zyM434eTFHABAeIhB5aqIiMjbMNiQT9h3LA3rfz7tcCw6PFClaoiIyFsx2JBPSMmy3nwvLjoEzepEIyLUgDZN4lWuioiIvI1XzbFZuHAhnnnmGYdjR44cQb9+/dCiRQt07NgRn332mUrVkZqycowAgDvqROPpB+ujS9taCA5kLiciIkdeE2ySkpLw/vvvOxzLyspC//79UaNGDaxduxZDhgzBrFmzsHbtWnWKJNVczbMGm5iIIJUrISIib6b6r7ypqamYNGkS9uzZg1q1ajk8tnr1agQEBOCtt96CXq9H3bp1cfbsWSxatAi9evVSp2BSRXa+dSUU59UQEdHNqD5i88cffyAgIABfffUVmjdv7vBYcnIyWrduDb3+Wv5q06YNzpw5g/T09PIulVSUUxJsKjDYEBHRTag+YtOxY0d07Nix1MdSUlJQv77jLfMrVaoEALh8+TIqVqzo8tfV692b6XQ62eH/ZO3FHyfT8dP+C7DtV2m2KFAU6wcSrv09KIqALEuQpGs7cwshYFEEFEXY7zYcExnk9r+78sTXiTP2xBl74ow9ccaelE71YHMzRUVFMBgc71USGGj9jd1oNLp8XlmWEBUVWqba/kpERLBHzuurZszZgaxc1/+urqfXSahVPRqBATq3nE9NfJ04Y0+csSfO2BNn7Ikjrw42QUFBMJlMDsdsgSYkJMTl8yqKQE5OQZlqu5FOJyMiIhg5OYWwWBS3nttXGYst9lDzaJsakCQJZrNi340bAPQlv2koQkCWJMjytREbpWS0xvb8xrWiUZBXBPf+zZUvvk6csSfO2BNn7Ikzf+tJRETwLY1OeXWwiY+PR1pamsMx28dxcXFlOrfZ7JkXgcWieOzcvuZCWh4A69YHTz6Q4JZzaqW3fJ04Y0+csSfO2BNn7Ikjr74w16pVK+zbtw8Wi8V+bPfu3ahduzZiYmJUrIxuxaX0fABAbAUOkxIRUfnw6mDTq1cv5OXlYdy4cThx4gTWrVuHpUuXYsCAAWqXRrfgfMmITeUY1y8bEhER3Q6vDjYxMTFITEzE6dOn0aNHD8yfPx+jR49Gjx491C6NboFtxKZabJjKlRARkb/wqjk206dPdzrWrFkzrFq1SoVqqCx2/5GCgyczAADV4xhsiIiofHj1iA35przCYnz89WH7x1UrMtgQEVH5YLAht8svKrbfkO+1p+9ETCT3dyIiovLBYENuZyq2LjsMCw5Ax5Y1VK6GiIj8CYMNuZ2x2Lo8P8CHtz4gIiLfxJ885HYmBhsiIlIJf/KQ29kuRRkYbIiIqJx51XJv8g6/n0jHodOZECUzgCVJQoBOtu/ZJJfswF1sUZyeAwApmdbdnAwa2KySiIh8C4MNOVAUgY82HEKxG/YdCQ8JcENFREREt47BhhxYFGEPNe2aV4ZeJ0OWJOj1MhSlZMSmZAfu63fqtj3HRgLQ4e5q5Vs8ERH5PQYbcmC7tAQAT3Wsh+BA118ies6xISKicsafPORAXPdn21waIiIiX8FgQw6uH7EBcw0REfkYBhtycH2ukRlsiIjIx3COjZ85fCYTv/15BYB1ibZOlqyTgiXrpSez5dpqKImXooiIyMcw2PiZjzYcQkGR+W+fZ9DLnGNDREQ+h8HGjxQUFdtDTYc7q0InS5BlCYoQkOA4QtO4VpR9WTcREZGvYLDxIxk5RgBASKAezzzcQOVqiIiI3I+Th/1IRnYRAKBCmEHlSoiIiDyDwcaPpGVZ93CKjghSuRIiIiLPYLDxI2lXCwEAMZEMNkREpE0MNn7kp98vAQAqVQhWuRIiIiLPYLDxE5k5RTBbrHffqxobqnI1REREnsFg4ydyC4rtf25aO0bFSoiIiDyHwcZPFJms96+JiQjk/WmIiEizGGz8hLHYulWCIUCnciVERESew2DjJ4zFFgBAIIMNERFpGIONnyg0Wi9FccSGiIi0jFsq+IADx9Px5/mrDseKLQqEsK5ysu3xdP3HATprZlVKjp1LzQUABDHYEBGRhjHYeLlis4KPNhyC2aK45XwR3E6BiIg0jMHGyxWazPZQ80jrGkDJgiazWbGPxsglIzbXf6zXl4zYKMJ+Lp0sodPd1cqrdCIionLHYOPlTCbrpN8AvYzeHRNUroaIiMi7cfKwlzOaraM1XM1ERET09xhsvJypZJm2IYB/VURERH+HPy29nNHE+88QERHdKs6x8ZD0q4X46eAlmIqtk3yvn+ArS5L9Y9sxwDrpVxECiiIgyxIsikD61UIAgF7HDEpERPR3GGw85KtfzuC/By+77XwGvYxiswUBeo7cEBER/RUGGw8pLLLe6bdRzShUiw11uImeJEkOG1HalmTLsgRFEfZRHfufZQltGscx1BAREf0NBhsPsZSElXsax6Fd8yoqV0NEROQfOHHDQ8yKdZm27rqRGSIiIvIsBhsPsV1eYrAhIiIqPww2HmKxXJs3Q0REROWDwcYDCorMOFayG7dOZouJiIjKC3/qesD2Axftfw4J4vxsIiKi8sJg4wGZOUUAgACdjAbVK6hbDBERkR9hsPGA/JJ72Dx8T3XOsSEiIipHDDYeUFBUDAAICwpQuRIiIiL/wmDjAQUlIzbhIQw2RERE5YnBxgMKjdZgE8IRGyIionLFYOMBhSYLACCUwYaIiKhcMdh4QJHJOmITzKXeRERE5YrBxs2EECiyj9gw2BAREZUnBhs3KzJZIKy7KSAkkMGGiIioPDHYuJntHjY6WUKAnu0lIiIqT/zJ62a2e9gEGXSQJN6cj4iIqDwx2LiZ7R42QQZehiIiIipv/OnrJhfT8/HFjlM4ezkbABAcqFO5IiIiIv/DYOMmX/x4AvuOXbF/HBkWqGI1RERE/onBxk2e7JCAanHhyC8wQZYkPNCiitolERER+R2fCDaKomD+/PlYs2YNcnNz0apVK0ycOBHVq1dXuzS7KhVD8dI/70BWVj7MZkXtcoiIiPyST0we/uijj7B8+XK8/fbbWLlyJRRFwUsvvQSTyaR2aURERORFvD7YmEwmLFmyBK+++ioeeOABNGzYEHPnzkVKSgq+//57tcsjIiIiL+L1webo0aPIz89H27Zt7cciIiLQuHFj7N27V8XKiIiIyNt4/RyblJQUAEDlypUdjleqVMn+mCv0br4rsE4nO/yf2JPSsCfO2BNn7Ikz9sQZe1I6rw82hYWFAACDweBwPDAwENnZ2S6dU5YlREWFlrm20kREBHvkvL6MPXHGnjhjT5yxJ87YE2fsiSOvDzZBQUEArHNtbH8GAKPRiOBg1/4yFUUgJ6fALfXZ6HQyIiKCkZNTCIuFq6IA9qQ07Ikz9sQZe+KMPXHmbz2JiAi+pdEprw82tktQaWlpqFGjhv14WloaGjRo4PJ5PbUk22JRuNz7BuyJM/bEGXvijD1xxp44Y08cef2FuYYNGyIsLAx79uyxH8vJycHhw4fRqlUrFSsjIiIib+P1IzYGgwH9+vXDrFmzEB0djapVq2LmzJmIj49H586d1S6PiIiIvIjXBxsAePXVV2E2mzF+/HgUFRWhVatWWLx4MQICAtQujYiIiLyITwQbnU6HUaNGYdSoUWqXQkRERF7M6+fYEBEREd0qBhsiIiLSDEkIIdQuorwJIaAo7v+2dTrZL+4lcDvYE2fsiTP2xBl74ow9ceZPPZFlCZIk/e3z/DLYEBERkTbxUhQRERFpBoMNERERaQaDDREREWkGgw0RERFpBoMNERERaQaDDREREWkGgw0RERFpBoMNERERaQaDDREREWkGgw0RERFpBoMNERERaQaDDREREWkGgw0RERFpBoMNERERaQaDDRGRDxJCqF2C12FPSudvfdGrXYCv+uWXX1BQUABFUXDvvfciLCxM7ZJ8ghACkiTZP1YUBbLMfF0a9qZ07IvV9f+OyIo9IQCQhL9FOTeYMWMGvvrqK1SoUAFnz55F8+bN0bVrVzz99NNql+bVVq5ciT/++ANmsxkJCQl48cUX1S7J62RnZ6O4uBgVK1a0H7sxDPoj9uWadevW4fTp00hPT0eXLl3QvHlzhIeHq12WqtiT0iUlJeHPP//EhQsX0K1bN7Ro0QK1atVSuyyPY7C5Tdu3b8fkyZPxwQcfoHbt2igoKMBbb72Fixcv4t5778WoUaPULtErzZ07F6tWrcJjjz2Gixcv4uTJk4iIiMDs2bNRu3ZttcvzCvPnz8e2bdtw5coVVKlSBU8//TTat2+PqKgovx6lYF+umTVrFtauXYs777wThYWF+PXXX9GzZ0/07NkTd955p9rlqYI9KZ3tPffBBx9Efn4+fvnlF9x1113o1asXHnzwQbXL8yxBt2XFihXi8ccfF0aj0X4sIyNDTJ06VXTr1k3MnTtXveK81IULF8Sjjz4qtm/fLoQQQlEUcejQIdGzZ0/RqVMncfDgQZUrVN+SJUtEmzZtxNq1a8X27dvF0KFDRdeuXcWYMWNESkqKEEIIi8WicpXlj3255vDhw6Jz587iwIED9mNffvmlePTRR8WAAQPEL7/8omJ16mBPSnfmzBnRvXt3sXv3bvux7du3ixdeeEH07NlTfP311ypW53n+86tOGYmSga2AgACYTCbk5OQAAMxmM6KjozFkyBC0bt0aP//8M7766is1S/U6hYWFyMrKQrVq1QBYr4M3adIEH3/8MSpVqoTXX38dKSkpAKzzJ/yJEAImkwm//vorXn75ZfTs2RPt27fHBx98gG7duuHYsWOYOnUqUlNTIcuy30wCZF+cSZKEwsJC6PXXpkZ2794db7zxBq5cuYKkpCQcOnRIxQrLH3tSOp1OhytXrsBoNNqPtW/fHsOGDUN8fDw+//xz7NixQ8UKPYvB5hbZruW3atUK58+fx+effw4A0Ov1MJvNiIyMxKBBgxAWFsZgU8L2w6ZGjRoIDg7Gxo0b7Y8pioLo6GjMmzcPQUFBGD58OAD41WUFwPq6MhgMKCwsRGpqKgDAYrEAAF555RX07NkTFy9exIIFC5CTk+M3c0rYF2dmsxlGoxFZWVkAAJPJBMD6A2vo0KE4duwYNm7cCIvF4hdBD2BPSiOEgKIoCAkJweXLlwEAxcXFAIAWLVrgxRdfhMFgwIYNG5Cenq5mqR7jXz9F3KBGjRoYO3YsFi5ciBUrVgC4Fm5iYmLw5ptvYteuXfjjjz9UrlR9th82Op0OjzzyCHbu3IktW7YAgP237NjYWEyYMAGZmZn4/vvv1SxXFUIICCFQqVIl7N27F3l5edDpdPY36H79+qFDhw7YvXs3Dhw4AMA/RrXYF2dNmzbFP/7xD4wePRqpqakwGAz2H1gdOnTAwIEDsWzZMvz5559+EfQA9uR6tuAmSRJq1KiBTp06YcaMGTh27BgCAgLsfbnrrrvw/PPPY9u2bThx4oSaJXsMg40LevTogZdffhlTpkxBUlISADgMhVavXh0RERFqlae6FStW4O2338aAAQPwzTffIDs7G/3794dOp8OyZcuwc+dOANeCT8OGDaEoCs6fP69m2eUqIyMD2dnZyM3NhSRJGDVqFFJTUzFx4kQAgMFgsP8QHzp0KCpWrIjVq1cD0PaoFvtyzYYNGzBnzhzMnDkTmzZtAgCMHDkS1apVw6BBg5Cammq/NA4AvXr1QrVq1fDbb7+pWbZHsSelW7lyJSZOnIg333wTixYtAgCMGDECd999N5577jmcP3/eIdx07NgRderUwe7du9Us22O09U5QTgIDAzFw4EAMGDAA77zzDt577z38+eefSE1NxXfffQcACAkJUblKdcyZMwfz5s1DQUEBdDodJk+ejPHjxyM1NRWzZ8/GlStXsGjRInz77bf2zwkLC0P16tX9pmfz58/H0KFD0bVrV/z73//G6tWrERsbi0mTJuHHH3/EmDFjAFh/iNtGIVq3bo38/Hw1y/Y49uWa2bNnY/r06bh48SJ++eUXzJs3D6+88gqio6MxfPhwyLKMV155BSkpKTAYDACsc9mCg4MRGRmpcvWewZ6Ubu7cuXj//fcREBCAzMxMrF692n6pduTIkahXrx6efPJJHDp0CAEBAQCsl/ACAwNRqVIllav3EBUmLGuG0WgUX331lWjbtq1o166dePDBB0X79u3FH3/8oXZpqjh58qTo2rWr2Lt3r/3YDz/8IJ599lnRo0cP8dtvv4kLFy6Ifv36iccff1xMmjRJbNy4UUyePFm0atVKnD17VsXqy8fHH38s2rRpIzZt2iSWLVsmpk6dKho0aCDee+89kZKSItauXStatGghhg0bJrKysoTZbBZCCPHGG2+I4cOHC7PZLBRFUfm7cD/25Zrjx4+Lhx56yL6ix2g0is2bN4sOHTqIp556SqSnp4s9e/aIJ598UrRs2VKsX79ebNq0ScyaNUvcd9994vz58yp/B+7HnpTur1ac9ujRQ3Tu3Fn8/vvv4vjx42LAgAGiWbNm4qOPPhKffvqpePfdd8U999wjzpw5o/J34Bm883AZGAwGdOvWDa1bt8a5c+dgNptRp04dxMXFqV2aKnQ6HdLT0+3DnQDw4IMPokKFCkhMTMT06dMxZcoUzJs3D19++SU2bNiA/fv3IywsDJ999hlq1KihYvWeJ4TAwYMH0b9/fzz22GMAgKKiIjRu3Bjjx4+H0WjE4MGDER0djfHjx+OZZ55BbGwsQkND8csvv2DFihXQ6XQqfxfux744ysnJQV5eHurUqQPA+j7TqVMnVK5cGaNGjcLQoUORlJSExMREvP/++/jggw+g1+sRHh6ORYsW2Vcfagl7Urq/WnGamJiIwYMHY8yYMViyZAkWLFiA+fPnY8eOHcjNzUXFihXxySefoGbNmip/Bx6idrIibVAURZw6dUp07NhRrF27VgghhMlksj++Z88e0bdvXzFixAhRUFBgP56Xl+fwsZYVFhaKRx55RMyZM8fpse+//140adJEzJs3TwghRG5urpg7d66YMGGCePfdd8WJEyfKu9xyw75Y2e7Hk5qaKh544AGxcuVKp+ccOHBAdOjQQQwbNsx+7NKlSyI7O1tkZ2eXW63lhT0pnW100mg0ig4dOjjcP83Ws7S0NNG1a1fx1FNP2R+7evWqKCoqEnl5eeVab3ljsCG3mjRpkmjZsqU4deqUEEI43Mjw22+/Fc2aNRPJyclqlaeK6y+RzJkzR3Tp0kUcPXrU6XmrV68WjRo1Eps2bfrLz9cS9qV0ubm5YtiwYeL5558X//vf/xweMxqNYv369aJr165i//79Qgj/uEEhe1I6s9ksZsyYIZ544gnxww8/2I/b/m3s3btXPPTQQ+Lbb78VQvhPXzh5mFy2evVqTJo0CRMnTsQnn3wCABg9ejSaNGmCZ555xmn55SOPPIIaNWpg165dapZdrnJzc+332ACA+++/H3q9HmvWrMGlS5fsx4UQePTRR/HYY49h9+7dMJvN9vu2aBH7cs2GDRswb948TJw4EXv27EFYWBiGDx+O48ePY8GCBTh58qT9uQaDAffffz9SUlLsx7W2GgxgT/6KqytOL168CEC7fbmRf3yX5HZz587FnDlzIITApUuX8Nlnn6FPnz7IyMjA6NGjUa1aNfTq1Qt//vmnfSa+yWRCSEiIdmfi32D+/Pl44YUX8Pjjj6Nfv3745ptvcPfdd6Nv3774/vvvsXz5cvsbjiRJCAsLQ1hYGE6fPg29Xm+fN6K1+2+wL9fMnDkTM2bMwOHDh3Hq1Cm88MILmDRpEsLCwpCYmIiff/4Zc+bMwf79++2fEx4ejnr16ml2k0f2pHTuWHEq/OQmhZw8TLft3Llz2Lx5M9577z20a9cOFosFhw4dwvjx4zF48GDMmDEDU6ZMwXvvvYc+ffpg8ODBCAkJwfnz53Hu3Dm0adNG7W/B4xYvXoxly5Zh5MiRiIqKwurVq/Hhhx9i3759ePPNN1FUVITFixcjNzcXffv2Rf369QFY765brVo1FBcX2wOhlrAv1xw6dAhbtmzBwoUL0axZMwDAmjVrkJiYiNTUVEyYMAGrVq3C4MGDMWfOHNx3331o1qwZtm/fjlOnTqFx48Yqfwfux56U7tSpU/jxxx8xf/58tGzZEgCwZcsWfP7555g4cSImTJiARYsWYcyYMVi0aBH27NmDli1bYt++ffjjjz8wZcoUANr4ZeBWcHdvum0nT57EM888g+XLl6NWrVr242lpaRg4cCDMZjMWL16M2NhYzJkzB7t27UJeXh4qVqyIsWPHolGjRuoV72FCCBiNRvz73//Gvffei+eee87+2IcffojNmzejUaNGmDp1KjZu3IiVK1fiypUraNiwISwWC5KTk7F8+XI0aNBAxe/C/dgXZ4cPH8agQYOwcOFCNGzY0H58y5Yt+PDDD1G1alW89dZbyM3NxWeffYaffvoJsiwjNDQUU6dO1eS/I/akdGfPnkWfPn0wZ84ctG3b1n48OTkZiYmJyMrKwpQpU1CpUiX7ilPAOmIzYcIEh176BfWm95CvWbt2rTh8+LAoKCgQ7dq1Ex9++KH9MduktMuXL4uHH35Y9OvXz/5YZmamKCgoELm5ueVes1r69esnZsyYIYQQ9nuuCCHEJ598Irp37y6mT58uhBDiyJEjIikpSQwfPlzMnDlTHD9+XJV6Pck2kdFisbAv1zlw4IBo3bq12LNnjxDCcaL95s2bRceOHe39MBqNIj8/X6Smpmr63xF74owrTm8fgw3dkrfffls0bdpUnDt3TlgsFjF16lTx1FNPiR9//NH+HNsPsF27dolOnTrZZ+n7y0x8Iaw9sFgs4rXXXhO9e/e2v7Fc/wY9d+5c8fDDD4tdu3apVWa5OnnypBDC+joYMWIE+3KdIUOGiPvvv19kZGQIIRz7kZSUJJo0aSL+/PNPtcorF3PnzhWLFy+2f/zvf//b73tSGq44vXWcPEx/a9q0adi4cSPWrFmD6tWrQ5ZlPPnkkzCbzUhKSrKvcrJdv23cuLHfzcTPzMxEbm4u8vLyIMsyXn/9dZw5cwZvvfUWAMc9joYPH47IyEisWrVKzZLLxTvvvIOBAweyLwC++uorzJs3D/PmzcPmzZsBWFcRVqxYEQMHDkRmZiYMBgOMRiMA4F//+hfi4+MdJslqzdSpU7Fs2TK0a9fOfmzAgAGIi4vz254AXHFaVtr/iUNlMmPGDGzYsAFffPGF/TqtEAL16tXD+PHjce7cOaxYscJhJn5ERITf7f00bNgwdOvWDa+99ho2bNiAKlWqYOLEidi0aRMmTZoEwHGPozZt2iAnJ0fNsj1u2rRp+Oqrr/B///d/CAsLg8ViQeXKlTFx4kRs3LgRkydPBuAffZk9ezamTZuGkydPYuvWrZg1axaGDh2K+Ph4/Pvf/0ZxcTFefvllZGRkIDAwEACQn5+PkJAQza70sb0+Pv/8cyQkJNhX7DRo0AADBw6E0Wj0u54AXHHqDlwVRX/JYrHgwIEDqFy5MqpXrw4AKC4uxv/93//hxIkTiI+PR7169ZCWloaVK1di3759uPvuu7F3714cOXIE77zzjsrfged9/PHHSEpKwtixY5GRkYGzZ89izJgxOHfuHPr06YNx48Zh2rRpKCgowMSJExEaGgoAuHz5MipUqACLxQJZljW3WmH69On48ssvkZSUhHr16gGAfZn2o48+ipycHEyfPh15eXmYNGmSpvvy559/4rvvvsP777+PNm3aoLCwED/++COmT5+OF198EfPmzcOoUaMwa9YsdO3aFRMmTIBer8ehQ4eQmZmJO+64Q+1vwe2WLl2KZcuWYfXq1fYJv5IkITs7GxaLBZ06dUJQUBDmzZuHLl26YOLEiZrvCQCcP3+eK07dgMGG/pJOp8Obb76JcePGYe7cuXjttdcwYMAAFBQUoHHjxjh37hwKCgoAAPfeey++/vpr7NmzB6Ghofjss8/sYUirbMHvpZdeQrdu3QBY925p1KgRpkyZgsLCQvvuwxMnTsRzzz2HmJgYhISE4L///a/m9jiy2blzJ5YvX44JEybYQ42iKPj555+RlZWFuLg4dOnSBbGxsZg8eTKeffZZVKxYUbN9yc7ORmFhob0XwcHB6Ny5M6pUqYKRI0fitddew6efforExETMnj0bs2bNgl6vR1hYmGb3Obpw4QKqVq2K4OBgANYRh0mTJuH48eO4cuUKGjVqhLFjx+L999/Hhx9+6Bc9AYCCggLk5OTY983T6XRo3rw5Fi9ejIEDB2LMmDFYvHgxFi9ejDlz5mDz5s32FadLlizR/H57t4rLvemmioqK8Pnnn2Pbtm2oUaMGFEXB2LFjERUVBZPJhCVLlmDr1q147733ULNmTeTn50On02n+MpSiKCgqKsLjjz+Of/7znxgyZIjD419//TXeeOMNDBs2DAMHDkRWVhYWL16MrKwsBAcH4+mnn0bdunVVqt6zzpw5gzfffBMJCQmYNGkSZFnGCy+8gIyMDFy9ehUZGRn45z//iVGjRkGWZftyVa32JSUlBf/6178waNAgPPnkkw6P7du3D8OHD8c999yDWbNmAbD+0A8NDYUsy4iMjFSj5HLxr3/9CwCwfPlyDB06FAUFBXjwwQdhMBiwZMkS6PV6rF+/HjqdDufPn0dYWJjme1JUVISHH34YvXv3tr+nKIoCWZaRkpKC559/HrGxsfj8888BAFlZWQgKCoLFYkFYWJiapXsXVacuk09ISUkRAwYMEA0bNhQzZ860r/wRQoiMjAzRpEkT8dVXX6lcpTqmT58uunfvXupmjMuWLRONGjVy2MNFCP9YJbZ3717RtGlTkZiYKD744AMxaNAgcfr0aZGeni527twpGjduLGbPni2EcFwOrhXff/+9WLp0qfjPf/4jdu7cKQYOHCiGDh0qDh065PA8o9Eo1qxZI7p27SoOHjwohNBWH65n68kHH3wgTp06Jc6fPy86duwonnjiCTF+/HiRmppqf+758+fFP/7xD/Hxxx8LIbTbEyGE+Pnnn8WmTZvEunXrRH5+vpg6daro3bs3V5yWAScP09+Ki4vDa6+9hjp16qB79+6QJAmyLENYbxeARo0aIT4+Xu0yy8WXX36JxMRE+8etWrWCTqfD6tWrkZqaaj8uhED37t3RuXNn7Nq1CxaLxb7HkRbmjdzoxr60bNkSY8aMwdy5c/HTTz/hpZdeQq1atRATE4N7770Xo0aNwpYtW5CZmWmfOKyVvsyaNQtTpkzBTz/9hKVLl2LRokWIjY1FcnIylixZgjNnztifa9vn6NKlSzh16hQAba4ivL4nSUlJGD58OHbt2oVhw4bhyJEjSE1NRVRUlP35lSpVQpUqVZCXlwdAmz0BrIszxo4diyVLluDNN9/EBx98gBdeeAEWi4UrTsuAXaFb0qBBA6xbtw7169fH5cuXkZ2djby8PCxbtgxXrlzR/HwaW4jbs2cPPvnkE6xZswYA0LFjR3Ts2BE//PADVqxYgZSUFADWN6Lw8HCEhobi5MmT0Ol0mtrjyObGvqxdu9b+WJcuXdCxY0ekpKSgatWq9ucD1rkDQUFBiIiI0FRfNm3ahG+//RaJiYlYvHgxtm3bhry8PBiNRkyfPh2bN2/GvHnzcPDgQfvnVKhQAfXq1dPspYTSehIYGIgffvgBLVu2xDPPPIMRI0Y4bJVhMBgQERFhv+wkNDhjYv369fjmm2+waNEiLF26FNOmTcO6desQHx+PCRMm4Ny5c1i2bBm+++47++f424pTV3HyMN2ywMBAZGRk4IknnoCiKKhcuTKuXr2Kjz76SPMjNoqiQKfTITg4GIWFhfj8889RVFSEZ555xj4/YOPGjfY9jurUqQPA+sO6WrVqMJvN0Ou198/txr58+umnKCoqQt++fVGhQgW8+OKLiI2NRVxcHEwmEwwGAwDr6o9KlSqhuLhYU305deoU6tWrhwYNGqC4uBghISF45ZVXMGLECIwbNw4ff/wxxowZg+zsbNx333244447sHXrVpw9e1azt72/sSfBwcF4+eWXMWLECADA66+/Dp1OhxMnTuDEiROoX78+1q9fj4MHD2L8+PEAtBF6b3T8+HHcfffd9r/3yMhIhIaGYvLkyYiIiEDbtm1x7NgxJCUlITk52e9WnJaFdt5RqFzExMTYf+OsVKkS7rzzTvtv41pmG1U4c+YM7rjjDsTGxmL16tUAgGeeeQajR49GZGQktm3bhldeeQVNmzZFUVER9u7dixUrVmjqh/f1SuvLypUrAQB9+/ZF8+bNAQBHjhzBnDlzULt2beTm5to38LOtivF1QghIkoQrV64gIyMDkiTZRyAiIyNhNptx6dIltG3bFh9++CFWr16NZcuWISAgAMHBwViyZInm/h3drCcREREwm832narz8/Mxbdo07NmzB9WqVYPBYMDSpUtRs2ZNlb8L97ONPl28eNEe2IQQWLhwIQAgLy8PycnJiIiIQGxsLJo2bYovv/zSr1aclpU2323Jo1q2bGnfYdZfCCGQlZWF/Px8DB48GHXq1MHcuXMdws2AAQPQsmVL/O9//8Nvv/2GWrVq4fXXX0dCQoLK1XvOX/Vl5cqVkCTJvvLlxIkT0Ol02L9/PxISErB8+XL78mctsP2Aeuihh3DgwAGcP3/e/sMnMjISOp0OJpMJQgg0bdoUTZs2RW5uLiwWC3Q6nSZvOPd3PZFl2X5H4dDQUEyfPh0pKSkIDg5GdHQ0YmJiVKvdk2x9eeWVV/Dbb78BsIacf/zjH+jXrx+io6ORl5eH6dOn48SJE+jVqxdeeuklv1lx6g5c7k10i8xmM1avXo177rkHdevWxYkTJ7BgwQIcO3YMTz31FPr166d2iaq4WV/69OmDvn37AoB964Trf3PXopSUFMTExNi/x+TkZLz00ktYs2YNEhISIEkSPv30UxgMBjz99NMqV1s+bqUnSUlJCAgIQO/evVWuVh1FRUX2pds6nQ4XL15Ep06dsHDhQrRv317t8nwKJw8T3SK9Xo/evXujbt26UBQFCQkJGDhwIBo0aIBVq1ZhxYoVapeoipv1ZeXKlVi+fDkA64RQg8Gg6VADAPHx8Q7fY2pqKsxmM8LDwyFJEubNm4cZM2b41ajnrfRk2rRpaNGihXpFqsQ2thAUFATAenlXCAGz2Yz69eujcuXKapbnkxhsiG6Dba6MbTjZ9kO8cePG+M9//oMvvvhCzfJUc7O+LFiwwG/7Ali3IdHpdAgLC8OHH36IJUuWYPXq1Zq6FHe7SuvJqlWrUL9+fbVLK3e2fzOXLl3Cr7/+iszMTOTl5WHDhg0oLCx0WAZPt4ZzbIhccP0qjYSEBPTv3x+BgYG45557VKxKfezLNbbJs4GBgYiIiMD48eOxZcsWrFy5Ek2bNlW7PFWwJ3/typUreOmllxAeHo5KlSohOzsb8+fPR2xsrNql+RzOsSFyk+uXM9M1/t6XI0eOoEePHggMDMTKlSvtmz76M/akdAcPHsTx48cRGRmJJk2a8DKUixhsiIg8qKioCDNnzsS//vUvze2D5Sr2hDyJwYaIyMOKi4s1P2n6drEn5CkMNkRERKQZXBVFREREmsFgQ0RERJrBYENERESawWBDREREmsFgQ0RERJrBOw8TkVcYM2YM1q9ff9PnVK1aFRcvXsTWrVtRrVq1cqqMiHwJl3sTkVc4d+4cMjMz7R9/9NFHOHz4MObPn28/ZruLcePGjf36bsZE9Nc4YkNEXqFGjRqoUaOG/ePo6GgYDAa/3PGZiFzHOTZE5DPWrVuHBg0a4MKFCwCsl69efPFFrFq1Cg8++CCaNWuGPn364PTp0/jxxx/RrVs3NG/eHE8++SSOHDnicK7k5GT069cPzZs3R+vWrfHGG284jBgRkW/iiA0R+bT9+/cjLS0NY8aMgdFoxOTJk/HKK69AkiS8+uqrCA4OxqRJk/D6669j06ZNAIC9e/eif//+aNOmDd5//31kZ2dj3rx5ePbZZ/HFF18gKChI5e+KiFzFYENEPi0/Px/vv/++fTPFX3/9FStXrsTSpUvRtm1bAMDZs2cxY8YM5OTkICIiArNnz0bt2rWxcOFC6HQ6AEDz5s3RpUsXrF27Fn379lXt+yGisuGlKCLyaZGRkQ47RFesWBGANajYVKhQAQCQk5ODwsJC/P7772jfvj2EEDCbzTCbzahevTrq1q2LnTt3lmv9ROReHLEhIp8WFhZW6vGQkJBSj+fk5EBRFHz88cf4+OOPnR4PDAx0a31EVL4YbIjIr4SGhkKSJDz//PPo0qWL0+PBwcEqVEVE7sJgQ0R+JSwsDI0bN8apU6dwxx132I8XFRXh1VdfRfv27ZGQkKBihURUFpxjQ0R+Z8SIEfjvf/+LkSNHYseOHdi2bRteeukl7Nq1C02aNFG7PCIqAwYbIvI7//jHP7B48WKkpKTg1VdfxejRo6HT6fDJJ5/whoBEPo5bKhAREZFmcMSGiIiINIPBhoiIiDSDwYaIiIg0g8GGiIiINIPBhoiIiDSDwYaIiIg0g8GGiIiINIPBhoiIiDSDwYaIiIg0g8GGiIiINIPBhoiIiDSDwYaIiIg04/8BeIbEfIFWUrIAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -415,7 +439,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.10.13"
   },
   "vscode": {
    "interpreter": {
@@ -425,4 +449,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}

From 7e133a19eb5521cf8e9fe4806169fb118e73d7b5 Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Fri, 17 May 2024 12:13:33 +0100
Subject: [PATCH 06/13] impl review comments and add tests

---
 python/tests/test_graphdb.py             | 17 ++++++++++++-----
 raphtory-graphql/src/model/graph/edge.rs | 15 +++++----------
 raphtory/Cargo.toml                      |  1 -
 raphtory/src/core/utils/errors.rs        |  4 ++--
 raphtory/src/db/api/view/edge.rs         |  9 +++++++++
 raphtory/src/db/graph/graph.rs           |  2 +-
 6 files changed, 29 insertions(+), 19 deletions(-)

diff --git a/python/tests/test_graphdb.py b/python/tests/test_graphdb.py
index f4ae71c48a..fcf6b54475 100644
--- a/python/tests/test_graphdb.py
+++ b/python/tests/test_graphdb.py
@@ -1435,19 +1435,21 @@ def test_layer_name():
     assert g.edge(0, 1).layer_names == ["_default"]
     assert g.edge(0, 2).layer_names == ["awesome layer"]
 
-    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() or "
-                 ".explode(). If you want to retrieve the layers for this edge you can use .layer_names")
+    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers(). " 
+                 "If you want to retrieve the layers for this edge you can use .layer_names")
     with pytest.raises(Exception) as e:
         g.edges.layer_name()
     assert str(e.value) == error_msg
 
     assert list(g.edges.explode().layer_name) == ['_default', 'awesome layer']
+    assert list(g.edges.explode_layers().layer_name) == ['_default', 'awesome layer']
 
     with pytest.raises(Exception) as e:
         g.edge(0, 2).layer_name()
     assert str(e.value) == error_msg
 
     assert list(g.edge(0, 2).explode().layer_name) == ['awesome layer']
+    assert list(g.edge(0, 2).explode_layers().layer_name) == ['awesome layer']
 
     with pytest.raises(Exception) as e:
         g.nodes.neighbours.edges.layer_name()
@@ -1458,17 +1460,22 @@ def test_layer_name():
         ["_default", "awesome layer"],
         ["_default", "awesome layer"]
     ]
+    assert [list(iterator) for iterator in g.nodes.neighbours.edges.explode_layers().layer_name] == [
+        ["_default", "awesome layer"],
+        ["_default", "awesome layer"],
+        ["_default", "awesome layer"]
+    ]
 
 def test_time():
     g = Graph()
+    g.add_constant_properties({"name": "graph"})
 
     g.add_edge(0, 0, 1)
     g.add_edge(0, 0, 2)
     g.add_edge(1, 0, 2)
 
-    error_msg = ("The time function is only available once an edge has been exploded via .explode_layers() or "
-                 ".explode(). You may want to retrieve the history for this edge via .history(), "
-                 "or the earliest/latest time via earliest_time or latest_time")
+    error_msg = ("The time function is only available once an edge has been exploded via .explode_layers() and .explode(). " 
+                 "You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")
     with pytest.raises(Exception) as e:
         g.edges.time()
     assert str(e.value) == error_msg
diff --git a/raphtory-graphql/src/model/graph/edge.rs b/raphtory-graphql/src/model/graph/edge.rs
index 1761ce6258..c3f5417cbc 100644
--- a/raphtory-graphql/src/model/graph/edge.rs
+++ b/raphtory-graphql/src/model/graph/edge.rs
@@ -9,6 +9,7 @@ use raphtory::{
     },
     prelude::{LayerOps, TimeOps},
 };
+use raphtory::core::utils::errors::GraphError;
 
 #[derive(ResolvedObject)]
 pub(crate) struct Edge {
@@ -95,11 +96,8 @@ impl Edge {
         self.ee.history().last().cloned()
     }
 
-    async fn time(&self) -> Result<i64, Error> {
-        match self.ee.time().map(|x| x.into()) {
-            Ok(name) => Ok(name),
-            Err(e) => Err(Error::new(e.to_string())),
-        }
+    async fn time(&self) -> Result<i64, GraphError> {
+        self.ee.time().map(|x| x.into())
     }
 
     async fn start(&self) -> Option<i64> {
@@ -126,11 +124,8 @@ impl Edge {
         self.ee.layer_names().map(|x| x.into()).collect()
     }
 
-    async fn layer_name(&self) -> Result<String, Error> {
-        match self.ee.layer_name().map(|x| x.into()) {
-            Ok(name) => Ok(name),
-            Err(e) => Err(Error::new(e.to_string())),
-        }
+    async fn layer_name(&self) -> Result<String, GraphError> {
+        self.ee.layer_name().map(|x| x.into())
     }
 
     async fn explode(&self) -> Vec<Edge> {
diff --git a/raphtory/Cargo.toml b/raphtory/Cargo.toml
index 7ac2e8370c..47cde45f44 100644
--- a/raphtory/Cargo.toml
+++ b/raphtory/Cargo.toml
@@ -77,7 +77,6 @@ tokio = { workspace = true } # for vector testing
 dotenv = { workspace = true } # for vector testing
 streaming-stats = { workspace = true }
 proptest = { workspace = true }
-futures-util = { workspace = true }
 
 [features]
 default = []
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
index daee9937bd..d051c8a667 100644
--- a/raphtory/src/core/utils/errors.rs
+++ b/raphtory/src/core/utils/errors.rs
@@ -115,10 +115,10 @@ pub enum GraphError {
     )]
     BincodeVersionError(u32, u32),
 
-    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). If you want to retrieve the layers for this edge you can use .layer_names")]
+    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers(). If you want to retrieve the layers for this edge you can use .layer_names")]
     LayerNameAPIError,
 
-    #[error("The time function is only available once an edge has been exploded via .explode_layers() or .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]
+    #[error("The time function is only available once an edge has been exploded via .explode_layers() and .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]
     TimeAPIError,
 }
 
diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index 396baacba4..7243d87f52 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -353,12 +353,21 @@ mod test_edge_view {
             .explode()
             .layer_name()
             .all(|l| l.is_ok()));
+        assert!(g
+            .edge(1, 2)
+            .unwrap()
+            .explode_layers()
+            .layer_name()
+            .all(|l| l.is_ok()));
         assert!(g.edges().explode().layer_name().all(|l| l.is_ok()));
+        assert!(g.edges().explode_layers().layer_name().all(|l| l.is_ok()));
 
         assert!(g.edge(1, 2).unwrap().time().is_err());
         assert!(g.edges().time().all(|l| l.is_err()));
         assert!(g.edge(1, 2).unwrap().explode().time().all(|l| l.is_ok()));
+        assert!(g.edge(1, 2).unwrap().explode_layers().time().all(|l| l.is_err()));
         assert!(g.edges().explode().time().all(|l| l.is_ok()));
+        assert!(g.edges().explode_layers().time().all(|l| l.is_err()));
     }
 
     #[test]
diff --git a/raphtory/src/db/graph/graph.rs b/raphtory/src/db/graph/graph.rs
index 9c97e3523e..e2b6b3b6db 100644
--- a/raphtory/src/db/graph/graph.rs
+++ b/raphtory/src/db/graph/graph.rs
@@ -1767,7 +1767,7 @@ mod db_tests {
                 e.explode().iter().filter_map(|e| {
                     e.edge
                         .layer()
-                        .zip(Some(e.time().unwrap()))
+                        .zip(e.time().ok())
                         .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
                 })
             })

From fe3552f334e215791f3e720bcf2db92ac1bd037e Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Fri, 17 May 2024 12:14:21 +0100
Subject: [PATCH 07/13] fmt

---
 raphtory-graphql/src/model/graph/edge.rs | 2 +-
 raphtory/src/db/api/view/edge.rs         | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/raphtory-graphql/src/model/graph/edge.rs b/raphtory-graphql/src/model/graph/edge.rs
index c3f5417cbc..cb59c1589e 100644
--- a/raphtory-graphql/src/model/graph/edge.rs
+++ b/raphtory-graphql/src/model/graph/edge.rs
@@ -3,13 +3,13 @@ use async_graphql::Error;
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
 use itertools::Itertools;
 use raphtory::{
+    core::utils::errors::GraphError,
     db::{
         api::view::{DynamicGraph, EdgeViewOps, IntoDynamic, StaticGraphViewOps},
         graph::edge::EdgeView,
     },
     prelude::{LayerOps, TimeOps},
 };
-use raphtory::core::utils::errors::GraphError;
 
 #[derive(ResolvedObject)]
 pub(crate) struct Edge {
diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index 7243d87f52..30f3b15acc 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -365,7 +365,12 @@ mod test_edge_view {
         assert!(g.edge(1, 2).unwrap().time().is_err());
         assert!(g.edges().time().all(|l| l.is_err()));
         assert!(g.edge(1, 2).unwrap().explode().time().all(|l| l.is_ok()));
-        assert!(g.edge(1, 2).unwrap().explode_layers().time().all(|l| l.is_err()));
+        assert!(g
+            .edge(1, 2)
+            .unwrap()
+            .explode_layers()
+            .time()
+            .all(|l| l.is_err()));
         assert!(g.edges().explode().time().all(|l| l.is_ok()));
         assert!(g.edges().explode_layers().time().all(|l| l.is_err()));
     }

From d51f08a251e573f0aa5285e120e83fd3219b1457 Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Fri, 17 May 2024 13:31:32 +0100
Subject: [PATCH 08/13] fix tests

---
 python/tests/test_graphql.py | 42 ++++++++++++++----------------------
 1 file changed, 16 insertions(+), 26 deletions(-)

diff --git a/python/tests/test_graphql.py b/python/tests/test_graphql.py
index 2af27a34bc..16194bf512 100644
--- a/python/tests/test_graphql.py
+++ b/python/tests/test_graphql.py
@@ -248,11 +248,9 @@ def test_windows_and_layers():
             after(time: 500) {
               history
               neighbours {
-                list {
-                  name
-                  before(time: 300) {
-                    history
-                  }
+                name
+                before(time: 300) {
+                  history
                 }
               }
             }
@@ -271,8 +269,7 @@ def test_windows_and_layers():
               555,
               562
             ],
-            "neighbours": {
-              "list": [
+            "neighbours": [
                 {
                   "name": "Gandalf",
                   "before": {
@@ -292,7 +289,6 @@ def test_windows_and_layers():
                   }
                 }
               ]
-            }
           }
         }
       }
@@ -311,16 +307,12 @@ def test_windows_and_layers():
               layer(name: "layer1") {
                 name
                 neighbours {
-                  list {
                     name
                     layer(name: "layer2") {
                       neighbours {
-                        list {
                           name
-                        }
                       }
                     }
-                  }
                 }
               }
             }
@@ -333,22 +325,16 @@ def test_windows_and_layers():
           "node": {
             "layer": {
               "name": "1",
-              "neighbours": {
-                "list": [
+              "neighbours": [
                   {
                     "name": "2",
                     "layer": {
-                      "neighbours": {
-                        "list": [
-                          {
+                      "neighbours": [{
                             "name": "3"
-                          }
-                        ]
-                      }
+                      }]
                     }
                   }
                 ]
-              }
             }
           }
         }
@@ -369,6 +355,7 @@ def test_properties():
     from raphtory.graphql import RaphtoryServer
 
     g = Graph()
+    g.add_constant_properties({"name": "graph"})
     g.add_node(
         1,
         1,
@@ -402,6 +389,7 @@ def test_properties():
     n.add_constant_properties(
         {"prop5": "val4", "prop6": "val4", "prop7": "val4", "prop8": "val4"}
     )
+
     hm = {"graph": g}
     server = RaphtoryServer(hm).start()
     server.wait_for_online()
@@ -410,7 +398,7 @@ def test_properties():
       graph(name: "graph") {
           nodes {
             list{
-              properties{
+              properties {
                 values(keys:["prop1","prop2"]){
                   key
                   asString
@@ -436,6 +424,7 @@ def test_properties():
     """
     r = """
     {
+      "data": {
         "graph": {
           "nodes": {
             "list": [
@@ -454,7 +443,7 @@ def test_properties():
                   "temporal": {
                     "values": [
                       {
-                        "key": "prop3",
+                        "key": "prop4",
                         "history": [
                           1,
                           2,
@@ -462,7 +451,7 @@ def test_properties():
                         ]
                       },
                       {
-                        "key": "prop4",
+                        "key": "prop3",
                         "history": [
                           1,
                           2,
@@ -474,11 +463,11 @@ def test_properties():
                   "constant": {
                     "values": [
                       {
-                        "key": "prop6",
+                        "key": "prop5",
                         "value": "val4"
                       },
                       {
-                        "key": "prop5",
+                        "key": "prop6",
                         "value": "val4"
                       }
                     ]
@@ -489,6 +478,7 @@ def test_properties():
           }
         }
       }
+    }
     """
     s = server.query(q)
     json_a = json.loads(json.dumps(s))

From d92a116c9ebef17b00765cf5b228b7fc59ff1d15 Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Fri, 17 May 2024 18:01:52 +0100
Subject: [PATCH 09/13] fix tests

---
 python/tests/test_graphql.py | 91 +++++++++++++++++++++---------------
 1 file changed, 53 insertions(+), 38 deletions(-)

diff --git a/python/tests/test_graphql.py b/python/tests/test_graphql.py
index 16194bf512..de8eae9226 100644
--- a/python/tests/test_graphql.py
+++ b/python/tests/test_graphql.py
@@ -234,9 +234,12 @@ def test_windows_and_layers():
     from raphtory.graphql import RaphtoryServer
 
     g_lotr = graph_loader.lotr_graph()
+    g_lotr.add_constant_properties({"name": "lotr"})
     g_layers = Graph()
+    g_layers.add_constant_properties({"name": "layers"})
     g_layers.add_edge(1, 1, 2, layer="layer1")
     g_layers.add_edge(1, 2, 3, layer="layer2")
+    g_layers.save_to_file("/tmp/graphs")
     hm = {"lotr": g_lotr, "layers": g_layers}
     server = RaphtoryServer(hm).start()
     server.wait_for_online()
@@ -248,9 +251,11 @@ def test_windows_and_layers():
             after(time: 500) {
               history
               neighbours {
-                name
-                before(time: 300) {
-                  history
+                list { 
+                    name
+                    before(time: 300) {
+                      history
+                    }
                 }
               }
             }
@@ -261,39 +266,41 @@ def test_windows_and_layers():
     """
     ra = """
     {
-    "graph": {
-      "window": {
-        "node": {
-          "after": {
-            "history": [
-              555,
-              562
-            ],
-            "neighbours": [
-                {
-                  "name": "Gandalf",
-                  "before": {
-                    "history": [
-                      270
-                    ]
-                  }
-                },
-                {
-                  "name": "Bilbo",
-                  "before": {
-                    "history": [
-                      205,
-                      270,
-                      286
-                    ]
-                  }
+        "graph": {
+          "window": {
+            "node": {
+              "after": {
+                "history": [
+                  555,
+                  562
+                ],
+                "neighbours": {
+                  "list": [
+                    {
+                      "name": "Gandalf",
+                      "before": {
+                        "history": [
+                          270
+                        ]
+                      }
+                    },
+                    {
+                      "name": "Bilbo",
+                      "before": {
+                        "history": [
+                          205,
+                          270,
+                          286
+                        ]
+                      }
+                    }
+                  ]
                 }
-              ]
+              }
+            }
           }
         }
-      }
     }
-  }
     """
     a = json.dumps(server.query(q))
     json_a = json.loads(a)
@@ -307,12 +314,16 @@ def test_windows_and_layers():
               layer(name: "layer1") {
                 name
                 neighbours {
+                  list {
                     name
                     layer(name: "layer2") {
                       neighbours {
+                        list {
                           name
+                        }
                       }
                     }
+                  }
                 }
               }
             }
@@ -325,20 +336,26 @@ def test_windows_and_layers():
           "node": {
             "layer": {
               "name": "1",
-              "neighbours": [
+              "neighbours": {
+                "list": [
                   {
                     "name": "2",
                     "layer": {
-                      "neighbours": [{
+                      "neighbours": {
+                        "list": [
+                          {
                             "name": "3"
-                      }]
+                          }
+                        ]
+                      }
                     }
                   }
                 ]
+              }
             }
           }
         }
-      }
+    }
       """
 
     a = json.dumps(server.query(q))
@@ -424,7 +441,6 @@ def test_properties():
     """
     r = """
     {
-      "data": {
         "graph": {
           "nodes": {
             "list": [
@@ -477,7 +493,6 @@ def test_properties():
             ]
           }
         }
-      }
     }
     """
     s = server.query(q)

From 8a72a65abf49f6c7bb7c0bf3e9083a802d6be27e Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Fri, 17 May 2024 19:14:42 +0100
Subject: [PATCH 10/13] rid save

---
 python/tests/test_graphql.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/python/tests/test_graphql.py b/python/tests/test_graphql.py
index de8eae9226..c28b555657 100644
--- a/python/tests/test_graphql.py
+++ b/python/tests/test_graphql.py
@@ -239,7 +239,6 @@ def test_windows_and_layers():
     g_layers.add_constant_properties({"name": "layers"})
     g_layers.add_edge(1, 1, 2, layer="layer1")
     g_layers.add_edge(1, 2, 3, layer="layer2")
-    g_layers.save_to_file("/tmp/graphs")
     hm = {"lotr": g_lotr, "layers": g_layers}
     server = RaphtoryServer(hm).start()
     server.wait_for_online()

From f7a3741be6f2de2fb4c4eca32458f9b56e4004ad Mon Sep 17 00:00:00 2001
From: Shivam Kapoor <4599890+iamsmkr@users.noreply.github.com>
Date: Tue, 21 May 2024 16:36:02 +0100
Subject: [PATCH 11/13] fix error msgs

---
 python/tests/test_graphdb.py      | 4 ++--
 raphtory/src/core/utils/errors.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/tests/test_graphdb.py b/python/tests/test_graphdb.py
index a62e1fc0a7..63f1c704c7 100644
--- a/python/tests/test_graphdb.py
+++ b/python/tests/test_graphdb.py
@@ -1446,7 +1446,7 @@ def test_layer_name():
     assert g.edge(0, 1).layer_names == ["_default"]
     assert g.edge(0, 2).layer_names == ["awesome layer"]
 
-    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers(). " 
+    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() and .explode(). " 
                  "If you want to retrieve the layers for this edge you can use .layer_names")
     with pytest.raises(Exception) as e:
         g.edges.layer_name()
@@ -1485,7 +1485,7 @@ def test_time():
     g.add_edge(0, 0, 2)
     g.add_edge(1, 0, 2)
 
-    error_msg = ("The time function is only available once an edge has been exploded via .explode_layers() and .explode(). " 
+    error_msg = ("The time function is only available once an edge has been exploded via .explode(). " 
                  "You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")
     with pytest.raises(Exception) as e:
         g.edges.time()
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
index d051c8a667..d32a9a18e1 100644
--- a/raphtory/src/core/utils/errors.rs
+++ b/raphtory/src/core/utils/errors.rs
@@ -115,10 +115,10 @@ pub enum GraphError {
     )]
     BincodeVersionError(u32, u32),
 
-    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers(). If you want to retrieve the layers for this edge you can use .layer_names")]
+    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() and .explode(). If you want to retrieve the layers for this edge you can use .layer_names")]
     LayerNameAPIError,
 
-    #[error("The time function is only available once an edge has been exploded via .explode_layers() and .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]
+    #[error("The time function is only available once an edge has been exploded via .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]
     TimeAPIError,
 }
 

From 90b4327d21790c0cfd5f0c506e42182210138782 Mon Sep 17 00:00:00 2001
From: miratepuffin <b.a.steer@qmul.ac.uk>
Date: Thu, 23 May 2024 13:58:13 +0100
Subject: [PATCH 12/13] Fixed error messages

---
 python/tests/test_graphdb.py      | 2 +-
 raphtory/src/core/utils/errors.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/tests/test_graphdb.py b/python/tests/test_graphdb.py
index b08d6fe1aa..2868ec58f6 100644
--- a/python/tests/test_graphdb.py
+++ b/python/tests/test_graphdb.py
@@ -1466,7 +1466,7 @@ def test_layer_name():
     assert g.edge(0, 1).layer_names == ["_default"]
     assert g.edge(0, 2).layer_names == ["awesome layer"]
 
-    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() and .explode(). " 
+    error_msg = ("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). " 
                  "If you want to retrieve the layers for this edge you can use .layer_names")
     with pytest.raises(Exception) as e:
         g.edges.layer_name()
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
index 7b39788ddc..ce5fe09555 100644
--- a/raphtory/src/core/utils/errors.rs
+++ b/raphtory/src/core/utils/errors.rs
@@ -113,7 +113,7 @@ pub enum GraphError {
     )]
     BincodeVersionError(u32, u32),
 
-    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() and .explode(). If you want to retrieve the layers for this edge you can use .layer_names")]
+    #[error("The layer_name function is only available once an edge has been exploded via .explode_layers() or .explode(). If you want to retrieve the layers for this edge you can use .layer_names")]
     LayerNameAPIError,
 
     #[error("The time function is only available once an edge has been exploded via .explode(). You may want to retrieve the history for this edge via .history(), or the earliest/latest time via earliest_time or latest_time")]

From bb87b1b05c197d7f209bcdb4147f2e8655b1662d Mon Sep 17 00:00:00 2001
From: miratepuffin <b.a.steer@qmul.ac.uk>
Date: Thu, 23 May 2024 15:14:47 +0100
Subject: [PATCH 13/13] fmt

---
 raphtory/src/db/api/view/edge.rs | 13 ++++++++--
 raphtory/src/db/graph/graph.rs   | 44 ++++++++++++++++----------------
 2 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/raphtory/src/db/api/view/edge.rs b/raphtory/src/db/api/view/edge.rs
index 3d11123c2f..b3ac6eb398 100644
--- a/raphtory/src/db/api/view/edge.rs
+++ b/raphtory/src/db/api/view/edge.rs
@@ -421,11 +421,20 @@ mod test_edge_view {
                 .layer_name()
                 .all(|l| l.is_ok()));
             assert!(graph.edges().explode().layer_name().all(|l| l.is_ok()));
-            assert!(graph.edges().explode_layers().layer_name().all(|l| l.is_ok()));
+            assert!(graph
+                .edges()
+                .explode_layers()
+                .layer_name()
+                .all(|l| l.is_ok()));
 
             assert!(graph.edge(1, 2).unwrap().time().is_err());
             assert!(graph.edges().time().all(|l| l.is_err()));
-            assert!(graph.edge(1, 2).unwrap().explode().time().all(|l| l.is_ok()));
+            assert!(graph
+                .edge(1, 2)
+                .unwrap()
+                .explode()
+                .time()
+                .all(|l| l.is_ok()));
             assert!(graph
                 .edge(1, 2)
                 .unwrap()
diff --git a/raphtory/src/db/graph/graph.rs b/raphtory/src/db/graph/graph.rs
index d75a74607f..f2eb47f048 100644
--- a/raphtory/src/db/graph/graph.rs
+++ b/raphtory/src/db/graph/graph.rs
@@ -2018,18 +2018,18 @@ mod db_tests {
         fn test<G: StaticGraphViewOps>(graph: &G) {
             let e = graph.edge(1, 2).expect("edge");
 
-        let layer_exploded = e
-            .explode_layers()
-            .iter()
-            .flat_map(|e| {
-                e.explode().iter().filter_map(|e| {
-                    e.edge
-                        .layer()
-                        .zip(e.time().ok())
-                        .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
+            let layer_exploded = e
+                .explode_layers()
+                .iter()
+                .flat_map(|e| {
+                    e.explode().iter().filter_map(|e| {
+                        e.edge
+                            .layer()
+                            .zip(e.time().ok())
+                            .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
+                    })
                 })
-            })
-            .collect::<Vec<_>>();
+                .collect::<Vec<_>>();
 
             assert_eq!(
                 layer_exploded,
@@ -2057,18 +2057,18 @@ mod db_tests {
             let g = graph.window(0, 3);
             let e = g.edge(1, 2).expect("edge");
 
-        let layer_exploded = e
-            .explode_layers()
-            .iter()
-            .flat_map(|e| {
-                e.explode().iter().filter_map(|e| {
-                    e.edge
-                        .layer()
-                        .zip(Some(e.time().unwrap()))
-                        .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
+            let layer_exploded = e
+                .explode_layers()
+                .iter()
+                .flat_map(|e| {
+                    e.explode().iter().filter_map(|e| {
+                        e.edge
+                            .layer()
+                            .zip(Some(e.time().unwrap()))
+                            .map(|(layer, t)| (t, e.src().id(), e.dst().id(), *layer))
+                    })
                 })
-            })
-            .collect::<Vec<_>>();
+                .collect::<Vec<_>>();
 
             assert_eq!(
                 layer_exploded,