fn shares_alive_change(&self) -> bool {
        self.vertex.change == self.last_alive.change
    }

            for (_, r) in descendants.range((elt.vertex, Vertex::ROOT)..=(elt.vertex, Vertex::MAX))
            {

            let descendants_to_reconnect: Vec<_> = descendants
                .range((elt.vertex, Vertex::ROOT)..=(elt.vertex, Vertex::MAX))
                .map(|(_, r)| *r)
                .collect();
            for r in descendants_to_reconnect {

                if elt.last_alive != *r {

                if elt.last_alive != r {

                        *r,

                        r,

            let mut saw_dead_on_path = false;

                        if v.vertex != elt.vertex {

                        if saw_dead_on_path && v.vertex != elt.vertex {

                        saw_dead_on_path = true;

            let mut saw_dead_on_path = false;

                    if v.is_alive() {
                        // We need to reconnect, and we can do it now
                        // since we won't have a chance to visit that
                        // edge (because non-PARENT edge we are
                        // inserting now starts from a vertex that is
                        // on the path, which means we've already
                        // pushed all its children onto the stack.).
                        debug!(
                            "put_pseudo, alive 2, {:?} {:?}",
                            v.last_alive,
                            stack[len - 1].vertex
                        );
                        debug!("{:?}", stack);
                        let edge = Edge {
                            dest: stack[len - 1].vertex.start_pos(),
                            flag: EdgeFlags::empty(),
                            introduced_by: ChangeId::ROOT,
                        };
                        match txn.get_graph(channel, &v.last_alive, Some(&edge.into()))? {
                            Some(e) if e.dest() == edge.dest && e.flag() == EdgeFlags::BLOCK => {}
                            _ => {
                                put_graph_with_rev(
                                    txn,
                                    channel,
                                    EdgeFlags::PSEUDO,
                                    v.last_alive,
                                    stack[len - 1].vertex,
                                    ChangeId::ROOT,
                                )?;
                            }

                    if v.is_alive() || v.shares_alive_change() {
                        if saw_dead_on_path {
                            // We need to reconnect, and we can do it now
                            // since we won't have a chance to visit that
                            // edge (because non-PARENT edge we are
                            // inserting now starts from a vertex that is
                            // on the path, which means we've already
                            // pushed all its children onto the stack.).
                            debug!(
                                "put_pseudo, alive 2, {:?} {:?}",
                                v.last_alive,
                                stack[len - 1].vertex
                            );
                            debug!("{:?}", stack);
                            put_graph_with_rev(
                                txn,
                                channel,
                                EdgeFlags::PSEUDO,
                                v.last_alive,
                                stack[len - 1].vertex,
                                ChangeId::ROOT,
                            )?;

                        saw_dead_on_path = true;