} else if tag.len() < 2 {
                    bail!("Ambiguous tag hash, need at least two characters")

                    find_tag(&mut tag_path, &tag)?

                    super::find_hash(&mut tag_path, &tag)?

}
fn find_tag(tag_path: &mut PathBuf, tag: &str) -> Result<libpijul::Hash, anyhow::Error> {
    let (a, b) = tag.split_at(2);
    tag_path.push(a);
    let mut result = None;
    for f in std::fs::read_dir(&tag_path)? {
        let e = f?;
        let p = if let Ok(p) = e.file_name().into_string() {
            p
        } else {
            continue;
        };
        if p.starts_with(b) {
            if result.is_none() {
                result = Some(p)
            } else {
                bail!("Ambiguous tag hash");
            }
        }
    }
    if let Some(mut r) = result {
        tag_path.push(&r);
        if let Some(i) = r.find('.') {
            r.truncate(i)
        }
        let f = format!("{}{}", a, r);
        if let Some(h) = libpijul::Hash::from_base32(f.as_bytes()) {
            return Ok(h);
        }
    }
    bail!("Tag not found")

    }
}
fn find_hash(path: &mut std::path::PathBuf, hash: &str) -> Result<libpijul::Hash, anyhow::Error> {
    use libpijul::Base32;
    if hash.len() < 2 {
        bail!("Ambiguous hash, need at least two characters")
    }
    let (a, b) = hash.split_at(2);
    path.push(a);
    let mut result = None;
    for f in std::fs::read_dir(&path)? {
        let e = f?;
        let p = if let Ok(p) = e.file_name().into_string() {
            p
        } else {
            continue;
        };
        if p.starts_with(b) {
            if result.is_none() {
                result = Some(p)
            } else {
                bail!("Ambiguous hash");
            }
        }
    }
    if let Some(mut r) = result {
        path.push(&r);
        if let Some(i) = r.find('.') {
            r.truncate(i)
        }
        let f = format!("{}{}", a, r);
        if let Some(h) = libpijul::Hash::from_base32(f.as_bytes()) {
            return Ok(h);
        }

    bail!("Hash not found")

                let change = match change {
                    Ok(change) => change,

                match change {
                    Ok(change) => repo.changes.save_change(&change)?,

                            let extra = if std::path::Path::new(&ch).is_relative() {
                                " Using the full path to the change file may help."
                            } else {
                                ""
                            };
                            bail!("File {} not found, and not recognised as a prefix of a known change identifier.{}", ch, extra)

                            let mut changes = repo.changes_dir.clone();
                            super::find_hash(&mut changes, &ch)?

                            return Err(e.into())

                            return Err(e.into());

                    Err(e) => return Err(e.into())
                };
                repo.changes.save_change(&change)?

                    Err(e) => return Err(e.into()),
                }