libpijul::fs::iter_graph_descendants(txn, &channel.read().graph, p)?
                .map(|x| x.unwrap()),

            libpijul::fs::iter_graph_descendants(txn, &channel.read(), p)?.map(|x| x.unwrap()),

                    libpijul::fs::iter_graph_descendants(
                        &remote_txn,
                        &remote_channel.read().graph,
                        p,
                    )?
                    .map(|x| x.unwrap()),

                    libpijul::fs::iter_graph_descendants(&remote_txn, &remote_channel.read(), p)?
                        .map(|x| x.unwrap()),

                            libpijul::fs::iter_graph_descendants(&*txn, &channel.read().graph, p)?

                            libpijul::fs::iter_graph_descendants(&*txn, &channel.read(), p)?

                    &channel.read().graph,

                    &channel.read(),

                libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;

                libpijul::pristine::debug(&txn, &channel, std::io::stdout())?;

    type Graph = Db<Vertex<ChangeId>, SerializedEdge>;

    type Graph = Channel;

    sanakirja_get!(graph, Vertex<ChangeId>, SerializedEdge, GraphError);

    fn get_graph<'txn>(
        &'txn self,
        db: &Self::Graph,
        key: &Vertex<ChangeId>,
        value: Option<&SerializedEdge>,
    ) -> Result<Option<&'txn SerializedEdge>, TxnErr<Self::GraphError>> {
        match ::sanakirja::btree::get(&self.txn, &db.graph, key, value) {
            Ok(Some((k, v))) if k == key => Ok(Some(v)),
            Ok(_) => Ok(None),
            Err(e) => {
                error!("{:?}", e);
                Err(TxnErr(SanakirjaError::PristineCorrupt))
            }
        }
    }

        let mut cursor = btree::cursor::Cursor::new(&self.txn, g).map_err(TxnErr)?;

        let mut cursor = btree::cursor::Cursor::new(&self.txn, &g.graph).map_err(TxnErr)?;

        find_block(&self.txn, graph, p)

        find_block(&self.txn, &graph.graph, p)

        find_block_end(&self.txn, graph, p)

        find_block_end(&self.txn, &graph.graph, p)

        let mut c = ::sanakirja::btree::cursor::Cursor::new(&self.txn, &g)?;

        let mut c = ::sanakirja::btree::cursor::Cursor::new(&self.txn, &g.graph)?;

    fn graph<'a>(&self, c: &'a Self::Channel) -> &'a Db<Vertex<ChangeId>, SerializedEdge> {
        &c.graph

    fn graph<'a>(&self, c: &'a Self::Channel) -> &'a Channel {
        c

        Ok(btree::put(&mut self.txn, graph, k, e)?)

        Ok(btree::put(&mut self.txn, &mut graph.graph, k, e)?)

        Ok(btree::del(&mut self.txn, graph, k, e)?)

        Ok(btree::del(&mut self.txn, &mut graph.graph, k, e)?)

            &[graph],

            &[&graph.graph],

        let mut cursor = btree::cursor::Cursor::new(&self.txn, graph)?;

        let mut cursor = btree::cursor::Cursor::new(&self.txn, &graph.graph)?;

        &mut c.graph

        c