}
}
pub mod position_base32_serde {
    use super::*;
    use serde::*;
    pub struct PositionDe {}
    impl<'de> serde::de::Visitor<'de> for PositionDe {
        type Value = Position<ChangeId>;
        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(formatter, "a base32-encoded string")
        }
        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            if let Some(b) = Position::from_base32(s.as_bytes()) {
                Ok(b)
            } else {
                Err(de::Error::invalid_value(
                    serde::de::Unexpected::Str(s),
                    &self,
                ))
            }
        }
    }
    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Position<ChangeId>, D::Error> {
        d.deserialize_str(PositionDe {})

    pub fn serialize<S: Serializer>(pos: &Position<ChangeId>, s: S) -> Result<S::Ok, S::Error> {
        let b = pos.to_base32();
        s.serialize_str(&b)
    }

pub(crate) fn iter_adj_all<'txn, T: GraphTxnT>(

pub fn iter_adj_all<'txn, T: GraphTxnT>(

pub(crate) fn internal_pos<T: GraphTxnT>(

pub fn internal_pos<T: GraphTxnT>(

pub fn internal_vertex<T: GraphTxnT>(
    txn: &T,
    v: &Vertex<Option<Hash>>,
    change_id: ChangeId,
) -> Result<Vertex<ChangeId>, InconsistentChange<T::GraphError>> {
    let change = if let Some(p) = v.change {
        if let Some(&p) = txn.get_internal(&p.into())? {
            p
        } else {
            return Err(InconsistentChange::UndeclaredDep);
        }
    } else {
        change_id
    };
    Ok(Vertex {
        change,
        start: v.start,
        end: v.end,
    })
}

use super::Base32;

impl Base32 for Inode {
    fn to_base32(&self) -> String {
        let inode: u64 = self.0.into();
        let mut b = [0; 8];
        BigEndian::write_u64(&mut b, inode);
        let mut bb = [0; 13];
        data_encoding::BASE32_NOPAD.encode_mut(&b, &mut bb);
        let b = std::str::from_utf8(&bb).unwrap();
        b.to_string()
    }
    fn from_base32(s: &[u8]) -> Option<Self> {
        let mut b = [0; 8];
        if data_encoding::BASE32_NOPAD
            .decode_mut(s, &mut b)
            .is_ok()
        {
            Some(Inode(BigEndian::read_u64(&b).into()))
        } else {
            None
        }
    }
}

    use serde::*;

    use serde::*;

    pub struct InodeDe{}

    pub struct InodeDe {}

            if data_encoding::BASE32_NOPAD.decode_mut(s.as_bytes(), &mut b).is_ok() {

            if data_encoding::BASE32_NOPAD
                .decode_mut(s.as_bytes(), &mut b)
                .is_ok()
            {

                Err(de::Error::invalid_value(serde::de::Unexpected::Str(s), &self))

                Err(de::Error::invalid_value(
                    serde::de::Unexpected::Str(s),
                    &self,
                ))

        d.deserialize_str(InodeDe{})

        d.deserialize_str(InodeDe {})

    pub(crate) fn is_deleted(&self) -> bool {

    pub fn is_deleted(&self) -> bool {

    pub(crate) fn is_parent(&self) -> bool {

    pub fn is_parent(&self) -> bool {

    pub(crate) fn is_folder(&self) -> bool {

    pub fn is_folder(&self) -> bool {

    pub(crate) fn is_block(&self) -> bool {

    pub fn is_block(&self) -> bool {

use byteorder::{ByteOrder, LittleEndian};

pub mod changeid_base32_serde {
    use super::*;
    use serde::*;
    pub struct ChangeIdDe {}
    impl<'de> serde::de::Visitor<'de> for ChangeIdDe {
        type Value = ChangeId;
        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(formatter, "a base32-encoded string")
        }
        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            let mut b = [0; 8];
            if data_encoding::BASE32_NOPAD
                .decode_mut(s.as_bytes(), &mut b)
                .is_ok()
            {
                let b: u64 = LittleEndian::read_u64(&b);
                Ok(ChangeId(b.into()))
            } else {
                Err(de::Error::invalid_value(
                    serde::de::Unexpected::Str(s),
                    &self,
                ))
            }
        }
    }
    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<ChangeId, D::Error> {
        d.deserialize_str(ChangeIdDe {})
    }
    pub fn serialize<S: Serializer>(inode: &ChangeId, s: S) -> Result<S::Ok, S::Error> {
        let inode: u64 = inode.0.into();
        let mut b = [0; 8];
        LittleEndian::write_u64(&mut b, inode);
        let mut bb = [0; 13];
        data_encoding::BASE32_NOPAD.encode_mut(&b, &mut bb);
        let b = std::str::from_utf8(&bb).unwrap();
        s.serialize_str(b)
    }
}

mod find_alive;

pub mod find_alive;

    fn iter_graph_children<'txn, 'changes, P>(
        &'txn self,
        changes: &'changes P,
        channel: &'txn Self::Channel,
        key: pristine::Position<ChangeId>,
    ) -> Result<fs::GraphChildren<'txn, 'changes, Self, P>, Self::GraphError>
    where
        P: changestore::ChangeStore
    {
        fs::iter_graph_children(self, changes, &self.graph(channel), key)
    }

pub(crate) fn find_alive_up<T: GraphTxnT>(

pub fn find_alive_up<T: GraphTxnT>(

use crate::pristine::{ChangeId, ChangePosition, EdgeFlags, Position, Inode};

use crate::pristine::{ChangeId, ChangePosition, EdgeFlags, Inode, Position};

pub(crate) use output::*;
pub(crate) use retrieve::*;

pub use output::*;
pub use retrieve::*;

pub(crate) struct AliveVertex {

pub struct AliveVertex {

    children: usize,
    n_children: usize,

    pub children: usize,
    pub n_children: usize,

    pub extra: Vec<(Option<SerializedEdge>, VertexId)>,

pub(crate) struct VertexId(pub(crate) usize);

pub struct VertexId(pub usize);

    const DUMMY: VertexId = VertexId(0);

    pub const DUMMY: VertexId = VertexId(0);