pub const MAX: Vertex<ChangeId> = Vertex {
        // u64::MAX is the maximum both for LE and BE byte orders.
        change: ChangeId(L64(u64::MAX)),
        start: ChangePosition(L64(u64::MAX)),
        end: ChangePosition(L64(u64::MAX)),
    };

use std::collections::BTreeSet;

#[derive(Debug)]

    let mut visited = HashSet::new();

    let mut visited = BTreeSet::new();
    let mut descendants = BTreeSet::new();

        // If `current` is alive and already visited, pass.
        if visited.contains(&(elt.vertex, elt.vertex)) {

        debug!("elt {:?}", elt);
        if elt.is_on_path {
            continue;
        }
        // Has this vertex been visited already?
        debug!("visited {:?}", visited);
        if !visited.insert(elt.vertex) {
            debug!("already visited!");
            debug!("descendants {:#?}", descendants);
            for (_, r) in descendants.range((elt.vertex, Vertex::ROOT)..=(elt.vertex, Vertex::MAX))
            {
                put_graph_with_rev(
                    txn,
                    channel,
                    EdgeFlags::PSEUDO,
                    elt.last_alive,
                    *r,
                    ChangeId::ROOT,
                )?;
            }

        let is_first_visit = visited.insert((elt.vertex, elt.last_alive));

        if !elt.is_on_path {
            // If this is the first visit, find the children, starting
            // with in flag order (alive first), since we don't want
            // to reconnect vertices multiple times.
            for e in iter_adjacent(
                txn,
                channel,
                elt.vertex,
                EdgeFlags::empty(),
                EdgeFlags::all(),
            )? {
                let e = e?;

        // If this is the first visit, find the children, in flag
        // order (alive first), since we don't want to reconnect
        // vertices multiple times.
        for e in iter_adjacent(
            txn,
            channel,
            elt.vertex,
            EdgeFlags::empty(),
            EdgeFlags::all(),
        )? {
            let e = e?;

                if e.flag().contains(EdgeFlags::PARENT) {
                    if e.flag() & (EdgeFlags::BLOCK | EdgeFlags::DELETED) == EdgeFlags::BLOCK {
                        // This vertex is alive!
                        stack[len - 1].last_alive = elt.vertex;
                    }
                    continue;
                } else if e.flag().contains(EdgeFlags::FOLDER) {
                    // If we are here, at least one children of `root`
                    // is FOLDER, hence all are.
                    return Ok(());
                }
                if is_first_visit {
                    let child = txn.find_block(channel, e.dest())?;
                    stack.push(StackElt {
                        vertex: *child,
                        last_alive: elt.last_alive,
                        is_on_path: false,
                    });

            if e.flag().contains(EdgeFlags::PARENT) {
                if e.flag() & (EdgeFlags::BLOCK | EdgeFlags::DELETED) == EdgeFlags::BLOCK {
                    // This vertex is alive!
                    stack[len - 1].last_alive = elt.vertex;

                continue;
            } else if e.flag().contains(EdgeFlags::FOLDER) {
                // If we are here, at least one child of `root` is
                // FOLDER, hence all are.
                return Ok(());

            let child = txn.find_block(channel, e.dest())?;
            stack.push(StackElt {
                vertex: *child,
                last_alive: elt.last_alive,
                is_on_path: false,
            });

            // If `elt` is alive, it doesn't matter which part
            // `last_alive` the current path comes from, we can stop
            // here.
            visited.remove(&(elt.vertex, elt.last_alive));
            visited.insert((elt.vertex, elt.vertex));

            if let Some(last_on_path) = (&stack[..len - 1]).iter().rev().position(|x| x.is_on_path)
            {
                let last_on_path = len - 2 - last_on_path;
                // If the last vertex on the path to `current` is not
                // alive, a reconnect is needed.
                if !stack[last_on_path].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.).
                    put_graph_with_rev(
                        txn,
                        channel,
                        EdgeFlags::PSEUDO,
                        elt.last_alive,
                        stack[len - 1].vertex,
                        ChangeId::ROOT,
                    )?;

            for v in (&stack[..len - 1]).iter().rev() {
                if v.is_on_path {
                    // If the last vertex on the path to `current` is not
                    // alive, a reconnect is needed.
                    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.).
                        put_graph_with_rev(
                            txn,
                            channel,
                            EdgeFlags::PSEUDO,
                            elt.last_alive,
                            stack[len - 1].vertex,
                            ChangeId::ROOT,
                        )?;
                        break;
                    } else {
                        // Remember that those dead vertices have
                        // `stack[len-1].vertex` as a descendant.
                        descendants.insert((v.vertex, stack[len - 1].vertex));
                    }