(import
  (fetchTarball {
    url = "https://github.com/edolstra/flake-compat/archive/c71d063a2fce96001c7ef99b301dfbd0c29ebde1.tar.gz";
    sha256 = "0vnbhqf0lc4mf2zmzqbfv6kqj9raijxz8xfaimxihz3c6s5gma2x";
  })
  { src = ./.; }).shellNix.default

with import <nixpkgs> {};
stdenv.mkDerivation {
  name = "Pijul";
  buildInputs = with pkgs; [
    xxHash
    zstd
    libsodium
    openssl
    pkgconfig
  ] ++ lib.optionals stdenv.isDarwin
    (with darwin.apple_sdk.frameworks; [
      CoreServices
      Security
      SystemConfiguration
    ]);
}
# (import
#   (fetchTarball {
#     url = "https://github.com/edolstra/flake-compat/archive/c71d063a2fce96001c7ef99b301dfbd0c29ebde1.tar.gz";
#     sha256 = "0vnbhqf0lc4mf2zmzqbfv6kqj9raijxz8xfaimxihz3c6s5gma2x";
#   })
#   { src = ./.; }).shellNix.default

    };
    let pre_ = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let pre = if !pre_.is_empty() {
        quote! {
            let (key, value) = #pre_;
        }
    } else {
        quote! {}
    };
    let post_ = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let post = if post_.is_empty() {
        quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
            Ok(x)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }
        }
    } else {
        quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
            Ok(x . #post_)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }}

        fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {
            use ::sanakirja::Transaction;
            #pre
            #post

        fn #name_get <'txn> (&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>> {
            match ::sanakirja::btree::get(&self.txn, &self.#name, key, value) {
                Ok(Some((k, v))) if k == key => Ok(Some(v)),
                Ok(_) => Ok(None),
                Err(e) => {
                    error!("{:?}", e);
                    Err(TxnErr(SanakirjaError::PristineCorrupt))
                }
            }

        fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {
            use ::sanakirja::Transaction;
            if let Ok(x) = self.txn.get(db, key, value) {
                Ok(x)
            } else {
                Err(TxnErr(SanakirjaError::PristineCorrupt))

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

        fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;

        fn #name_get<'txn>(&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>>;

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>>;

    let mut level = 0;

                        return result;

                        if level == 0 {
                            return result;
                        } else {
                            result.push(TokenTree::Punct(p))
                        }

                } else if p.as_char() == '<' {
                    level += 1;
                    result.push(TokenTree::Punct(p))
                } else if level > 0 && p.as_char() == '>' {
                    level -= 1;
                    result.push(TokenTree::Punct(p))

            Some(e) => result.push(e),

            Some(e) => {
                result.push(e)
            },

            ) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<Self::#error>>;

            ) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<Self::#error>>;

            pos: Option<(#key, Option<#value>)>,

            pos: Option<(&#key, Option<&#value>)>,

                k: #key,
                v: Option<#value>

                k: &#key,
                v: Option<&#value>

            pos: Option<(#key, Option<#value>)>,

            pos: Option<(&#key, Option<&#value>)>,

    let pre = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let post = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let pre_init = if !pre.is_empty() {
        quote! { let pos = #pre; }
    } else {
        quote! {}
    };
    let post = if !post.is_empty() {
        quote! { . #post }
    } else {
        quote! {}
    };

                k: #key,
                v: Option<#value>

                k: &#key,
                v: Option<&#value>

                pos: Option<(#key, Option<#value>)>,

                pos: Option<(&#key, Option<&#value>)>,

                #pre_init
                if let Ok((cursor, _)) = txn.txn.set_cursors(&db, pos) {
                    Ok(Cursor {
                        cursor,
                        txn,
                        marker: std::marker::PhantomData,
                    })
                } else {
                    Err(TxnErr(SanakirjaError::PristineCorrupt))

                let mut cursor = ::sanakirja::btree::cursor::Cursor::new(&txn.txn, &db)?;
                if let Some((k, v)) = pos {
                    cursor.set(&txn.txn, k, v)?;

                Ok(Cursor {
                    cursor,
                    txn,
                    k: std::marker::PhantomData,
                    v: std::marker::PhantomData,
                    t: std::marker::PhantomData,
                })

                pos: Option<(#key, Option<#value>)>,

                pos: Option<(&#key, Option<&#value>)>,

                #pre_init
                let mut cursor = if pos.is_some() {
                    if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
                        x
                    } else {
                        return Err(TxnErr(SanakirjaError::PristineCorrupt))
                    }
                } else if let Ok(x) = self.txn.set_cursors_last(&db) {
                    x

                let mut cursor = ::sanakirja::btree::cursor::Cursor::new(&self.txn, &db)?;
                if let Some((k, v)) = pos {
                    cursor.set(&self.txn, k, v)?;

                    return Err(TxnErr(SanakirjaError::PristineCorrupt))
                };

                    cursor.set_last(&self.txn)?;
                }

                    marker: std::marker::PhantomData,

                    k: std::marker::PhantomData,
                    v: std::marker::PhantomData,
                    t: std::marker::PhantomData,

            type #cursor_name = ::sanakirja::Cursor;

                pos: Option<(#key, Option<#value>)>,

                pos: Option<(&#key, Option<&#value>)>,

                #pre_init
                let mut cursor = if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
                    x
                } else {
                    return Err(TxnErr(SanakirjaError::PristineCorrupt))
                };

                let mut cursor = ::sanakirja::btree::cursor::Cursor::new(&self.txn, &db)?;
                if let Some((k, v)) = pos {
                    cursor.set(&self.txn, k, v)?;
                }

                    marker: std::marker::PhantomData,

                    k: std::marker::PhantomData,
                    v: std::marker::PhantomData,
                    t: std::marker::PhantomData,

            ) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = unsafe { ::sanakirja::next(&self.txn, cursor) } {

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = cursor.next(&self.txn) {

                Ok(x #post)

                Ok(x)

            ) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = unsafe { ::sanakirja::prev(&self.txn, cursor) } {

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = cursor.next(&self.txn) {

                Ok(x #post)

                Ok(x)

            impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::RevCursor<T, RT, T::#cursor_name, #key, #value>

            impl<'a, T: #txnt> Iterator for crate::pristine::RevCursor<T, &'a T, T::#cursor_name, #key, #value>

                type Item = Result<(#key, #value), TxnErr<T::#error>>;

                type Item = Result<(&'a #key, &'a #value), TxnErr<T::#error>>;

            impl<T: #txnt, RT: std::ops::Deref<Target = T>>
                crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>

            impl<'a, T: #txnt>
                crate::pristine::Cursor<T, &'a T, T::#cursor_name, #key, #value>

                pub fn prev(&mut self) -> Option<Result<(#key, #value), TxnErr<T::#error>>> {

                pub fn prev(&mut self) -> Option<Result<(&'a #key, &'a #value), TxnErr<T::#error>>> {

            impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>

            impl<'a, T: #txnt> Iterator for crate::pristine::Cursor<T, &'a T, T::#cursor_name, #key, #value>

                type Item = Result<(#key, #value), TxnErr<T::#error>>;

                type Item = Result<(&'a #key, &'a #value), TxnErr<T::#error>>;

            k: #key,
            e: #value,

            k: &#key,
            e: &#value,

            k: #key,
            e: Option<#value>,

            k: &#key,
            e: Option<&#value>,

    let pre_key = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let pre_value = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());

    if pre_key.is_empty() {
        proc_macro::TokenStream::from(quote! {
            fn #put(
                &mut self,
                k: #key,
                v: #value,
            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
            }
            fn #del(
                &mut self,
                k: #key,
                v: Option<#value>,
            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
            }
        })
    } else {
        proc_macro::TokenStream::from(quote! {
            fn #put(
                &mut self,
                k: #key,
                v: #value,
            ) -> Result<bool, TxnErr<Self::#error>> {
                let k = #pre_key;
                let v = #pre_value;
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
            }
            fn #del(
                &mut self,
                k: #key,
                v: Option<#value>,
            ) -> Result<bool, TxnErr<Self::#error>> {
                let k = #pre_key;
                let v = v.map(|v| #pre_value);
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
            }
        })
    }

    proc_macro::TokenStream::from(quote! {
        fn #put(
            &mut self,
            k: &#key,
            v: &#value,
        ) -> Result<bool, TxnErr<Self::#error>> {
            Ok(::sanakirja::btree::put(&mut self.txn, &mut self.#name, k, v).map_err(TxnErr)?)
        }
        fn #del(
            &mut self,
            k: &#key,
            v: Option<&#value>,
        ) -> Result<bool, TxnErr<Self::#error>> {
            Ok(::sanakirja::btree::del(&mut self.txn, &mut self.#name, k, v).map_err(TxnErr)?)
        }
    })

use crate::{config, current_dir};

#[cfg(not(unix))]
mod basic_lock;
#[cfg(unix)]
mod unix_lock;
mod lock {
    #[cfg(not(unix))]
    pub use super::basic_lock::*;
    #[cfg(unix)]
    pub use super::unix_lock::*;
    use std::path::Path;
    pub enum Lock {
        Txn(TxnLock),
        MutTxn(MutTxnLock),
    }

    impl Lock {
        pub async fn mut_txn_lock<P: AsRef<Path>>(p: P) -> Result<Self, anyhow::Error> {
            let pp = p.as_ref().join("db_lock");
            Ok(Lock::MutTxn(mut_txn(&pp).await?))
        }
        pub async fn txn_lock<P: AsRef<Path>>(p: P) -> Result<Self, anyhow::Error> {
            let pp = p.as_ref().join("db_lock");
            Ok(Lock::Txn(txn(&pp).await?))
        }
        pub async fn commit(&mut self) -> Result<(), anyhow::Error> {
            match self {
                Lock::MutTxn(m) => m.commit().await,
                _ => Ok(()),
            }
        }
    }
}
use crate::{config, current_dir};

    pub lock: lock::Lock,

        Self::find_root_with_dot_dir(cur, DOT_DIR, true).await

        Self::find_root_with_dot_dir(cur, DOT_DIR).await

    pub async unsafe fn find_root_immutable(cur: Option<PathBuf>) -> Result<Self, anyhow::Error> {
        Self::find_root_with_dot_dir(cur, DOT_DIR, false).await
    }

        mutable: bool,

            lock: if mutable {
                lock::Lock::mut_txn_lock(&pristine_dir).await?
            } else {
                lock::Lock::txn_lock(&pristine_dir).await?
            },
            pristine: unsafe {
                libpijul::pristine::sanakirja::Pristine::new_nolock(&pristine_dir)?
            },

            pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,

                lock: lock::Lock::mut_txn_lock(&pristine_dir).await?,
                pristine: unsafe {
                    libpijul::pristine::sanakirja::Pristine::new_nolock(&pristine_dir)?
                },

                pristine: libpijul::pristine::sanakirja::Pristine::new(&pristine_dir.join("db"))?,

use libpijul::{Base32, ChannelRef, Hash, Merkle, MutTxnT, MutTxnTExt, TxnTExt};

use libpijul::{Base32, Hash, Merkle, MutTxnT};

use crate::repository::Repository;

    },
    Channel {
        sender: tokio::sync::mpsc::Sender<Vec<u8>>,

        pending: Vec<u8>,

                State::Changelist { ref mut sender } => {

                State::Changelist {
                    ref mut sender,
                    ref mut pending,
                } => {

                    } else if let Ok(data) = std::str::from_utf8(&data) {
                        for l in data.lines() {

                    } else {
                        debug!("{:?}", data);
                        let mut p = 0;
                        while let Some(i) = (&data[p..]).iter().position(|i| *i == b'\n') {
                            let line = if !pending.is_empty() {
                                pending.extend(&data[p..p + i]);
                                &pending
                            } else {
                                &data[p..p + i]
                            };
                            let l = std::str::from_utf8(line)?;

                            pending.clear();
                            p += i + 1;

                        pending.extend(&data[p..]);

                State::Channel { ref mut sender } => {
                    debug!("state channel");
                    sender.send(data).await?
                }

        *self.state.lock().await = State::Changelist { sender };

        *self.state.lock().await = State::Changelist {
            sender,
            pending: Vec::new(),
        };

        Ok(())
    }
    pub async fn clone_channel<T: TxnTExt + MutTxnTExt>(
        &mut self,
        repo: &mut Repository,
        txn: &mut T,
        channel: &mut ChannelRef<T>,
        lazy: bool,
    ) -> Result<(), anyhow::Error> {
        let (sender, mut recv) = tokio::sync::mpsc::channel(10);
        *self.state.lock().await = State::Channel { sender };
        self.run_protocol().await?;
        debug!("clone channel");
        self.c
            .data(format!("channel {}\n", self.channel).as_bytes())
            .await?;
        let progress = indicatif::ProgressBar::new_spinner();
        progress.set_style(
            indicatif::ProgressStyle::default_spinner().template("{spinner} Cloning channel"),
        );
        progress.enable_steady_tick(100);
        *PROGRESS.lock().await = Some(progress);
        let from_dump_alive = {
            let mut from_dump =
                libpijul::pristine::channel_dump::ChannelFromDump::new(txn, channel.clone());
            debug!("receiving channel");
            while let Some(msg) = recv.recv().await {
                debug!("msg = {:?}", msg.len());
                if from_dump.read(&msg)? {
                    debug!("break");
                    break;
                }
            }
            debug!("from dump done");
            from_dump.alive
        };
        if let Some(ref mut progress) = *PROGRESS.lock().await {
            progress.set_style(
                indicatif::ProgressStyle::default_spinner().template("✓ Cloning channel"),
            );
            progress.finish();
        }
        let channel_ = channel.borrow();
        debug!("cloned, now downloading changes");
        let mut hashes = Vec::new();
        if lazy {
            for &ch in from_dump_alive.iter() {
                let h = txn.get_external(ch)?.unwrap();
                hashes.push(h);
            }
        } else {
            for h in txn.log(&channel_, 0)? {
                hashes.push((h?.1).0);
            }
        }
        std::mem::drop(channel_);
        debug!("hashes = {:#?}", hashes);
        self.download_changes_(&hashes, None, &mut repo.changes_dir, true)
            .await?;
        txn.output_repository_no_pending(
            &mut repo.working_copy,
            &repo.changes,
            channel,
            "",
            true,
            None,
        )?;

        if let Ok(pristine) = libpijul::pristine::sanakirja::Pristine::new(&dot_dir) {

        if let Ok(pristine) = libpijul::pristine::sanakirja::Pristine::new(&dot_dir.join("db")) {

                let k = k.unwrap().0;

                debug!("filter_map {:?}", k);
                let k = (*k.unwrap().0).into();

        debug!("deleted");

        let (mut b, (_, state)) = if let Some(last) = txn.last_remote(remote)? {
            last

        let (mut b, state): (_, Merkle) = if let Some((u, v)) = txn.last_remote(remote)? {
            debug!("dichotomy_changelist: {:?} {:?}", u, v);
            (u, (&v.b).into())

            let (mid, (_, state)) = txn.get_remote_state(remote, mid)?.unwrap();

            let (mid, state) = txn.get_remote_state(remote, mid)?.unwrap();

                if remote_state == state {

                if remote_state == state.b {

                    txn.archive_with_state(&changes, &mut channel, state, extra, &mut tarball)?

                    txn.archive_with_state(&changes, &mut channel, &state, extra, &mut tarball)?

                txn.apply_change_ws(&repo.changes, channel, *h, &mut ws)?;

                txn.apply_change_ws(&repo.changes, channel, h, &mut ws)?;

            txn.apply_change_ws(&repo.changes, channel, hash, &mut ws)?;

            txn.apply_change_ws(&repo.changes, channel, &hash, &mut ws)?;

        lazy: bool,

        if let RemoteRepo::Ssh(ref mut s) = self {
            s.clone_channel(repo, txn, channel, lazy).await?;
            let mut to_unrecord = Vec::new();
            let mut found = false;
            for x in txn.iter_rev_remote(&remote.borrow().remote, None)? {
                let (n, (h, s)) = x?;
                debug!("{:?} {:?} {:?}", n, h, s);
                if s == state {
                    found = true;
                    break;
                }
                to_unrecord.push(h);
            }
            if !found {
                bail!("State not found: {:?}", state)
            }
            self.pull(repo, txn, channel, &to_unrecord, &HashSet::new(), false)
                .await?;
            for unrec in to_unrecord.iter() {
                txn.unrecord(&repo.changes, channel, unrec)?;
            }
            return Ok(());
        }

            let (n, (h, s)) = x?;
            debug!("{:?} {:?} {:?}", n, h, s);
            to_pull.push(h);
            if s == state {

            let (n, p) = x?;
            debug!("{:?} {:?}", n, p);
            to_pull.push(p.a.into());
            if p.b == state {

            if repo.changes.has_contents(*c, txn.get_internal(*c)?) {

            let sc = c.into();
            if repo
                .changes
                .has_contents(*c, txn.get_internal(&sc)?.cloned())
            {

            let change = if let Some(i) = txn.get_internal(*c)? {

            let change = if let Some(&i) = txn.get_internal(&sc)? {

                start: libpijul::pristine::ChangePosition(0),
                end: libpijul::pristine::ChangePosition(0),

                start: libpijul::pristine::ChangePosition(0u64.into()),
                end: libpijul::pristine::ChangePosition(0u64.into()),

            if txn.is_alive(&channel, v)? {

            if txn.is_alive(&channel, &v)? {

        lazy: bool,

        if path.is_empty() {
            if let RemoteRepo::Ssh(s) = self {
                return s.clone_channel(repo, txn, local_channel, lazy).await;
            }
        }

            let (_, (h, _)) = x?;
            pullable.push(h)

            let (_, p) = x?;
            pullable.push(p.a.into())

            pos: ChangePosition(caps.name("num").unwrap().as_str().parse().unwrap()),

            pos: ChangePosition(
                caps.name("num")
                    .unwrap()
                    .as_str()
                    .parse::<u64>()
                    .unwrap()
                    .into(),
            ),

            (n, m)

            (n, m.into())

                    change: remote_txn.get_external(p.change)?.unwrap(),

                    change: remote_txn.get_external(&p.change)?.unwrap().into(),

                debug!(
                    "downloading changelist item {:?} {:?} {:?}",
                    n,
                    h.to_base32(),
                    m.to_base32()
                );

                            .get_touched_files(*x, Some(h_int))

                            .get_touched_files(x, Some(h_int))

                    txn.put_remote(remote, n, (h, m))?;

                    txn.put_remote(remote, n, (h.into(), m.into()))?;

        txn.apply_change_ws(store, channel, *c, &mut ws)?;

        txn.apply_change_ws(store, channel, c, &mut ws)?;

    /// 
    /// Users can ignore files and directories by placing the relevant paths
    /// in one or more `.ignore` files using git's pattern syntax.

    #[cfg(unix)]
    #[clap(setting = AppSettings::Hidden)]
    Lock(Lock),

    /// Manage tags (create tags, check out a tag)
    // Tag(Tag),

        #[cfg(unix)]
        SubCommand::Lock(lock) => lock.run().await,

        // SubCommand::Tag(tag) => tag.run().await,

                    .map(|h| (h.unwrap().1).0)

                    .map(|h| (h.unwrap().1).0.into())

                    hashes.push((*h, txn.get_internal(*h)?.unwrap()))

                    hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))

            let mut changes = Vec::new();

            let mut changes: Vec<(Hash, ChangeId, Option<u64>)> = Vec::new();

                    .get_changeset(txn.changes(&channel_), change_id)

                    .get_changeset(txn.changes(&channel_), &change_id)

                changes.push((hash, change_id, n));

                changes.push((hash, change_id, n.map(|&x| x.into())));

                for p in txn.iter_revdep(change_id)? {

                for p in txn.iter_revdep(&change_id)? {

                    if p < change_id {

                    if p < &change_id {

                    } else if p > change_id {

                    } else if p > &change_id {

                        let dep = txn.get_external(d)?.unwrap();

                        let dep: Hash = txn.get_external(d)?.unwrap().into();

        repo.lock.commit().await?;

                    repo.lock.commit().await?;

            repo.lock.commit().await?;

    for x in libpijul::pristine::changeid_log(txn, chan, from)? {
        let (n, (u, _)) = x?;
        debug!("{:?} {:?} {:?}", n, u, from);

    for x in libpijul::pristine::changeid_log(txn, chan, from.into())? {
        let (n, p) = x?;
        let n: u64 = (*n).into();
        debug!("{:?} {:?} {:?}", n, p, from);

        if changediff.insert(u) {
            for y in txn.iter_rev_touched_files(u, None)? {

        if changediff.insert(p.a) {
            for y in txn.iter_rev_touched_files(&p.a, None)? {

                if uu < u {
                    continue;
                } else if uu > u {

                debug_assert!(uu >= &p.a);
                if uu > &p.a {

                inodes.insert(pos);

                inodes.insert(*pos);

    #[clap(long = "tag")]
    pub tag: bool,

                .get_changeset(txn.changes(&channel.borrow()), c)?

                .get_changeset(txn.changes(&channel.borrow()), &c)?

                (h?.1).0

                (h?.1).0.into()

            txn.apply_local_change(&mut channel, &change, hash, &updates)?;

            ::sanakirja::debug::debug(&txn.txn, &[&txn.internal], "internal", true);
            txn.apply_local_change(&mut channel, &change, &hash, &updates)?;

            repo.lock.commit().await?;

                repo.lock.commit().await?;

        let mut repo = Repository::find_root(self.repo_path).await?;

        let repo = Repository::find_root(self.repo_path).await?;

                    repo.lock.commit().await?;

        let mut repo = Repository::find_root(self.repo_path).await?;

        let repo = Repository::find_root(self.repo_path).await?;

        let mut to_upload = Vec::new();

        let mut to_upload: Vec<Hash> = Vec::new();

                if txn.remote_has_state(remote_changes, m)? {

                if txn.remote_has_state(remote_changes, &m)? {

                if !txn.remote_has_change(&remote_changes, h)? {

                if !txn.remote_has_change(&remote_changes, &h)? {

                        to_upload.push(h)

                        to_upload.push(h.into())

                            if txn.get_touched_files(*p, Some(h_int))?.is_some() {
                                to_upload.push(h);

                            if txn.get_touched_files(p, Some(h_int))?.is_some() {
                                to_upload.push(h.into());

                            to_upload.push(h)

                            to_upload.push(h.into())

                                if txn.get_touched_files(*p, Some(h_int))?.is_some() {
                                    to_upload.push(h);

                                if txn.get_touched_files(p, Some(h_int))?.is_some() {
                                    to_upload.push(h.into());

            let mut u = Vec::new();

            let mut u: Vec<libpijul::Hash> = Vec::new();

        repo.lock.commit().await?;

            let mut to_download = Vec::new();

            let mut to_download: Vec<Hash> = Vec::new();

                    let (h, m) = x?.1;

                    let p = x?.1; // (h, m)

                        .channel_has_state(txn.states(&channel.borrow()), m)?

                        .channel_has_state(txn.states(&channel.borrow()), &p.b)?

                    } else if txn.get_revchanges(&channel, h)?.is_none() {
                        to_download.push(h)

                    } else if txn.get_revchanges(&channel, &p.a.into())?.is_none() {
                        to_download.push(p.a.into())

                    change: txn.get_external(x.change).unwrap().unwrap(),

                    change: txn.get_external(&x.change).unwrap().unwrap().into(),

                            .channel_has_state(txn.states(&channel.borrow()), m)?

                            .channel_has_state(txn.states(&channel.borrow()), &m)?

                                    txn.get_rev_touched_files(h_int, Some(inode))

                                    txn.get_rev_touched_files(h_int, Some(&inode))

                                to_download.push(h)

                                to_download.push(h.into())

            debug!("to_download = {:?}", to_download);

            debug!("to_download = {:#?}", to_download);

                txn.apply_change_rec_ws(&repo.changes, &mut channel, *h, &mut ws)?;

                txn.apply_change_rec_ws(&repo.changes, &mut channel, h, &mut ws)?;

            if let Some(int) = txn.get_internal(*d)? {

            if let Some(int) = txn.get_internal(&d.into())? {

                        change: txn.get_external(inode.change)?.unwrap(),

                        change: txn.get_external(&inode.change)?.unwrap().into(),

                .push(libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, i)?.0)

                .push(libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, *i)?.0)

        repo.lock.commit().await?;

                if txn.remote_has_change(rem, d)? {

                if txn.remote_has_change(rem, &d.into())? {

                                let m: libpijul::Merkle = m.into();

                    let m: Merkle = m.into();

                        let h = txn.get_external(p.change)?.unwrap();

                        let h: libpijul::Hash = txn.get_external(&p.change)?.unwrap().into();

                            x.change == h_int
                                || txn.get_touched_files(*x, Some(h_int)).unwrap().is_some()

                            x.change == *h_int
                                || txn.get_touched_files(x, Some(h_int)).unwrap().is_some()

                        let h: Hash = h.into();
                        let m: Merkle = m.into();

                txn.apply_change_ws(&repo.changes, &mut channel, h, &mut ws)?;

                txn.apply_change_ws(&repo.changes, &mut channel, &h, &mut ws)?;

            } else if let Some(cap) = CHANNEL.captures(&buf) {
                let channel = load_channel(&txn, &cap[1])?;
                let channel = channel.borrow();
                for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel)? {
                    o.write_all(&d?)?;
                }
                o.flush()?;

                            state,

                            &state,

            repo.lock.commit().await?;

#[cfg(unix)]
mod lock;
#[cfg(unix)]
pub use lock::*;

    txn.apply_local_change(channel, &pending_change, hash, &recorded.updatables)?;

    txn.apply_local_change(channel, &pending_change, &hash, &recorded.updatables)?;

        let repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

        let repo = unsafe { Repository::find_root(self.repo_path).await? };

                let h = (h?.1).0;

                let h: libpijul::Hash = (h?.1).0.into();

                let header = changes.get_header(&h)?;

                let h: libpijul::Hash = h.into();
                let mrk: libpijul::Merkle = mrk.into();
                let header = changes.get_header(&h.into())?;

        repo.lock.commit().await?;

        let mut repo = Repository::find_root(self.repo_path).await?;

        let repo = Repository::find_root(self.repo_path).await?;

            txn.apply_change_rec(&repo.changes, &mut channel, hash)?

            txn.apply_change_rec(&repo.changes, &mut channel, &hash)?

        repo.lock.commit().await?;

        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

        let repo = Repository::find_root(self.repo_path.clone()).await?;

        repo.lock.commit().await?;

        let repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

        let repo = unsafe { Repository::find_root(self.repo_path).await? };

        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

        let repo = Repository::find_root(self.repo_path.clone()).await?;

        repo.lock.commit().await?;

        let mut repo = Repository::find_root(self.repo_path.clone()).await?;

        let repo = Repository::find_root(self.repo_path.clone()).await?;

        repo.lock.commit().await?;

        let mut repo = unsafe { Repository::find_root_immutable(self.repo_path).await? };

        let mut repo = Repository::find_root(self.repo_path).await?;

                if e.introduced_by.is_root() {

                if e.introduced_by().is_root() {

                self.changes.insert(e.introduced_by);

                self.changes.insert(e.introduced_by());

    /// Only download changes with alive contents
    #[clap(long = "lazy")]
    lazy: bool,

                .clone_state(&mut repo, &mut txn, &mut channel, h, self.lazy)

                .clone_state(&mut repo, &mut txn, &mut channel, h)

                .clone_channel(
                    &mut repo,
                    &mut txn,
                    &mut channel,
                    self.lazy,
                    &self.partial_paths,
                )

                .clone_channel(&mut repo, &mut txn, &mut channel, &self.partial_paths)

        repo.lock.commit().await?;

                let mut repo = Repository::find_root(self.repo_path).await?;

                let repo = Repository::find_root(self.repo_path).await?;

                repo.lock.commit().await?;

                let mut repo = Repository::find_root(self.repo_path).await?;

                let repo = Repository::find_root(self.repo_path).await?;

                repo.lock.commit().await?;

        let repo = unsafe { Repository::find_root_immutable(self.repo_path.clone()).await? };

        let repo = unsafe { Repository::find_root(self.repo_path.clone()).await? };

                (h?.1).0

                (h?.1).0.into()

                    state,

                    &state,

use log::*;

            txn.apply_deps_rec(&repo.changes, &mut channel, hashes.pop().unwrap())?;

            txn.apply_deps_rec(&repo.changes, &mut channel, hashes.last().unwrap())?;

            for hash in hashes.drain(..) {

            for hash in hashes.iter() {

            if let Some(int) = txn.get_internal(*d)? {

            if let Some(int) = txn.get_internal(&d.into())? {
                debug!("int = {:?}", int);

                    debug!("{:?}", inode);

                    touched.insert(inode);

                    touched.insert(*inode);

        repo.lock.commit().await?;

"src/commands/tag.rs",

git = [ "git2", "sanakirja/git2" ]

git = [ "git2" ]

sanakirja = { version = "0.15.8", features = ["crc32"] }

sanakirja = { version = "1.1.2", features = ["crc32"] }

        if let Some(inode) = txn.get_revinodes(pos, None)? {
            del_inodes_with_rev(txn, inode, pos)?;

        if let Some(&inode) = txn.get_revinodes(&pos, None)? {
            del_inodes_with_rev(txn, &inode, &pos)?;

            txn.find_block_end(txn.graph(channel), internal_pos(txn, &e.from, change_id)?)?;

            *txn.find_block_end(txn.graph(channel), internal_pos(txn, &e.from, change_id)?)?;

            if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
                source_parent = Some(e.dest);

            if e.flag().contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
                source_parent = Some(e.dest());

        } else if let Some(inode) = txn.get_revinodes(source_parent, None)? {

        } else if let Some(&inode) = txn.get_revinodes(&source_parent, None)? {

        .get_file_name(|h| txn.get_external(h).unwrap(), source, &mut name)

        .get_file_name(|h| txn.get_external(&h).unwrap().map(From::from), source, &mut name)

    if let Some(inode) = txn.get_revinodes(dest, None)? {
        Ok(inode)

    if let Some(inode) = txn.get_revinodes(&dest, None)? {
        Ok(*inode)

        put_tree_with_rev(txn, file_id.as_file_id(), inode)?;
        put_inodes_with_rev(txn, inode, dest)?;

        put_tree_with_rev(txn, &file_id, &inode)?;
        put_inodes_with_rev(txn, &inode, &dest)?;

        if !e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {

        if !e.flag().contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {

        if e.flag.contains(EdgeFlags::DELETED) {
            debug!("deleted: {:?}", e.introduced_by);

        if e.flag().contains(EdgeFlags::DELETED) {
            debug!("deleted: {:?}", e.introduced_by());

                .get_changeset(txn.changes(channel), e.introduced_by)?

                .get_changeset(txn.changes(channel), &e.introduced_by())?

                    *v = e.dest

                    *v = e.dest()

                next = Some((age, e.dest))

                next = Some((age, e.dest()))

            next = Some((0, e.dest));

            next = Some((&L64(0), e.dest()));

    txn.find_block_end(txn.graph(channel), next.unwrap().1)

    Ok(*txn.find_block_end(txn.graph(channel), next.unwrap().1)?)

            if let Some(inode) = txn.get_revinodes(position, None)? {
                del_inodes_with_rev(txn, inode, position)?;

            if let Some(&inode) = txn.get_revinodes(&position, None)? {
                del_inodes_with_rev(txn, &inode, &position)?;

    let change_id = if let Some(h) = txn.get_internal(*hash)? {

    let change_id = if let Some(&h) = txn.get_internal(&hash.into())? {

        assert!(txn.get_revdep(change_id, None)?.is_none());
        while txn.del_dep(change_id, None)? {}
        txn.del_external(change_id, None)?;
        txn.del_internal(*hash, None)?;

        assert!(txn.get_revdep(&change_id, None)?.is_none());
        while txn.del_dep(&change_id, None)? {}
        txn.del_external(&change_id, None)?;
        txn.del_internal(&hash.into(), None)?;

            let dep = txn.get_internal(*dep)?.unwrap();
            txn.del_revdep(dep, Some(change_id))?;

            let dep = *txn.get_internal(&dep.into())?.unwrap();
            txn.del_revdep(&dep, Some(&change_id))?;

    let timestamp = if let Some(ts) = txn.get_changeset(txn.changes(channel), change_id)? {

    let timestamp = if let Some(&ts) = txn.get_changeset(txn.changes(channel), &change_id)? {

    for x in txn.iter_revdep(change_id)? {

    for x in txn.iter_revdep(&change_id)? {

        if p < change_id {
            continue;
        } else if p > change_id {

        assert!(*p >= change_id);
        if *p > change_id {

                dependent: d,

                dependent: *d,

    txn.del_changes(channel, change_id, timestamp)?;

    txn.del_changes(channel, change_id, timestamp.into())?;

            && txn.get_changeset(txn.changes(&br), change_id)?.is_some()

            && txn.get_changeset(txn.changes(&br), &change_id)?.is_some()

                )?

                )?;

    del: Vec<Edge>,

    del: Vec<SerializedEdge>,

    del_edges: Vec<(Vertex<ChangeId>, Edge)>,

    del_edges: Vec<(Vertex<ChangeId>, SerializedEdge)>,

    while let Ok(vertex) = txn.find_block(channel, pos) {

    while let Ok(&vertex) = txn.find_block(channel, pos) {

            if !e.flag.is_deleted() {
                if e.flag.is_parent() {
                    if !e.flag.is_folder() {
                        let up_v = txn.find_block_end(channel, e.dest)?;
                        ws.up.insert(up_v, new_vertex.inode);

            if !e.flag().is_deleted() {
                if e.flag().is_parent() {
                    if !e.flag().is_folder() {
                        let up_v = txn.find_block_end(channel, e.dest())?;
                        ws.up.insert(*up_v, new_vertex.inode);

                    let down_v = txn.find_block(channel, e.dest)?;
                    ws.down.insert(down_v, new_vertex.inode);
                    if e.flag.is_folder() {
                        ws.apply.missing_context.files.insert(down_v);

                    let down_v = txn.find_block(channel, e.dest())?;
                    ws.down.insert(*down_v, new_vertex.inode);
                    if e.flag().is_folder() {
                        ws.apply.missing_context.files.insert(*down_v);

            ws.del.push(e)

            ws.del.push(*e)

            let (a, b) = if e.flag.is_parent() {
                (txn.find_block_end(channel, e.dest)?, vertex)

            let (a, b) = if e.flag().is_parent() {
                (*txn.find_block_end(channel, e.dest())?, vertex)

                (vertex, txn.find_block(channel, e.dest)?)

                (vertex, *txn.find_block(channel, e.dest())?)

                e.flag - EdgeFlags::PARENT,

                e.flag() - EdgeFlags::PARENT,

                e.introduced_by,

                e.introduced_by(),

        if !is_alive(txn, channel, up)? {

        if !is_alive(txn, channel, &up)? {

        if !is_alive(txn, channel, down)? {

        if !is_alive(txn, channel, &down)? {

            let parent = txn.find_block_end(channel, parent.dest)?;

            let parent = txn.find_block_end(channel, parent.dest())?;

                ws.parents.insert(parent);

                ws.parents.insert(*parent);

    let ext = txn.get_external(change_id)?.unwrap();

    let ext: Hash = txn.get_external(&change_id)?.unwrap().into();

        change: txn.get_external(b.change)?,

        change: txn.get_external(&b.change)?.map(From::from),

        if e.flag.contains(EdgeFlags::PARENT)
            || e.dest != b.start_pos()
            || e.introduced_by.is_root()
            || e.introduced_by == current_id

        if e.flag().contains(EdgeFlags::PARENT)
            || e.dest() != b.start_pos()
            || e.introduced_by().is_root()
            || e.introduced_by() == current_id

        stack.push(e.introduced_by)

        stack.push(e.introduced_by())

            .change_deletes_position(|c| txn.get_external(c).unwrap(), s, pos)

            .change_deletes_position(|c| txn.get_external(&c).unwrap().map(From::from), s, pos)

            } else if let Some(i) = txn.get_internal(next)? {
                stack.push(i)

            } else if let Some(i) = txn.get_internal(&next.into())? {
                stack.push(*i)

            if e.flag.contains(EdgeFlags::PARENT) {
                let u = txn.find_block_end(channel, e.dest)?;
                e.flag -= EdgeFlags::PARENT;
                del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)?;

            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())?;

                let w = txn.find_block(channel, e.dest)?;
                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)?;

                let w = *txn.find_block(channel, e.dest())?;
                del_graph_with_rev(txn, channel, e.flag(), v, w, e.introduced_by())?;

    ws.stack.push(txn.find_block(channel, to)?);

    ws.stack.push(*txn.find_block(channel, to)?);

            if !(e.introduced_by == change_id || e.flag & EdgeFlags::bp() == EdgeFlags::PARENT) {

            if !(e.introduced_by() == change_id || e.flag() & EdgeFlags::bp() == EdgeFlags::PARENT) {

            if e.flag.contains(EdgeFlags::PARENT) {
                ws.stack.push(txn.find_block_end(channel, e.dest)?)

            if e.flag().contains(EdgeFlags::PARENT) {
                ws.stack.push(*txn.find_block_end(channel, e.dest())?)

                ws.stack.push(txn.find_block(channel, e.dest)?)

                ws.stack.push(*txn.find_block(channel, e.dest())?)

            if e.introduced_by == change_id {
                ws.del_edges.push((v, e))

            if e.introduced_by() == change_id {
                ws.del_edges.push((v, *e))

    let change_hash = txn.get_external(change_id)?.unwrap();

    let change_hash: Hash = txn.get_external(&change_id)?.unwrap().into();

        None,

    debug_to_file(&txn, &channel.borrow(), "debug_un0")?;

    debug_to_file(&txn, &channel.borrow(), "debug_un1")?;

        None,

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true)?;

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

    assert_eq!(repo.list_files(), vec!["file"]);

    // Checking that unrecord doesn't delete `dir`, and moves `file`
    // back to the root.
    let mut files = repo.list_files();
    files.sort();
    assert_eq!(files, vec!["dir", "file"]);

    apply::apply_change(&changes, &mut txn2, &mut channel2, h0)?;
    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true)?;
    apply::apply_change(&changes, &mut txn3, &mut channel3, h0)?;
    output::output_repository_no_pending(&mut repo3, &changes, &mut txn3, &mut channel3, "", true)?;

    apply::apply_change(&changes, &mut txn2, &mut channel2, &h0)?;
    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true, None)?;
    apply::apply_change(&changes, &mut txn3, &mut channel3, &h0)?;
    output::output_repository_no_pending(&mut repo3, &changes, &mut txn3, &mut channel3, "", true, None)?;

    apply::apply_change(&changes, &mut txn, &mut channel, h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel, h3)?;
    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel, &h3)?;
    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

    apply::apply_change(&changes, &mut txn2, &mut channel2, h0)?;
    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true)?;

    apply::apply_change(&changes, &mut txn2, &mut channel2, &h0)?;
    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true, None)?;

    apply::apply_change(&changes, &mut txn, &mut channel, h2)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h2)?;

        None,

    apply::apply_change(&changes, &mut txn2, &mut channel2, h1)?;

    apply::apply_change(&changes, &mut txn2, &mut channel2, &h1)?;

        None,

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true)?;

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

        None,

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true)?;
    let files = repo.list_files();
    if !files.is_empty() {
        panic!("Files should be empty {:?}", files);
    }

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;
    // Checking that unrecord doesn't delete files on the filesystem,
    // but updates the tree/revtree tables.
    let mut files = repo.list_files();
    files.sort();
    assert_eq!(files, &["dir", "dir/file"]);

        None,

        None,

    if !files.is_empty() {
        panic!("Files should be empty {:?}", files);
    }

    // Unrecording a file addition shouldn't delete the file.
    assert_eq!(files, &["file"]);

    apply::apply_change(&changes, &mut txn, &mut channel, b)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &b)?;

        None,

        None,

    apply::apply_change(&changes, &mut txn, &mut channel, h_inv)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h_inv)?;

        None,

        None,

    let r = repo.read_file("file", &mut buf);

    repo.read_file("file", &mut buf).unwrap();

        assert!(r.is_err())

        assert_eq!(std::str::from_utf8(&buf), Ok("a\nb\nc\n"));

    apply::apply_change(&changes, &mut txn, &mut channel2, h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel2, &h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel, h2)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h2)?;

        None,

    apply::apply_change(&changes, &mut txn, &mut channel2, h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel2, &h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel, h2)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h2)?;

        None,

    apply::apply_change(&changes, &mut txn, &mut channel2, h1)?;

    apply::apply_change(&changes, &mut txn, &mut channel2, &h1)?;

        apply::apply_change(&changes, &mut txn, &mut channel2, r).unwrap();

        apply::apply_change(&changes, &mut txn, &mut channel2, &r).unwrap();

        None,

    apply::apply_change(&changes, &mut txn, &mut channel2, h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel2, &h0)?;

    apply::apply_change(&changes, &mut txn, &mut channel, h2)?;

    apply::apply_change(&changes, &mut txn, &mut channel, &h2)?;

fn rollback_conflict_resolution_simple() -> Result<(), anyhow::Error> {

fn rollback_conflict_resolution_simple() {

    let env = pristine::sanakirja::Pristine::new_anon()?;

    let env = pristine::sanakirja::Pristine::new_anon().unwrap();

    let mut channela = txn.open_or_create_channel("main")?;

    let mut channela = txn.open_or_create_channel("main").unwrap();

    txn.add_file("file")?;
    record_all(&mut repo, &changes, &mut txn, &mut channela, "")?;

    txn.add_file("file").unwrap();
    record_all(&mut repo, &changes, &mut txn, &mut channela, "").unwrap();

    let mut channelb = txn.fork(&channela, "other")?;

    let mut channelb = txn.fork(&channela, "other").unwrap();

        w.write_all(b"a\nx\nb\n")?;

        w.write_all(b"a\nx\nb\n").unwrap();

    })?;
    let ha = record_all(&mut repo, &changes, &mut txn, &mut channela, "")?;

    }).unwrap();
    let ha = record_all(&mut repo, &changes, &mut txn, &mut channela, "").unwrap();

        w.write_all(b"a\ny\nb\n")?;

        w.write_all(b"a\ny\nb\n").unwrap();

    })?;
    let hb = record_all(&mut repo, &changes, &mut txn, &mut channelb, "")?;

    }).unwrap();
    let hb = record_all(&mut repo, &changes, &mut txn, &mut channelb, "").unwrap();

    apply::apply_change(&changes, &mut txn, &mut channelb, ha)?;
    apply::apply_change(&changes, &mut txn, &mut channela, hb)?;

    apply::apply_change(&changes, &mut txn, &mut channelb, &ha).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channela, &hb).unwrap();

    debug_to_file(&txn, &channela.borrow(), "debuga")?;
    debug_to_file(&txn, &channelb.borrow(), "debugb")?;

    debug_to_file(&txn, &channela.borrow(), "debuga").unwrap();
    debug_to_file(&txn, &channelb.borrow(), "debugb").unwrap();

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channela, "", true)?;

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channela, "", true, None).unwrap();

    repo.read_file("file", &mut buf)?;

    repo.read_file("file", &mut buf).unwrap();

    let conflict: Vec<_> = std::str::from_utf8(&buf)?.lines().collect();

    let conflict: Vec<_> = std::str::from_utf8(&buf).unwrap().lines().collect();

            writeln!(w, "{}", l)?

            writeln!(w, "{}", l).unwrap()

    })?;