if let Some((txn, mut change, updates, hash, oldest)) = result {
            let hash = hash.unwrap();
            if sign {
                let mut key_path = dirs_next::home_dir().unwrap().join(".ssh");
                match sign_hash(&mut key_path, hash).await? {
                    Some((pk, signature)) if !signature.is_empty() => {
                        let sig = toml::Value::try_from(vec![Signature {
                            public_key: pk,
                            timestamp: change.header.timestamp,
                            signature,
                        }])?;
                        let mut toml = toml::map::Map::new();
                        toml.insert("signatures".to_string(), sig);
                        change.unhashed = Some(toml.into());
                        let hash2 = repo.changes.save_change(&change).unwrap();
                        assert_eq!(hash2, hash);

        match result  {
            Either::A((txn, mut change, updates, hash, oldest)) => {
                let hash = hash.unwrap();
                if sign {
                    let mut key_path = dirs_next::home_dir().unwrap().join(".ssh");
                    match sign_hash(&mut key_path, hash).await? {
                        Some((pk, signature)) if !signature.is_empty() => {
                            let sig = toml::Value::try_from(vec![Signature {
                                public_key: pk,
                                timestamp: change.header.timestamp,
                                signature,
                            }])?;
                            let mut toml = toml::map::Map::new();
                            toml.insert("signatures".to_string(), sig);
                            change.unhashed = Some(toml.into());
                            let hash2 = repo.changes.save_change(&change).unwrap();
                            assert_eq!(hash2, hash);
                        }
                        _ => {
                            bail!("Could not sign the change");
                        }

                    _ => {
                        bail!("Could not sign the change");
                    }

            }
            let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };
            txn.apply_local_change(&mut channel, &change, &hash, &updates)?;
            writeln!(stdout, "Hash: {}", hash.to_base32())?;
            debug!("oldest = {:?}", oldest);
            if no_prefixes {
                let mut oldest = oldest
                    .duration_since(std::time::SystemTime::UNIX_EPOCH)
                    .unwrap()
                    .as_secs() as u64;
                if oldest == 0 {
                    // If no diff was done at all, it means that no
                    // existing file changed since last time (some
                    // files may have been added, deleted or moved,
                    // but `touch` isn't about those).
                    oldest = std::time::SystemTime::now()

                let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                    txn.into_inner().unwrap()
                } else {
                    unreachable!()
                };
                txn.apply_local_change(&mut channel, &change, &hash, &updates)?;
                writeln!(stdout, "Hash: {}", hash.to_base32())?;
                debug!("oldest = {:?}", oldest);
                if no_prefixes {
                    let mut oldest = oldest

                    if oldest == 0 {
                        // If no diff was done at all, it means that no
                        // existing file changed since last time (some
                        // files may have been added, deleted or moved,
                        // but `touch` isn't about those).
                        oldest = std::time::SystemTime::now()
                            .duration_since(std::time::SystemTime::UNIX_EPOCH)
                            .unwrap()
                            .as_secs() as u64;
                    }
                    txn.touch_channel(&mut *channel.write()?, Some(oldest));

                txn.touch_channel(&mut *channel.write()?, Some(oldest));

                txn.commit()?;
            }
            Either::B(txn) => {
                if no_prefixes {
                    let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                        txn.into_inner().unwrap()
                    } else {
                        unreachable!()
                    };
                    txn.touch_channel(&mut *channel.write()?, None);
                    txn.commit()?;
                }
                writeln!(stderr, "Nothing to record")?;

            txn.commit()?;
        } else {
            writeln!(stderr, "Nothing to record")?;

        Option<(

        Either<(

        )>,

        ), Arc<RwLock<T>>>,

            let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };
            txn.touch_channel(&mut *channel.write()?, None);
            txn.commit()?;
            return Ok(None);

            return Ok(Either::B(txn));

        Ok(Some((

        Ok(Either::A((

enum Either<A, B> {
    A(A),
    B(B)
}

            result.oldest_change = result.oldest_change.min(rec.oldest_change);

            if result.oldest_change == std::time::UNIX_EPOCH
                || (rec.oldest_change > std::time::UNIX_EPOCH
                    && rec.oldest_change < result.oldest_change)
            {
                result.oldest_change = rec.oldest_change
            }