// `clean_inodes` is used to check whether we're seeing this file
    // for the first time.

    let mut touched_inodes = HashSet::new();

            Atom::EdgeMap(ref newedges) => unapply_edges(
                changes,
                txn,
                T::graph_mut(channel),
                change_id,
                newedges,
                &mut ws,
            )?,

            Atom::EdgeMap(ref newedges) => {
                touched_inodes.insert(newedges.inode);
                unapply_edges(
                    changes,
                    txn,
                    T::graph_mut(channel),
                    change_id,
                    newedges,
                    &mut ws,
                )?
            }

                touched_inodes.insert(newvertex.inode);

            // If we are restoring a vertex that was deleted by the
            // patch we are unrecording, remove its zombie status
            // (extra pseudo-edges) if necessary.

    // Check each touched inode for zombieness, and remove files that
    // aren't zombies anymore.
    for inode in touched_inodes {
        // This inode is actually dead if its only alive adjacent
        // edges are PSEUDO.
        if let Ok(inode) = internal_pos(txn, &inode, change_id) {
            let channel = T::graph_mut(channel);
            collect_zombies_pseudo(txn, channel, inode, &mut ws)?;
            for (v, mut e) in ws.del_edges.drain(..) {
                if e.flag().contains(EdgeFlags::PARENT) {
                    let u = *txn.find_block_end(channel, e.dest())?;
                    e -= EdgeFlags::PARENT;
                    del_graph_with_rev(txn, channel, e.flag(), u, v, e.introduced_by())?;
                } else {
                    let w = *txn.find_block(channel, e.dest())?;
                    del_graph_with_rev(txn, channel, e.flag(), v, w, e.introduced_by())?;
                }
            }
        }
    }

/// Collect the edges introduced by the patch we're unrecording to
/// mark zombie conflicts.

                ws.del_edges.push((v, *e))
            }
        }
    }
    ws.stack.clear();
    ws.parents.clear();
    Ok(())
}
/// Collect the paths going through `to` whose vertices' adjacent
/// edges are all PSEUDO or DELETED
fn collect_zombies_pseudo<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    to: Position<ChangeId>,
    ws: &mut Workspace,
) -> Result<(), BlockError<T::GraphError>> {
    ws.stack.push(*txn.find_block(channel, to)?);
    while let Some(v) = ws.stack.pop() {
        debug!("remove_zombies, v = {:?}", v);
        if !ws.parents.insert(v) {
            continue;
        }
        let del_len = ws.del_edges.len();
        let stack_len = ws.stack.len();
        for e in iter_adj_all(txn, channel, v)? {
            let e = e?;
            debug!("e = {:?}", e);
            if (e.flag() & (EdgeFlags::PSEUDO | EdgeFlags::DELETED)).is_empty() {
                // This isn't a pseudo edge, `v` isn't part
                ws.del_edges.truncate(del_len);
                ws.stack.truncate(stack_len);
                break
            }
            if e.flag().contains(EdgeFlags::PARENT) {
                ws.stack.push(*txn.find_block_end(channel, e.dest())?)
            } else {
                ws.stack.push(*txn.find_block(channel, e.dest())?)
            }
            if e.flag().contains(EdgeFlags::PSEUDO) {