jcdickinson/pijul - Change YN63NUZO4LVJ7XPMURDULTXBVJKW5MVCTZ24R7Z52QMHO3HPDUVQC

Sanakirja 1.0

Created by pmeunier on February 26, 2021

YN63NUZO4LVJ7XPMURDULTXBVJKW5MVCTZ24R7Z52QMHO3HPDUVQC

Dependencies

In channels

main

Change contents

Replacement in shell.nix at line 1 [18.12]

B:BD[18.12] → [19.248286:248496]

B:BD[19.248496] → [20.0:35]

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

[18.12]

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

Deletion in pijul-macros/src/lib.rs at line 57 [18.445]

B:BD[21.178] → [21.178:185]

∅:D[21.185] → [18.2144:2496]

B:BD[18.2144] → [18.2144:2496]

B:BD[18.2496] → [21.186:370]

∅:D[21.370] → [18.2553:2566]

B:BD[18.2553] → [18.2553:2566]

B:BD[18.2566] → [21.371:555]

    };
    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))
        }}

Replacement in pijul-macros/src/lib.rs at line 59 [18.445]

B:BD[18.2682] → [21.556:681]

∅:D[21.681] → [18.2800:2877]

B:BD[18.2800] → [18.2800:2877]

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

[18.2682]

[18.2877]

        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))
                }
            }

Replacement in pijul-macros/src/lib.rs at line 92 [18.445]

B:BD[18.3671] → [21.868:1006]

∅:D[21.1006] → [18.3802:3844]

B:BD[18.3802] → [18.3802:3844]

B:BD[18.3844] → [21.1007:1169]

        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))

[18.3671]

[21.1169]

        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))
                }

Replacement in pijul-macros/src/lib.rs at line 124 [18.445]

B:BD[18.4594] → [21.1370:1492]

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

[18.4594]

[18.4709]

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

Replacement in pijul-macros/src/lib.rs at line 148 [18.445]

B:BD[18.5483] → [21.1679:1827]

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

[18.5483]

[18.5624]

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

Insertion in pijul-macros/src/lib.rs at line 155 [18.445]
[18.5778]
[18.5778]
```
    let mut level = 0;
```

Replacement in pijul-macros/src/lib.rs at line 161 [18.445]

B:BD[18.5941] → [18.5941:5980]

                        return result;

[18.5941]

[18.5980]

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

Insertion in pijul-macros/src/lib.rs at line 167 [18.445]

[18.6002]

                } 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))

Replacement in pijul-macros/src/lib.rs at line 177 [18.445]

B:BD[18.6112] → [18.6112:6151]

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

[18.6112]

[18.6151]

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

Replacement in pijul-macros/src/lib.rs at line 255 [18.445]

B:BD[18.8573] → [21.2262:2333]

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

[18.8573]

[18.8641]

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

Replacement in pijul-macros/src/lib.rs at line 259 [18.445]

B:BD[18.8753] → [21.2334:2405]

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

[18.8753]

[18.8794]

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

Replacement in pijul-macros/src/lib.rs at line 267 [18.445]

B:BD[18.9004] → [18.9004:9053]

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

[18.9004]

[21.2406]

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

Replacement in pijul-macros/src/lib.rs at line 279 [18.445]

B:BD[18.9347] → [18.9347:9406]

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

[18.9347]

[18.9406]

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

Replacement in pijul-macros/src/lib.rs at line 290 [18.445]

B:BD[18.9668] → [18.9668:9717]

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

[18.9668]

[18.9717]

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

Deletion in pijul-macros/src/lib.rs at line 354 [18.445]

B:BD[18.11796] → [18.11796:12184]

    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! {}
    };

Replacement in pijul-macros/src/lib.rs at line 358 [18.445]

B:BD[18.12316] → [18.12316:12375]

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

[18.12316]

[22.0]

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

Replacement in pijul-macros/src/lib.rs at line 373 [18.445]

B:BD[18.12795] → [18.12795:12848]

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

[18.12795]

[22.111]

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

Replacement in pijul-macros/src/lib.rs at line 375 [18.445]

∅:D[22.213] → [18.12925:12951]

∅:D[21.2746] → [18.12925:12951]

B:BD[18.12925] → [18.12925:12951]

B:BD[18.12951] → [21.2747:2820]

B:BD[21.2820] → [22.214:246]

∅:D[22.246] → [21.2859:3091]

B:BD[21.2859] → [21.2859:3091]

                #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))

[22.213]

[18.13156]

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

Insertion in pijul-macros/src/lib.rs at line 379 [18.445]

[18.13174]

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

Replacement in pijul-macros/src/lib.rs at line 397 [18.445]

B:BD[18.13442] → [18.13442:13495]

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

[18.13442]

[21.3092]

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

Replacement in pijul-macros/src/lib.rs at line 399 [18.445]

∅:D[21.3212] → [18.13583:13661]

B:BD[18.13583] → [18.13583:13661]

B:BD[18.13661] → [21.3213:3532]

                #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

[21.3212]

[18.13714]

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

Replacement in pijul-macros/src/lib.rs at line 403 [18.445]

B:BD[18.13739] → [21.3533:3605]

∅:D[21.3605] → [18.13790:13809]

B:BD[18.13790] → [18.13790:13809]

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

[18.13739]

[21.3606]

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

Replacement in pijul-macros/src/lib.rs at line 408 [18.445]

B:BD[18.13903] → [18.13903:13957]

                    marker: std::marker::PhantomData,

[18.13903]

[21.3645]

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

Deletion in pijul-macros/src/lib.rs at line 416 [18.445]
B:BD[18.14056] → [18.14056:14109]
```
            type #cursor_name = ::sanakirja::Cursor;
```

Replacement in pijul-macros/src/lib.rs at line 419 [18.445]

B:BD[18.14241] → [18.14241:14294]

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

[18.14241]

[22.247]

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

Replacement in pijul-macros/src/lib.rs at line 421 [18.445]

∅:D[22.357] → [18.14379:14405]

∅:D[21.3782] → [18.14379:14405]

B:BD[18.14379] → [18.14379:14405]

B:BD[18.14405] → [21.3783:4007]

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

[22.357]

[22.358]

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

Replacement in pijul-macros/src/lib.rs at line 428 [18.445]

B:BD[18.14563] → [18.14563:14617]

                    marker: std::marker::PhantomData,

[18.14563]

[21.4043]

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

Replacement in pijul-macros/src/lib.rs at line 437 [18.445]

B:BD[18.14808] → [21.4063:4226]

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

[18.14808]

[21.4226]

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

Replacement in pijul-macros/src/lib.rs at line 443 [18.445]
B:BD[21.4364] → [21.4364:4392]
```
                Ok(x #post)
```
[21.4364]
[18.14942]
```
                Ok(x)
```

Replacement in pijul-macros/src/lib.rs at line 448 [18.445]

B:BD[18.15095] → [21.4393:4556]

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

[18.15095]

[21.4556]

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

Replacement in pijul-macros/src/lib.rs at line 454 [18.445]
B:BD[21.4694] → [21.4694:4722]
```
                Ok(x #post)
```
[21.4694]
[18.15229]
```
                Ok(x)
```

Replacement in pijul-macros/src/lib.rs at line 504 [18.445]

B:BD[18.16490] → [21.5212:5350]

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

[18.16490]

[18.16627]

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

Replacement in pijul-macros/src/lib.rs at line 506 [18.445]

B:BD[18.16641] → [21.5351:5422]

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

[18.16641]

[21.5422]

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

Replacement in pijul-macros/src/lib.rs at line 518 [18.445]

B:BD[18.16909] → [18.16909:16910]

B:BD[18.16910] → [21.5712:5772]

∅:D[21.5772] → [18.16969:17047]

B:BD[18.16969] → [18.16969:17047]


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

[18.16909]

[18.17047]

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

Replacement in pijul-macros/src/lib.rs at line 521 [18.445]

B:BD[18.17061] → [21.5773:5867]

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

[18.17061]

[21.5867]

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

Replacement in pijul-macros/src/lib.rs at line 529 [18.445]

B:BD[18.17218] → [21.6098:6233]

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

[18.17218]

[18.17352]

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

Replacement in pijul-macros/src/lib.rs at line 531 [18.445]

B:BD[18.17366] → [21.6234:6305]

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

[18.17366]

[21.6305]

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

Replacement in pijul-macros/src/lib.rs at line 568 [18.445]

B:BD[18.18405] → [18.18405:18449]

            k: #key,
            e: #value,

[18.18405]

[21.6782]

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

Replacement in pijul-macros/src/lib.rs at line 573 [18.445]

B:BD[18.18554] → [18.18554:18606]

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

[18.18554]

[21.6832]

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

Deletion in pijul-macros/src/lib.rs at line 600 [18.445]

∅:D[21.7068] → [18.19400:19583]

B:BD[18.19400] → [18.19400:19583]

B:BD[18.19583] → [21.7069:7070]


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

Replacement in pijul-macros/src/lib.rs at line 601 [18.445]

B:BD[18.19625] → [21.7071:7072]

∅:D[21.7072] → [18.19625:19700]

B:BD[18.19625] → [18.19625:19700]

B:BD[18.19727] → [18.19727:19827]

B:BD[18.19827] → [21.7073:7215]

∅:D[21.7215] → [18.19946:19960]

B:BD[18.19946] → [18.19946:19960]

B:BD[18.19987] → [18.19987:20095]

B:BD[18.20095] → [21.7216:7358]

∅:D[21.7358] → [18.20214:20299]

B:BD[18.20214] → [18.20214:20299]

B:BD[18.20326] → [18.20326:20426]

B:BD[18.20426] → [21.7359:7413]

∅:D[23.219] → [18.20473:20543]

∅:D[21.7413] → [18.20473:20543]

B:BD[18.20473] → [18.20473:20543]

B:BD[18.20543] → [21.7414:7502]

∅:D[21.7502] → [18.20615:20629]

B:BD[18.20615] → [18.20615:20629]

B:BD[18.20656] → [18.20656:20764]

B:BD[18.20764] → [21.7503:7557]

∅:D[23.265] → [18.20811:20892]

∅:D[21.7557] → [18.20811:20892]

B:BD[18.20811] → [18.20811:20892]

B:BD[18.20892] → [21.7558:7646]

∅:D[21.7646] → [18.20964:20995]

B:BD[18.20964] → [18.20964:20995]


    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)?)
            }
        })
    }

[18.19625]

[18.20995]

    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)?)
        }
    })

Insertion in pijul/src/repository.rs at line 4 [18.21431]
[18.21541]
[21.7666]
```
use crate::{config, current_dir};
```

Deletion in pijul/src/repository.rs at line 8 [18.21431]

B:BD[24.39] → [25.0:282]


#[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),
    }

Deletion in pijul/src/repository.rs at line 9 [18.21431]

B:BD[24.40] → [25.283:894]

∅:D[25.894] → [21.7685:7719]

B:BD[24.40] → [21.7685:7719]

∅:D[21.7719] → [24.81:82]

B:BD[24.81] → [24.81:82]

    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};

Deletion in pijul/src/repository.rs at line 10 [18.21431]
B:BD[18.21565] → [25.895:921]
```
    pub lock: lock::Lock,
```

Replacement in pijul/src/repository.rs at line 54 [18.21431]

B:BD[25.1004] → [25.1004:1067]

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

[25.1004]

[18.23034]

        Self::find_root_with_dot_dir(cur, DOT_DIR).await

Deletion in pijul/src/repository.rs at line 57 [18.21431]

B:BD[18.23041] → [25.1068:1238]

    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
    }

Deletion in pijul/src/repository.rs at line 60 [18.21431]
B:BD[18.23129] → [25.1280:1303]
```
        mutable: bool,
```

Replacement in pijul/src/repository.rs at line 79 [18.21431]

B:BD[18.23883] → [25.1304:1623]

            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)?
            },

[18.23883]

[18.23967]

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

Replacement in pijul/src/repository.rs at line 105 [18.21431]

B:BD[18.24885] → [25.1714:1926]

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

[18.24885]

[18.24973]

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

Replacement in pijul/src/remote/ssh.rs at line 13 [18.25380]
∅:D[26.66] → [27.0:80]
B:BD[24.156] → [27.0:80]
```
use libpijul::{Base32, ChannelRef, Hash, Merkle, MutTxnT, MutTxnTExt, TxnTExt};
```
[26.66]
[24.251]
```
use libpijul::{Base32, Hash, Merkle, MutTxnT};
```
Deletion in pijul/src/remote/ssh.rs at line 20 [18.25380]
B:BD[24.331] → [24.331:366]
```
use crate::repository::Repository;
```
Replacement in pijul/src/remote/ssh.rs at line 268 [18.25380]
∅:D[26.135] → [28.659:732]
B:BD[28.659] → [28.659:732]
```
    },
    Channel {
        sender: tokio::sync::mpsc::Sender<Vec<u8>>,
```
[26.135]
[28.732]
```
        pending: Vec<u8>,
```

Replacement in pijul/src/remote/ssh.rs at line 475 [18.25380]

B:BD[28.5725] → [28.5725:5783]

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

[28.5725]

[28.5783]

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

Replacement in pijul/src/remote/ssh.rs at line 483 [18.25380]

B:BD[28.5981] → [28.5981:6103]

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

[28.5981]

[28.6103]

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

Insertion in pijul/src/remote/ssh.rs at line 500 [18.25380]

[28.6492]

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

Insertion in pijul/src/remote/ssh.rs at line 503 [18.25380]

[28.6518]

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

Deletion in pijul/src/remote/ssh.rs at line 506 [18.25380]

B:BD[29.18] → [29.18:163]

∅:D[29.163] → [28.6540:6558]

B:BD[28.6540] → [28.6540:6558]

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

Replacement in pijul/src/remote/ssh.rs at line 698 [18.25380]

B:BD[28.8468] → [27.312:377]

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

[28.8468]

[18.42222]

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

Deletion in pijul/src/remote/ssh.rs at line 858 [18.25380]

∅:D[28.9964] → [18.49799:49821]

B:BD[18.49799] → [18.49799:49821]

B:BD[18.49821] → [27.402:459]

∅:D[27.459] → [18.49868:50033]

B:BD[18.49868] → [18.49868:50033]

B:BD[18.50033] → [28.9965:10092]

∅:D[28.10092] → [18.50033:50069]

B:BD[18.50033] → [18.50033:50069]

B:BD[18.50069] → [28.10093:10126]

∅:D[28.10126] → [18.50069:50173]

B:BD[18.50069] → [18.50069:50173]

B:BD[18.50173] → [28.10127:10128]

B:BD[28.10128] → [30.282:520]

B:BD[30.520] → [31.1458:1507]

∅:D[30.520] → [18.50173:50331]

∅:D[31.1507] → [18.50173:50331]

∅:D[28.10128] → [18.50173:50331]

B:BD[18.50173] → [18.50173:50331]

B:BD[18.50331] → [29.210:251]

∅:D[29.251] → [28.10129:10183]

B:BD[18.50331] → [28.10129:10183]

B:BD[28.10183] → [29.252:301]

∅:D[29.301] → [28.10183:10226]

B:BD[28.10183] → [28.10183:10226]

B:BD[28.10226] → [29.302:339]

∅:D[29.339] → [28.10226:10253]

B:BD[28.10226] → [28.10226:10253]

∅:D[28.10253] → [18.51267:51299]

B:BD[18.51267] → [18.51267:51299]

B:BD[18.51299] → [29.340:378]

∅:D[29.378] → [18.51299:51338]

B:BD[18.51299] → [18.51299:51338]

B:BD[18.51338] → [31.1508:1754]

∅:D[30.548] → [18.51338:51533]

∅:D[31.1754] → [18.51338:51533]

B:BD[18.51338] → [18.51338:51533]

B:BD[18.51533] → [21.8103:8159]

∅:D[21.8159] → [18.51716:51779]

B:BD[18.51716] → [18.51716:51779]

B:BD[18.51779] → [21.8160:8245]

∅:D[21.8245] → [18.52059:52117]

B:BD[18.52059] → [18.52059:52117]

B:BD[18.52117] → [29.379:421]

B:BD[29.421] → [32.619:694]

∅:D[29.501] → [18.52289:52310]

∅:D[32.694] → [18.52289:52310]

∅:D[28.10334] → [18.52289:52310]

B:BD[18.52289] → [18.52289:52310]

B:BD[18.52310] → [33.43:169]

B:BD[33.202] → [33.202:236]

B:BD[33.236] → [34.0:18]

∅:D[34.18] → [33.236:248]

B:BD[33.236] → [33.236:248]

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

Replacement in pijul/src/remote/mod.rs at line 95 [18.52474]

B:BD[18.54479] → [18.54479:54566]

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

[18.54479]

[18.54566]

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

Replacement in pijul/src/remote/mod.rs at line 191 [18.52474]

B:BD[21.8428] → [21.8428:8466]

                let k = k.unwrap().0;

[21.8428]

[21.8466]

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

Insertion in pijul/src/remote/mod.rs at line 204 [18.52474]
[18.57429]
[26.987]
```
        debug!("deleted");
```

Replacement in pijul/src/remote/mod.rs at line 222 [18.52474]

B:BD[18.57695] → [21.8606:8687]

∅:D[21.8687] → [18.57775:57792]

B:BD[18.57775] → [18.57775:57792]

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

[18.57695]

[18.57792]

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

Replacement in pijul/src/remote/mod.rs at line 240 [18.52474]

B:BD[18.58358] → [21.8688:8769]

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

[18.58358]

[35.1790]

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

Replacement in pijul/src/remote/mod.rs at line 244 [18.52474]

B:BD[18.58637] → [18.58637:58680]

                if remote_state == state {

[18.58637]

[18.58680]

                if remote_state == state.b {

Replacement in pijul/src/remote/mod.rs at line 296 [18.52474]

∅:D[21.9035] → [18.61408:61504]

B:BD[18.61408] → [18.61408:61504]

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

[21.9035]

[18.61504]

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

Replacement in pijul/src/remote/mod.rs at line 460 [18.52474]

∅:D[30.1048] → [18.70519:70594]

B:BD[18.70519] → [18.70519:70594]

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

[30.1048]

[18.70594]

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

Replacement in pijul/src/remote/mod.rs at line 523 [18.52474]

B:BD[18.72852] → [18.72852:72925]

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

[18.72852]

[18.72925]

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

Deletion in pijul/src/remote/mod.rs at line 536 [18.52474]
B:BD[18.73215] → [18.73215:73235]
```
        lazy: bool,
```

Deletion in pijul/src/remote/mod.rs at line 540 [18.52474]

B:BD[18.73416] → [18.73416:73610]

B:BD[18.73610] → [21.9171:9284]

∅:D[21.9284] → [18.73694:73931]

B:BD[18.73694] → [18.73694:73931]

B:BD[18.73931] → [21.9285:9339]

∅:D[21.9339] → [18.74000:74014]

B:BD[18.74000] → [18.74000:74014]

B:BD[18.74014] → [26.2559:2664]

∅:D[36.819] → [18.74109:74269]

∅:D[26.2664] → [18.74109:74269]

B:BD[18.74109] → [18.74109:74269]

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

Replacement in pijul/src/remote/mod.rs at line 543 [18.52474]

B:BD[21.9404] → [21.9404:9438]

∅:D[21.9438] → [18.74411:74515]

B:BD[18.74411] → [18.74411:74515]

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

[21.9404]

[18.74515]

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

Replacement in pijul/src/remote/mod.rs at line 584 [18.52474]

B:BD[18.76104] → [21.9490:9560]

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

[18.76104]

[18.76173]

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

Replacement in pijul/src/remote/mod.rs at line 598 [18.52474]

B:BD[18.76443] → [21.9561:9627]

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

[18.76443]

[18.76508]

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

Replacement in pijul/src/remote/mod.rs at line 606 [18.52474]

B:BD[18.76738] → [18.76738:76860]

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

[18.76738]

[18.76860]

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

Replacement in pijul/src/remote/mod.rs at line 610 [18.52474]

B:BD[18.76925] → [21.9628:9672]

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

[18.76925]

[27.899]

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

Deletion in pijul/src/remote/mod.rs at line 626 [18.52474]
B:BD[18.77897] → [18.77897:77917]
```
        lazy: bool,
```

Deletion in pijul/src/remote/mod.rs at line 628 [18.52474]

B:BD[18.77979] → [18.77979:78008]

B:BD[18.78008] → [37.328:453]

∅:D[37.453] → [18.78205:78229]

B:BD[18.78205] → [18.78205:78229]

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

Replacement in pijul/src/remote/mod.rs at line 634 [18.52474]
B:BD[21.9745] → [21.9745:9779]
∅:D[21.9779] → [18.78420:78449]
B:BD[18.78420] → [18.78420:78449]
```
            let (_, (h, _)) = x?;
            pullable.push(h)
```
[21.9745]
[18.78449]
```
            let (_, p) = x?;
            pullable.push(p.a.into())
```

Replacement in pijul/src/remote/mod.rs at line 679 [18.52474]

B:BD[26.4046] → [26.4046:4132]

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

[26.4046]

[26.4132]

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

Replacement in pijul/src/remote/local.rs at line 30 [18.79745]
B:BD[21.10096] → [21.10096:10115]
```
            (n, m)
```
[21.10096]
[21.10115]
```
            (n, m.into())
```

Replacement in pijul/src/remote/local.rs at line 63 [18.79745]

B:BD[26.4571] → [21.10333:10406]

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

[26.4571]

[26.4643]

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

Deletion in pijul/src/remote/local.rs at line 81 [18.79745]

B:BD[18.81504] → [18.81504:81705]

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

Replacement in pijul/src/remote/local.rs at line 85 [18.79745]

B:BD[21.10952] → [21.10952:11016]

                            .get_touched_files(*x, Some(h_int))

[21.10952]

[21.11016]

                            .get_touched_files(x, Some(h_int))

Replacement in pijul/src/remote/local.rs at line 90 [18.79745]

B:BD[18.81977] → [18.81977:82033]

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

[18.81977]

[18.82033]

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

Replacement in pijul/src/remote/local.rs at line 163 [18.79745]

B:BD[35.4116] → [35.4116:4175]

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

[35.4116]

[35.4175]

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

Deletion in pijul/src/main.rs at line 77 [18.83981]

B:BD[38.180] → [16.0:153]

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

Replacement in pijul/src/main.rs at line 123 [18.83981]
B:BD[25.4574] → [25.4574:4591]
B:BD[25.4591] → [39.0:43]
∅:D[39.43] → [25.4591:4607]
B:BD[25.4591] → [25.4591:4607]
```
    #[cfg(unix)]
    #[clap(setting = AppSettings::Hidden)]
    Lock(Lock),
```
[25.4574]
[40.25]
```
    /// Manage tags (create tags, check out a tag)
    // Tag(Tag),
```

Replacement in pijul/src/main.rs at line 212 [18.83981]

B:BD[25.5590] → [25.5590:5663]

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

[25.5590]

[40.600]

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

Replacement in pijul/src/commands/unrecord.rs at line 66 [18.95630]

B:BD[21.11850] → [21.11850:11897]

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

[21.11850]

[41.2390]

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

Replacement in pijul/src/commands/unrecord.rs at line 71 [18.95630]

B:BD[11.279] → [11.279:349]

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

[11.279]

[11.349]

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

Replacement in pijul/src/commands/unrecord.rs at line 80 [18.95630]

B:BD[42.401] → [41.2792:2834]

            let mut changes = Vec::new();

[42.401]

[11.545]

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

Replacement in pijul/src/commands/unrecord.rs at line 83 [18.95630]

B:BD[27.1883] → [43.0:70]

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

[27.1883]

[27.1954]

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

Replacement in pijul/src/commands/unrecord.rs at line 85 [18.95630]

B:BD[27.1985] → [11.592:644]

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

[27.1985]

[42.648]

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

Replacement in pijul/src/commands/unrecord.rs at line 91 [18.95630]

B:BD[18.96722] → [21.11898:11953]

                for p in txn.iter_revdep(change_id)? {

[18.96722]

[21.11953]

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

Replacement in pijul/src/commands/unrecord.rs at line 93 [18.95630]
∅:D[21.11990] → [18.96781:96820]
B:BD[18.96781] → [18.96781:96820]
```
                    if p < change_id {
```
[21.11990]
[18.96820]
```
                    if p < &change_id {
```

Replacement in pijul/src/commands/unrecord.rs at line 95 [18.95630]

B:BD[18.96854] → [18.96854:96900]

                    } else if p > change_id {

[18.96854]

[18.96900]

                    } else if p > &change_id {

Replacement in pijul/src/commands/unrecord.rs at line 99 [18.95630]

∅:D[43.152] → [21.12073:12138]

∅:D[22.582] → [21.12073:12138]

B:BD[21.12073] → [21.12073:12138]

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

[43.152]

[44.551]

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

Deletion in pijul/src/commands/unrecord.rs at line 135 [18.95630]
B:BD[18.97615] → [25.5792:5827]
```
        repo.lock.commit().await?;
```
Deletion in pijul/src/commands/reset.rs at line 108 [18.97650]
B:BD[45.773] → [25.6164:6211]
```
                    repo.lock.commit().await?;
```
Deletion in pijul/src/commands/reset.rs at line 161 [18.97650]
B:BD[26.6587] → [25.6212:6251]
```
            repo.lock.commit().await?;
```

Replacement in pijul/src/commands/reset.rs at line 179 [18.97650]

B:BD[46.2300] → [46.2300:2442]

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

[46.2300]

[46.2442]

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

Replacement in pijul/src/commands/reset.rs at line 186 [18.97650]

B:BD[46.2497] → [46.2497:2591]

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

[46.2497]

[46.2591]

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

Replacement in pijul/src/commands/reset.rs at line 189 [18.97650]

B:BD[46.2627] → [46.2627:2720]

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

[46.2627]

[46.2720]

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

Replacement in pijul/src/commands/reset.rs at line 193 [18.97650]
B:BD[46.2765] → [46.2765:2801]
```
                inodes.insert(pos);
```
[46.2765]
[46.2801]
```
                inodes.insert(*pos);
```
Deletion in pijul/src/commands/record.rs at line 42 [18.101759]
B:BD[18.102621] → [18.102621:102666]
```
    #[clap(long = "tag")]
    pub tag: bool,
```

Replacement in pijul/src/commands/record.rs at line 73 [18.101759]

B:BD[13.357] → [13.357:424]

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

[13.357]

[13.424]

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

Replacement in pijul/src/commands/record.rs at line 89 [18.101759]
B:BD[21.12559] → [21.12559:12584]
```
                (h?.1).0
```
[21.12559]
[47.288]
```
                (h?.1).0.into()
```

Replacement in pijul/src/commands/record.rs at line 148 [18.101759]

B:BD[18.105115] → [18.105115:105191]

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

[18.105115]

[18.105191]

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

Deletion in pijul/src/commands/record.rs at line 160 [18.101759]
B:BD[18.105279] → [25.6330:6369]
```
            repo.lock.commit().await?;
```
Deletion in pijul/src/commands/record.rs at line 165 [18.101759]
B:BD[48.301] → [25.6370:6413]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/pushpull.rs at line 34 [18.111631]

B:BD[25.6472] → [25.6472:6541]

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

[25.6472]

[18.112314]

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

Deletion in pijul/src/commands/pushpull.rs at line 51 [18.111631]
B:BD[18.112970] → [25.6542:6589]
```
                    repo.lock.commit().await?;
```

Replacement in pijul/src/commands/pushpull.rs at line 122 [18.111631]

B:BD[49.1981] → [25.6590:6659]

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

[49.1981]

[18.114570]

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

Replacement in pijul/src/commands/pushpull.rs at line 173 [18.111631]
B:BD[18.116228] → [18.116228:116268]
```
        let mut to_upload = Vec::new();
```
[18.116228]
[21.13129]
```
        let mut to_upload: Vec<Hash> = Vec::new();
```

Replacement in pijul/src/commands/pushpull.rs at line 177 [18.111631]

B:BD[26.7524] → [21.13225:13287]

                if txn.remote_has_state(remote_changes, m)? {

[26.7524]

[35.4622]

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

Replacement in pijul/src/commands/pushpull.rs at line 181 [18.111631]

B:BD[21.13347] → [21.13347:13412]

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

[21.13347]

[26.7525]

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

Replacement in pijul/src/commands/pushpull.rs at line 183 [18.111631]

B:BD[26.7567] → [26.7567:7609]

                        to_upload.push(h)

[26.7567]

[26.7609]

                        to_upload.push(h.into())

Replacement in pijul/src/commands/pushpull.rs at line 186 [18.111631]

B:BD[26.7686] → [21.13413:13496]

∅:D[21.13496] → [26.7768:7819]

B:BD[26.7768] → [26.7768:7819]

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

[26.7686]

[26.7819]

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

Replacement in pijul/src/commands/pushpull.rs at line 199 [18.111631]

B:BD[26.7935] → [26.7935:7981]

                            to_upload.push(h)

[26.7935]

[26.7981]

                            to_upload.push(h.into())

Replacement in pijul/src/commands/pushpull.rs at line 202 [18.111631]

B:BD[26.8066] → [21.13722:13809]

∅:D[21.13809] → [26.8152:8207]

B:BD[26.8152] → [26.8152:8207]

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

[26.8066]

[26.8207]

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

Replacement in pijul/src/commands/pushpull.rs at line 221 [18.111631]

B:BD[50.426] → [50.426:462]

            let mut u = Vec::new();

[50.426]

[50.462]

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

Deletion in pijul/src/commands/pushpull.rs at line 269 [18.111631]
B:BD[18.117458] → [25.6660:6695]
```
        repo.lock.commit().await?;
```
Replacement in pijul/src/commands/pushpull.rs at line 308 [18.111631]
B:BD[18.118760] → [18.118760:118806]
```
            let mut to_download = Vec::new();
```
[18.118760]
[26.8690]
```
            let mut to_download: Vec<Hash> = Vec::new();
```

Replacement in pijul/src/commands/pushpull.rs at line 312 [18.111631]

B:BD[21.13890] → [21.13890:13929]

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

[21.13890]

[51.0]

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

Replacement in pijul/src/commands/pushpull.rs at line 314 [18.111631]

B:BD[51.27] → [51.27:105]

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

[51.27]

[51.105]

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

Replacement in pijul/src/commands/pushpull.rs at line 318 [18.111631]

B:BD[35.6447] → [21.13991:14066]

∅:D[21.14066] → [35.6521:6565]

B:BD[35.6521] → [35.6521:6565]

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

[35.6447]

[35.6565]

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

Replacement in pijul/src/commands/pushpull.rs at line 336 [18.111631]

B:BD[26.9407] → [21.14273:14347]

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

[26.9407]

[26.9472]

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

Replacement in pijul/src/commands/pushpull.rs at line 344 [18.111631]

B:BD[51.194] → [51.194:276]

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

[51.194]

[51.276]

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

Replacement in pijul/src/commands/pushpull.rs at line 356 [18.111631]

B:BD[26.9641] → [21.14764:14846]

                                    txn.get_rev_touched_files(h_int, Some(inode))

[26.9641]

[21.14846]

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

Replacement in pijul/src/commands/pushpull.rs at line 361 [18.111631]

∅:D[26.9798] → [35.7978:8030]

B:BD[35.7978] → [35.7978:8030]

                                to_download.push(h)

[26.9798]

[35.8030]

                                to_download.push(h.into())

Replacement in pijul/src/commands/pushpull.rs at line 406 [18.111631]

B:BD[18.120394] → [18.120394:120449]

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

[18.120394]

[14.72]

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

Replacement in pijul/src/commands/pushpull.rs at line 413 [18.111631]

∅:D[14.197] → [18.120481:120565]

B:BD[18.120481] → [18.120481:120565]

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

[14.197]

[52.750]

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

Replacement in pijul/src/commands/pushpull.rs at line 437 [18.111631]

B:BD[33.839] → [33.839:894]

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

[33.839]

[33.894]

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

Replacement in pijul/src/commands/pushpull.rs at line 446 [18.111631]

B:BD[33.1227] → [33.1227:1301]

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

[33.1227]

[33.1301]

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

Replacement in pijul/src/commands/pushpull.rs at line 459 [18.111631]

B:BD[15.369] → [15.369:469]

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

[15.369]

[15.469]

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

Deletion in pijul/src/commands/pushpull.rs at line 489 [18.111631]
B:BD[18.121124] → [25.6766:6801]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/pushpull.rs at line 513 [18.111631]

B:BD[53.350] → [21.15025:15077]

                if txn.remote_has_change(rem, d)? {

[53.350]

[53.401]

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

Insertion in pijul/src/commands/protocol.rs at line 81 [18.123281]

[37.1272]

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

Insertion in pijul/src/commands/protocol.rs at line 89 [18.123281]
[21.15582]
[37.1515]
```
                    let m: Merkle = m.into();
```

Replacement in pijul/src/commands/protocol.rs at line 107 [18.123281]

B:BD[18.127257] → [21.15636:15706]

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

[18.127257]

[26.11554]

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

Replacement in pijul/src/commands/protocol.rs at line 125 [18.123281]

B:BD[26.11980] → [21.16203:16342]

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

[26.11980]

[26.12078]

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

Insertion in pijul/src/commands/protocol.rs at line 129 [18.123281]

[18.127893]

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

Replacement in pijul/src/commands/protocol.rs at line 184 [18.123281]

B:BD[18.130437] → [18.130437:130516]

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

[18.130437]

[12.67]

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

Deletion in pijul/src/commands/protocol.rs at line 186 [18.123281]

∅:D[12.128] → [18.130577:130748]

B:BD[18.130577] → [18.130577:130748]

B:BD[18.130748] → [21.16547:16676]

∅:D[21.16676] → [18.130875:130921]

B:BD[18.130875] → [18.130875:130921]

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

Replacement in pijul/src/commands/protocol.rs at line 212 [18.123281]
B:BD[18.132460] → [18.132460:132495]
```
                            state,
```
[18.132460]
[18.132495]
```
                            &state,
```
Deletion in pijul/src/commands/protocol.rs at line 246 [18.123281]
B:BD[18.133576] → [25.6930:6969]
```
            repo.lock.commit().await?;
```
Deletion in pijul/src/commands/mod.rs at line 59 [18.133619]
B:BD[18.134333] → [25.6970:7024]
```
#[cfg(unix)]
mod lock;
#[cfg(unix)]
pub use lock::*;
```

Replacement in pijul/src/commands/mod.rs at line 95 [18.133619]

B:BD[44.2807] → [44.2807:2890]

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

[44.2807]

[44.2890]

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

Replacement in pijul/src/commands/log.rs at line 32 [18.134376]

B:BD[25.7083] → [25.7083:7169]

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

[25.7083]

[18.135006]

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

Replacement in pijul/src/commands/log.rs at line 45 [18.134376]

B:BD[21.17147] → [21.17147:17181]

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

[21.17147]

[18.135619]

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

Replacement in pijul/src/commands/log.rs at line 52 [18.134376]

∅:D[21.17284] → [54.0:54]

B:BD[18.135819] → [54.0:54]

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

[21.17284]

[18.135873]

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

Deletion in pijul/src/commands/init.rs at line 28 [18.136543]
B:BD[18.137177] → [25.14199:14234]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/fork.rs at line 26 [18.167873]

B:BD[25.14628] → [25.14628:14697]

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

[25.14628]

[18.168420]

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

Replacement in pijul/src/commands/fork.rs at line 32 [18.167873]

B:BD[18.168678] → [18.168678:168747]

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

[18.168678]

[18.168747]

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

Deletion in pijul/src/commands/fork.rs at line 40 [18.167873]
B:BD[18.169013] → [25.14698:14733]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 25 [18.169058]

B:BD[25.14796] → [25.14796:14873]

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

[25.14796]

[18.169474]

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

Deletion in pijul/src/commands/file_operations.rs at line 57 [18.169058]
B:BD[18.170571] → [25.14874:14909]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 78 [18.169058]

B:BD[25.14968] → [25.14968:15054]

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

[25.14968]

[18.170979]

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

Replacement in pijul/src/commands/file_operations.rs at line 104 [18.169058]

B:BD[25.15113] → [25.15113:15190]

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

[25.15113]

[18.171454]

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

Deletion in pijul/src/commands/file_operations.rs at line 150 [18.169058]
B:BD[18.172439] → [25.15191:15226]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/file_operations.rs at line 165 [18.169058]

B:BD[25.15285] → [25.15285:15362]

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

[25.15285]

[18.172733]

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

Deletion in pijul/src/commands/file_operations.rs at line 191 [18.169058]
B:BD[18.173517] → [25.15363:15398]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/credit.rs at line 28 [18.178684]

B:BD[18.179239] → [25.15722:15812]

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

[18.179239]

[18.179302]

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

Replacement in pijul/src/commands/credit.rs at line 107 [18.178684]

B:BD[21.18451] → [21.18451:18498]

                if e.introduced_by.is_root() {

[21.18451]

[21.18498]

                if e.introduced_by().is_root() {

Replacement in pijul/src/commands/credit.rs at line 110 [18.178684]
∅:D[21.18546] → [18.181572:181626]
B:BD[18.181572] → [18.181572:181626]
```
                self.changes.insert(e.introduced_by);
```
[21.18546]
[18.181626]
```
                self.changes.insert(e.introduced_by());
```
Deletion in pijul/src/commands/clone.rs at line 11 [18.182891]
B:BD[18.183067] → [55.4552:4629]
∅:D[55.4629] → [18.183147:183163]
B:BD[18.183147] → [18.183147:183163]
```
    /// Only download changes with alive contents
    #[clap(long = "lazy")]
    lazy: bool,
```

Replacement in pijul/src/commands/clone.rs at line 75 [18.182891]

B:BD[18.185211] → [18.185211:185289]

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

[18.185211]

[18.185289]

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

Replacement in pijul/src/commands/clone.rs at line 79 [18.182891]

B:BD[18.185349] → [18.185349:185566]

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

[18.185349]

[18.185566]

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

Deletion in pijul/src/commands/clone.rs at line 97 [18.182891]
B:BD[18.185801] → [25.15874:15909]
```
        repo.lock.commit().await?;
```

Replacement in pijul/src/commands/channel.rs at line 54 [18.186892]

B:BD[18.188244] → [25.16043:16120]

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

[18.188244]

[56.1196]

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

Deletion in pijul/src/commands/channel.rs at line 64 [18.186892]
B:BD[18.188379] → [25.16121:16164]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/channel.rs at line 76 [18.186892]

B:BD[18.188456] → [25.16217:16294]

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

[18.188456]

[56.1809]

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

Deletion in pijul/src/commands/channel.rs at line 93 [18.186892]
B:BD[18.189246] → [25.16295:16338]
```
                repo.lock.commit().await?;
```

Replacement in pijul/src/commands/change.rs at line 22 [18.189306]

B:BD[25.16397] → [25.16397:16491]

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

[25.16397]

[18.189800]

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

Replacement in pijul/src/commands/change.rs at line 37 [18.189306]
B:BD[21.19195] → [21.19195:19220]
```
                (h?.1).0
```
[21.19195]
[57.385]
```
                (h?.1).0.into()
```
Replacement in pijul/src/commands/archive.rs at line 99 [18.191083]
B:BD[18.193682] → [18.193682:193709]
```
                    state,
```
[18.193682]
[18.193709]
```
                    &state,
```
Insertion in pijul/src/commands/apply.rs at line 8 [18.194289]
[34.617]
[24.3379]
```
use log::*;
```

Replacement in pijul/src/commands/apply.rs at line 55 [18.194289]

B:BD[58.1173] → [58.1173:1258]

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

[58.1173]

[18.196040]

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

Replacement in pijul/src/commands/apply.rs at line 57 [18.194289]
B:BD[18.196057] → [58.1259:1302]
```
            for hash in hashes.drain(..) {
```
[18.196057]
[58.1302]
```
            for hash in hashes.iter() {
```

Replacement in pijul/src/commands/apply.rs at line 64 [18.194289]

B:BD[34.694] → [34.694:749]

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

[34.694]

[34.749]

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

Insertion in pijul/src/commands/apply.rs at line 67 [18.194289]
[34.807]
[34.807]
```
                    debug!("{:?}", inode);
```

Replacement in pijul/src/commands/apply.rs at line 74 [18.194289]

B:BD[34.1021] → [34.1021:1064]

                    touched.insert(inode);

[34.1021]

[34.1064]

                    touched.insert(*inode);

Deletion in pijul/src/commands/apply.rs at line 92 [18.194289]
B:BD[18.196337] → [25.16701:16736]
```
        repo.lock.commit().await?;
```
Insertion in pijul/Cargo.toml at line 33 [18.196374]
[25.16789]
[18.197171]
```
"src/commands/tag.rs",
```
Replacement in pijul/Cargo.toml at line 46 [18.196374]
B:BD[18.197316] → [18.197316:197351]
```
git = [ "git2", "sanakirja/git2" ]
```
[18.197316]
[3.121]
```
git = [ "git2" ]
```

Replacement in pijul/Cargo.toml at line 69 [18.196374]

B:BD[18.197874] → [59.0:57]

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

[18.197874]

[18.197895]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 18 [18.225940]

B:BD[18.226458] → [21.19970:20031]

∅:D[21.20031] → [60.353:404]

B:BD[18.226518] → [60.353:404]

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

[18.226458]

[18.226645]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 38 [18.225940]

B:BD[22.1134] → [43.565:658]

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

[22.1134]

[18.227128]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 73 [18.225940]

B:BD[21.20660] → [21.20660:20778]

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

[21.20660]

[21.20778]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 82 [18.225940]

B:BD[23.6928] → [21.20878:20956]

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

[23.6928]

[23.6929]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 105 [18.225940]

B:BD[23.7110] → [21.21152:21228]

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

[23.7110]

[23.7177]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 112 [18.225940]
B:BD[18.229428] → [21.21229:21287]
∅:D[21.21287] → [61.67:85]
B:BD[61.67] → [61.67:85]
```
    if let Some(inode) = txn.get_revinodes(dest, None)? {
        Ok(inode)
```
[18.229428]
[61.85]
```
    if let Some(inode) = txn.get_revinodes(&dest, None)? {
        Ok(*inode)
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 116 [18.225940]

B:BD[21.21343] → [21.21343:21453]

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

[21.21343]

[61.338]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 136 [18.225940]

B:BD[21.21610] → [21.21610:21679]

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

[21.21610]

[21.21679]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 139 [18.225940]

∅:D[21.21711] → [18.230169:230218]

B:BD[18.230169] → [18.230169:230218]

B:BD[18.230218] → [62.44:98]

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

[21.21711]

[18.230218]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 142 [18.225940]

B:BD[18.230244] → [43.721:792]

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

[18.230244]

[18.230316]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 147 [18.225940]
B:BD[18.230469] → [18.230469:230501]
```
                    *v = e.dest
```
[18.230469]
[18.230501]
```
                    *v = e.dest()
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 150 [18.225940]
B:BD[18.230540] → [18.230540:230583]
```
                next = Some((age, e.dest))
```
[18.230540]
[18.230583]
```
                next = Some((age, e.dest()))
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 153 [18.225940]
B:BD[18.230614] → [18.230614:230652]
```
            next = Some((0, e.dest));
```
[18.230614]
[18.230652]
```
            next = Some((&L64(0), e.dest()));
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 157 [18.225940]

B:BD[18.230687] → [43.793:853]

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

[18.230687]

[18.230736]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 172 [18.225940]

B:BD[27.7432] → [21.22048:22178]

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

[27.7432]

[18.231440]

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

Replacement in libpijul/src/unrecord/mod.rs at line 56 [18.231493]

B:BD[23.8768] → [21.22586:22650]

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

[23.8768]

[18.232023]

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

Replacement in libpijul/src/unrecord/mod.rs at line 69 [18.231493]

B:BD[18.232331] → [21.22722:22914]

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

[18.232331]

[18.232522]

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

Replacement in libpijul/src/unrecord/mod.rs at line 74 [18.231493]

B:BD[18.232570] → [21.22915:23022]

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

[18.232570]

[18.232676]

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

Replacement in libpijul/src/unrecord/mod.rs at line 91 [18.231493]

B:BD[21.23205] → [43.854:946]

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

[21.23205]

[18.233031]

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

Replacement in libpijul/src/unrecord/mod.rs at line 97 [18.231493]
B:BD[18.233133] → [21.23300:23343]
```
    for x in txn.iter_revdep(change_id)? {
```
[18.233133]
[21.23343]
```
    for x in txn.iter_revdep(&change_id)? {
```

Replacement in libpijul/src/unrecord/mod.rs at line 99 [18.231493]

∅:D[21.23368] → [18.233180:233263]

B:BD[18.233180] → [18.233180:233263]

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

[21.23368]

[18.233263]

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

Replacement in libpijul/src/unrecord/mod.rs at line 106 [18.231493]
B:BD[51.614] → [51.614:644]
```
                dependent: d,
```
[51.614]
[51.644]
```
                dependent: *d,
```
Replacement in libpijul/src/unrecord/mod.rs at line 111 [18.231493]
B:BD[18.233453] → [21.23439:23492]
```
    txn.del_changes(channel, change_id, timestamp)?;
```
[18.233453]
[18.233506]
```
    txn.del_changes(channel, change_id, timestamp.into())?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 125 [18.231493]

B:BD[43.1062] → [43.1062:1135]

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

[43.1062]

[22.1779]

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

Replacement in libpijul/src/unrecord/mod.rs at line 169 [18.231493]
B:BD[22.2111] → [22.2111:2130]
```
                )?
```
[22.2111]
[18.234960]
```
                )?;
```
Replacement in libpijul/src/unrecord/mod.rs at line 223 [18.231493]
∅:D[63.469] → [18.235921:235941]
B:BD[18.235921] → [18.235921:235941]
```
    del: Vec<Edge>,
```
[63.469]
[18.235941]
```
    del: Vec<SerializedEdge>,
```
Replacement in libpijul/src/unrecord/mod.rs at line 226 [18.231493]
B:BD[63.504] → [63.504:550]
```
    del_edges: Vec<(Vertex<ChangeId>, Edge)>,
```
[63.504]
[18.235977]
```
    del_edges: Vec<(Vertex<ChangeId>, SerializedEdge)>,
```

Replacement in libpijul/src/unrecord/mod.rs at line 241 [18.231493]

B:BD[18.236556] → [22.2614:2672]

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

[18.236556]

[18.237184]

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

Replacement in libpijul/src/unrecord/mod.rs at line 246 [18.231493]

B:BD[18.237352] → [63.666:789]

B:BD[63.789] → [22.2673:2746]

∅:D[22.2746] → [18.237596:237658]

∅:D[27.7814] → [18.237596:237658]

B:BD[18.237596] → [18.237596:237658]

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

[18.237352]

[18.237658]

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

Replacement in libpijul/src/unrecord/mod.rs at line 253 [18.231493]

B:BD[18.237705] → [22.2747:2814]

∅:D[22.2814] → [63.790:967]

B:BD[27.7883] → [63.790:967]

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

[18.237705]

[63.967]

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

Replacement in libpijul/src/unrecord/mod.rs at line 260 [18.231493]
B:BD[18.237975] → [18.237975:238002]
```
            ws.del.push(e)
```
[18.237975]
[18.238002]
```
            ws.del.push(*e)
```

Replacement in libpijul/src/unrecord/mod.rs at line 281 [18.231493]

B:BD[63.1417] → [63.1417:1466]

B:BD[63.1466] → [22.2815:2878]

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

[63.1417]

[18.238312]

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

Replacement in libpijul/src/unrecord/mod.rs at line 284 [18.231493]

B:BD[18.238333] → [22.2879:2938]

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

[18.238333]

[18.238392]

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

Replacement in libpijul/src/unrecord/mod.rs at line 289 [18.231493]

B:BD[27.8088] → [27.8088:8132]

                e.flag - EdgeFlags::PARENT,

[27.8088]

[27.8132]

                e.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/unrecord/mod.rs at line 292 [18.231493]
B:BD[27.8170] → [27.8170:8203]
```
                e.introduced_by,
```
[27.8170]
[21.25164]
```
                e.introduced_by(),
```
Replacement in libpijul/src/unrecord/mod.rs at line 307 [18.231493]
B:BD[18.239152] → [64.0:42]
```
        if !is_alive(txn, channel, up)? {
```
[18.239152]
[64.42]
```
        if !is_alive(txn, channel, &up)? {
```
Replacement in libpijul/src/unrecord/mod.rs at line 322 [18.231493]
B:BD[63.1552] → [64.273:317]
```
        if !is_alive(txn, channel, down)? {
```
[63.1552]
[64.317]
```
        if !is_alive(txn, channel, &down)? {
```

Replacement in libpijul/src/unrecord/mod.rs at line 333 [18.231493]

B:BD[21.25422] → [22.2939:3007]

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

[21.25422]

[21.25423]

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

Replacement in libpijul/src/unrecord/mod.rs at line 335 [18.231493]
∅:D[21.25473] → [63.1553:1596]
B:BD[27.8434] → [63.1553:1596]
```
                ws.parents.insert(parent);
```
[21.25473]
[18.239908]
```
                ws.parents.insert(*parent);
```

Replacement in libpijul/src/unrecord/mod.rs at line 363 [18.231493]

B:BD[18.240632] → [21.25614:25667]

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

[18.240632]

[18.240757]

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

Replacement in libpijul/src/unrecord/mod.rs at line 395 [18.231493]
B:BD[18.242373] → [21.25884:25929]
```
        change: txn.get_external(b.change)?,
```
[18.242373]
[18.242417]
```
        change: txn.get_external(&b.change)?.map(From::from),
```

Replacement in libpijul/src/unrecord/mod.rs at line 401 [18.231493]

B:BD[21.25996] → [21.25996:26167]

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

[21.25996]

[21.26167]

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

Replacement in libpijul/src/unrecord/mod.rs at line 415 [18.231493]
B:BD[18.243156] → [18.243156:243192]
```
        stack.push(e.introduced_by)
```
[18.243156]
[18.243192]
```
        stack.push(e.introduced_by())
```

Replacement in libpijul/src/unrecord/mod.rs at line 434 [18.231493]

B:BD[21.26353] → [21.26353:26432]

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

[21.26353]

[21.26432]

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

Replacement in libpijul/src/unrecord/mod.rs at line 439 [18.231493]

B:BD[18.243801] → [21.26493:26555]

∅:D[21.26555] → [18.243862:243892]

B:BD[18.243862] → [18.243862:243892]

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

[18.243801]

[18.243892]

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

Replacement in libpijul/src/unrecord/mod.rs at line 460 [18.231493]

∅:D[63.2699] → [18.245689:245741]

B:BD[18.245689] → [18.245689:245741]

B:BD[18.245741] → [22.3008:3070]

∅:D[22.3070] → [63.2700:2745]

B:BD[27.9132] → [63.2700:2745]

B:BD[63.2745] → [21.26697:26779]

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

[63.2699]

[18.246602]

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

Replacement in libpijul/src/unrecord/mod.rs at line 465 [18.231493]

B:BD[18.246623] → [22.3071:3129]

∅:D[22.3129] → [21.26780:26862]

B:BD[27.9860] → [21.26780:26862]

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

[18.246623]

[18.246762]

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

Replacement in libpijul/src/unrecord/mod.rs at line 480 [18.231493]
B:BD[21.26980] → [22.3130:3179]
```
    ws.stack.push(txn.find_block(channel, to)?);
```
[21.26980]
[63.3110]
```
    ws.stack.push(*txn.find_block(channel, to)?);
```

Replacement in libpijul/src/unrecord/mod.rs at line 489 [18.231493]

B:BD[63.3349] → [63.3349:3447]

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

[63.3349]

[63.3447]

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

Replacement in libpijul/src/unrecord/mod.rs at line 492 [18.231493]

B:BD[63.3487] → [63.3487:3539]

B:BD[63.3539] → [22.3180:3248]

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

[63.3487]

[63.3608]

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

Replacement in libpijul/src/unrecord/mod.rs at line 495 [18.231493]

B:BD[63.3629] → [22.3249:3313]

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

[63.3629]

[63.3694]

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

Replacement in libpijul/src/unrecord/mod.rs at line 497 [18.231493]

B:BD[63.3708] → [63.3708:3796]

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

[63.3708]

[63.3796]

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

Replacement in libpijul/src/unrecord/mod.rs at line 515 [18.231493]

B:BD[21.27202] → [21.27202:27263]

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

[21.27202]

[18.247175]

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

Insertion in libpijul/src/tests/unrecord.rs at line 38 [18.248807]
[18.249931]
[18.249931]
```
        None,
```
Insertion in libpijul/src/tests/unrecord.rs at line 78 [18.248807]
[18.251045]
[18.251045]
```
    debug_to_file(&txn, &channel.borrow(), "debug_un0")?;
```
Insertion in libpijul/src/tests/unrecord.rs at line 80 [18.248807]
[18.251116]
[18.251116]
```
    debug_to_file(&txn, &channel.borrow(), "debug_un1")?;
```
Insertion in libpijul/src/tests/unrecord.rs at line 88 [18.248807]
[18.251277]
[18.251277]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 138 [18.248807]

B:BD[18.252788] → [18.252788:252886]

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

[18.252788]

[18.252886]

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

Replacement in libpijul/src/tests/unrecord.rs at line 145 [18.248807]

B:BD[18.253055] → [18.253055:253104]

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

[18.253055]

[18.253104]


    // 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"]);

Replacement in libpijul/src/tests/unrecord.rs at line 191 [18.248807]

B:BD[18.254277] → [18.254277:254611]

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

[18.254277]

[18.254611]

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

Replacement in libpijul/src/tests/unrecord.rs at line 226 [18.248807]

B:BD[18.255511] → [18.255511:255737]

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

[18.255511]

[18.255737]

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

Replacement in libpijul/src/tests/unrecord.rs at line 267 [18.248807]

B:BD[18.256840] → [18.256840:257007]

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

[18.256840]

[18.257007]

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

Replacement in libpijul/src/tests/unrecord.rs at line 292 [18.248807]

B:BD[18.257606] → [18.257606:257670]

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

[18.257606]

[18.257670]

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

Insertion in libpijul/src/tests/unrecord.rs at line 304 [18.248807]
[18.257976]
[18.257976]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 335 [18.248807]

B:BD[18.258803] → [18.258803:258869]

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

[18.258803]

[22.4067]

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

Insertion in libpijul/src/tests/unrecord.rs at line 348 [18.248807]
[18.259244]
[18.259244]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 378 [18.248807]

B:BD[18.260186] → [18.260186:260284]

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

[18.260186]

[18.260284]

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

Insertion in libpijul/src/tests/unrecord.rs at line 395 [18.248807]
[18.260711]
[18.260711]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 478 [18.248807]

B:BD[18.263374] → [18.263374:263593]

    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);
    }

[18.263374]

[18.263593]

    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"]);

Insertion in libpijul/src/tests/unrecord.rs at line 525 [18.248807]
[18.264723]
[18.264723]
```
        None,
```
Insertion in libpijul/src/tests/unrecord.rs at line 543 [18.248807]
[18.265208]
[18.265208]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 549 [18.248807]

B:BD[18.265336] → [18.265336:265423]

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

[18.265336]

[18.265423]

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

Deletion in libpijul/src/tests/unrecord.rs at line 552 [18.248807]
B:BD[18.265442] → [18.265442:265443]

Replacement in libpijul/src/tests/unrecord.rs at line 580 [18.248807]

B:BD[18.266367] → [18.266367:266430]

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

[18.266367]

[22.4640]

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

Insertion in libpijul/src/tests/unrecord.rs at line 589 [18.248807]
[18.266634]
[18.266634]
```
        None,
```
Insertion in libpijul/src/tests/unrecord.rs at line 624 [18.248807]
[18.267630]
[18.267630]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 706 [18.248807]

B:BD[18.269719] → [18.269719:269786]

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

[18.269719]

[18.269786]

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

Insertion in libpijul/src/tests/unrecord.rs at line 714 [18.248807]
[18.269947]
[18.269947]
```
        None,
```
Insertion in libpijul/src/tests/unrecord.rs at line 733 [18.248807]
[18.270476]
[18.270476]
```
        None,
```
Replacement in libpijul/src/tests/unrecord.rs at line 740 [18.248807]
B:BD[18.270642] → [18.270642:270688]
```
    let r = repo.read_file("file", &mut buf);
```
[18.270642]
[18.270688]
```
    repo.read_file("file", &mut buf).unwrap();
```
Replacement in libpijul/src/tests/unrecord.rs at line 742 [18.248807]
B:BD[18.270709] → [18.270709:270737]
```
        assert!(r.is_err())
```
[18.270709]
[18.270737]
```
        assert_eq!(std::str::from_utf8(&buf), Ok("a\nb\nc\n"));
```

Replacement in libpijul/src/tests/unrecord.rs at line 771 [18.248807]

B:BD[18.271610] → [18.271610:271675]

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

[18.271610]

[18.271675]

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

Replacement in libpijul/src/tests/unrecord.rs at line 789 [18.248807]

B:BD[18.272221] → [18.272221:272285]

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

[18.272221]

[18.272285]

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

Insertion in libpijul/src/tests/unrecord.rs at line 804 [18.248807]
[18.272680]
[18.272680]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 834 [18.248807]

B:BD[18.273578] → [18.273578:273643]

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

[18.273578]

[18.273643]

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

Replacement in libpijul/src/tests/unrecord.rs at line 856 [18.248807]

B:BD[18.274217] → [18.274217:274281]

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

[18.274217]

[18.274281]

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

Insertion in libpijul/src/tests/unrecord.rs at line 871 [18.248807]
[18.274676]
[18.274676]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 879 [18.248807]

B:BD[18.274878] → [18.274878:274943]

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

[18.274878]

[18.274943]

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

Replacement in libpijul/src/tests/unrecord.rs at line 898 [18.248807]

B:BD[18.275468] → [18.275468:275544]

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

[18.275468]

[22.5370]

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

Insertion in libpijul/src/tests/unrecord.rs at line 912 [18.248807]
[18.275911]
[18.275911]
```
        None,
```

Replacement in libpijul/src/tests/unrecord.rs at line 941 [18.248807]

B:BD[61.1138] → [61.1138:1203]

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

[61.1138]

[18.276023]

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

Replacement in libpijul/src/tests/unrecord.rs at line 953 [18.248807]

B:BD[61.1546] → [61.1546:1610]

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

[61.1546]

[61.1610]

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

Replacement in libpijul/src/tests/rollback.rs at line 5 [6.14]

B:BD[6.76] → [6.76:148]

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

[6.76]

[6.148]

fn rollback_conflict_resolution_simple() {

Replacement in libpijul/src/tests/rollback.rs at line 11 [6.14]

B:BD[6.302] → [6.302:360]

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

[6.302]

[6.360]

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

Replacement in libpijul/src/tests/rollback.rs at line 15 [6.14]

B:BD[6.401] → [6.401:461]

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

[6.401]

[6.461]

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

Replacement in libpijul/src/tests/rollback.rs at line 19 [6.14]

B:BD[6.561] → [6.561:655]

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

[6.561]

[6.655]

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

Replacement in libpijul/src/tests/rollback.rs at line 22 [6.14]

B:BD[6.656] → [6.656:710]

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

[6.656]

[6.710]

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

Replacement in libpijul/src/tests/rollback.rs at line 25 [6.14]
B:BD[6.769] → [6.769:805]
```
        w.write_all(b"a\nx\nb\n")?;
```
[6.769]
[6.805]
```
        w.write_all(b"a\nx\nb\n").unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 27 [6.14]

B:BD[6.820] → [6.820:905]

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

[6.820]

[6.905]

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

Replacement in libpijul/src/tests/rollback.rs at line 31 [6.14]
B:BD[6.964] → [6.964:1000]
```
        w.write_all(b"a\ny\nb\n")?;
```
[6.964]
[6.1000]
```
        w.write_all(b"a\ny\nb\n").unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 33 [6.14]

B:BD[6.1015] → [6.1015:1100]

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

[6.1015]

[6.1100]

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

Replacement in libpijul/src/tests/rollback.rs at line 36 [6.14]

B:BD[6.1101] → [6.1101:1231]

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

[6.1101]

[6.1231]

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

Replacement in libpijul/src/tests/rollback.rs at line 39 [6.14]

B:BD[6.1232] → [6.1232:1344]

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

[6.1232]

[6.1344]

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

Replacement in libpijul/src/tests/rollback.rs at line 42 [6.14]

B:BD[6.1345] → [6.1345:1444]

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

[6.1345]

[6.1444]

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

Replacement in libpijul/src/tests/rollback.rs at line 44 [6.14]
B:BD[6.1474] → [6.1474:1513]
```
    repo.read_file("file", &mut buf)?;
```
[6.1474]
[6.1513]
```
    repo.read_file("file", &mut buf).unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 48 [6.14]

B:BD[6.1595] → [6.1595:1668]

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

[6.1595]

[6.1668]

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

Replacement in libpijul/src/tests/rollback.rs at line 51 [6.14]
B:BD[6.1786] → [6.1786:1820]
```
            writeln!(w, "{}", l)?
```
[6.1786]
[6.1820]
```
            writeln!(w, "{}", l).unwrap()
```
Replacement in libpijul/src/tests/rollback.rs at line 54 [6.14]
B:BD[6.1845] → [6.1845:1854]
```
    })?;
```
[6.1845]
[6.1854]
```
    }).unwrap();
```
Replacement in libpijul/src/tests/rollback.rs at line 57 [6.14]
B:BD[6.1872] → [6.1872:1911]
```
    repo.read_file("file", &mut buf)?;
```
[6.1872]
[6.1911]
```
    repo.read_file("file", &mut buf).unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 59 [6.14]

B:BD[6.1965] → [6.1965:2101]

    let resb = record_all(&mut repo, &changes, &mut txn, &mut channela, "")?;
    debug_to_file(&txn, &channela.borrow(), "debugres")?;

[6.1965]

[6.2101]

    let resb = record_all(&mut repo, &changes, &mut txn, &mut channela, "").unwrap();
    debug_to_file(&txn, &channela.borrow(), "debugres").unwrap();

Replacement in libpijul/src/tests/rollback.rs at line 72 [6.14]

B:BD[6.2401] → [6.2401:2582]

    let h_inv = changes.save_change(&p_inv)?;
    apply::apply_change(&changes, &mut txn, &mut channela, h_inv)?;
    debug_to_file(&txn, &channela.borrow(), "debug")?;
    Ok(())

[6.2401]

[6.2582]

    let h_inv = changes.save_change(&p_inv).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channela, &h_inv).unwrap();
    debug_to_file(&txn, &channela.borrow(), "debug").unwrap();

Replacement in libpijul/src/tests/rollback.rs at line 109 [6.14]

B:BD[6.3616] → [6.3616:3746]

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

[6.3616]

[6.3746]

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

Replacement in libpijul/src/tests/rollback.rs at line 115 [6.14]

B:BD[6.3860] → [6.3860:3959]

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

[6.3860]

[6.3959]

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

Replacement in libpijul/src/tests/rollback.rs at line 146 [6.14]

B:BD[6.4962] → [6.4962:5030]

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

[6.4962]

[6.5030]

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

Replacement in libpijul/src/tests/rm_file.rs at line 34 [18.276051]

B:BD[18.277183] → [18.277183:277267]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.277183]

[18.277267]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/rm_file.rs at line 42 [18.276051]
[18.277424]
[18.277424]
```
        None,
```

Replacement in libpijul/src/tests/rm_file.rs at line 53 [18.276051]

B:BD[18.277803] → [18.277803:277882]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.277803]

[22.5717]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/rm_file.rs at line 62 [18.276051]
[18.278107]
[18.278107]
```
        None,
```
Replacement in libpijul/src/tests/performance.rs at line 71 [18.278146]
B:BD[18.280147] → [18.280147:280205]
```
fn linear_context_repair() -> Result<(), anyhow::Error> {
```
[18.280147]
[18.280205]
```
fn linear_context_repair() {
```

Replacement in libpijul/src/tests/performance.rs at line 80 [18.278146]

B:BD[18.280444] → [18.280444:280502]

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

[18.280444]

[18.280502]

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

Replacement in libpijul/src/tests/performance.rs at line 84 [18.278146]
B:BD[18.280609] → [18.280609:280636]
```
    txn.add_file("file")?;
```
[18.280609]
[18.280636]
```
    txn.add_file("file").unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 87 [18.278146]
∅:D[22.6256] → [18.280761:280777]
∅:D[27.12880] → [18.280761:280777]
B:BD[18.280761] → [18.280761:280777]
```
    let n = 10;
```
[22.6256]
[18.280777]
```
    let n = 20;
```
Replacement in libpijul/src/tests/performance.rs at line 91 [18.278146]
B:BD[18.280864] → [18.280864:280903]
```
                writeln!(w, "{}", j)?;
```
[18.280864]
[18.280903]
```
                writeln!(w, "{}", j).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 93 [18.278146]
B:BD[18.280917] → [18.280917:280958]
```
            w.write_all(&contents[..])?;
```
[18.280917]
[18.280958]
```
            w.write_all(&contents[..]).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 95 [18.278146]
B:BD[18.280994] → [18.280994:281033]
```
                writeln!(w, "{}", j)?;
```
[18.280994]
[18.281033]
```
                writeln!(w, "{}", j).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 103 [18.278146]
B:BD[18.281250] → [18.281250:281302]
```
    let mut channel2 = txn.fork(&channel, "fork")?;
```
[18.281250]
[65.1378]
```
    let mut channel2 = txn.fork(&channel, "fork").unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 106 [18.278146]
B:BD[18.281360] → [18.281360:281395]
```
            writeln!(w, "{}", j)?;
```
[18.281360]
[18.281395]
```
            writeln!(w, "{}", j).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 108 [18.278146]
B:BD[18.281405] → [27.12954:13002]
```
        w.write_all(b"TxnTX\nYYYYY\nZZZZZ\n")?;
```
[18.281405]
[18.281453]
```
        w.write_all(b"TxnTX\nYYYYY\nZZZZZ\n").unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 110 [18.278146]
B:BD[18.281485] → [18.281485:281520]
```
            writeln!(w, "{}", j)?;
```
[18.281485]
[18.281520]
```
            writeln!(w, "{}", j).unwrap();
```
Insertion in libpijul/src/tests/performance.rs at line 115 [18.278146]
[18.281567]
[18.281567]

Replacement in libpijul/src/tests/performance.rs at line 117 [18.278146]

B:BD[18.281651] → [22.6339:6407]

    debug_to_file(&txn, &channel2.borrow(), "debug_bob0").unwrap();

[18.281651]

[18.281708]


    ::sanakirja::debug::debug(&txn.txn, &[
        txn.graph(&channel.borrow()),
        txn.graph(&channel2.borrow()),
    ], "debug_sanakirja", true);

Insertion in libpijul/src/tests/performance.rs at line 123 [18.278146]
[18.281709]
[65.1437]
```
    debug_to_file(&txn, &channel2.borrow(), "debug_bob0").unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 127 [18.278146]
B:BD[18.281767] → [18.281767:281802]
```
            writeln!(w, "{}", j)?;
```
[18.281767]
[18.281802]
```
            writeln!(w, "{}", j).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 130 [18.278146]
B:BD[18.281844] → [18.281844:281879]
```
            writeln!(w, "{}", j)?;
```
[18.281844]
[18.281879]
```
            writeln!(w, "{}", j).unwrap();
```
Insertion in libpijul/src/tests/performance.rs at line 136 [18.278146]
[18.282009]
[22.6408]
Replacement in libpijul/src/tests/performance.rs at line 139 [18.278146]
B:BD[18.282094] → [18.282094:282145]
```
    txn.apply_change(&changes, &mut channel, p1)?;
```
[18.282094]
[22.6478]
```
    txn.apply_change(&changes, &mut channel, &p1).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 142 [18.278146]
B:BD[18.282229] → [18.282229:282281]
```
    txn.apply_change(&changes, &mut channel2, p2)?;
```
[18.282229]
[22.6547]
```
    txn.apply_change(&changes, &mut channel2, &p2).unwrap();
```
Replacement in libpijul/src/tests/performance.rs at line 154 [18.278146]
B:BD[18.282552] → [18.282552:282593]
```
        let original_edges = 8 * n + 18;
```
[18.282552]
[18.282593]
```
        let original_edges = 8 * n + 27;
```
Replacement in libpijul/src/tests/performance.rs at line 156 [18.278146]
B:BD[18.282625] → [18.282625:282674]
```
            panic!("{} > {}", m, original_edges)
```
[18.282625]
[18.282674]
```
            panic!("{}: {} > {}", n, m, original_edges)
```
Replacement in libpijul/src/tests/performance.rs at line 167 [18.278146]
B:BD[18.282848] → [18.282848:282889]
```
        let original_edges = 8 * n + 18;
```
[18.282848]
[18.282889]
```
        let original_edges = 8 * n + 27;
```
Replacement in libpijul/src/tests/performance.rs at line 169 [18.278146]
B:BD[18.282921] → [18.282921:282970]
```
            panic!("{} > {}", m, original_edges)
```
[18.282921]
[18.282970]
```
            panic!("{}: {} > {}", n, m, original_edges)
```
Deletion in libpijul/src/tests/performance.rs at line 173 [18.278146]
B:BD[18.283013] → [18.283013:283024]
```
    Ok(())
```

Replacement in libpijul/src/tests/partial.rs at line 35 [18.285224]

B:BD[18.286507] → [21.27992:28057]

        let key = txn.get_inodes(inode, None).unwrap().unwrap();

[18.286507]

[21.28057]

        let key = txn.get_inodes(&inode, None).unwrap().unwrap();

Replacement in libpijul/src/tests/partial.rs at line 37 [18.285224]

B:BD[21.28091] → [21.28091:28144]

            .log_for_path(&channel.borrow(), key, 0)

[21.28091]

[21.28144]

            .log_for_path(&channel.borrow(), *key, 0)

Replacement in libpijul/src/tests/partial.rs at line 91 [18.285224]

B:BD[18.288228] → [18.288228:288304]

        apply::apply_change(&changes, &mut txn2, &mut channel, h).unwrap();

[18.288228]

[18.288304]

        apply::apply_change(&changes, &mut txn2, &mut channel, &h).unwrap();

Insertion in libpijul/src/tests/partial.rs at line 99 [18.285224]
[18.288482]
[18.288482]
```
            None,
```

Replacement in libpijul/src/tests/partial.rs at line 109 [18.285224]

B:BD[18.288704] → [18.288704:288781]

        apply::apply_change(&changes, &mut txn2, &mut channel, h2).unwrap();

[18.288704]

[18.288781]

        apply::apply_change(&changes, &mut txn2, &mut channel, &h2).unwrap();

Insertion in libpijul/src/tests/partial.rs at line 117 [18.285224]
[18.288956]
[18.288956]
```
            None,
```

Replacement in libpijul/src/tests/mod.rs at line 76 [18.289338]

B:BD[18.291067] → [18.291067:291146]

    apply::apply_local_change(txn, channel, &change0, hash, &rec.updatables)?;

[18.291067]

[18.291146]

    apply::apply_local_change(txn, channel, &change0, &hash, &rec.updatables)?;

Replacement in libpijul/src/tests/mod.rs at line 91 [18.289338]

B:BD[18.291462] → [18.291462:291552]

    output::output_repository_no_pending(repo, changes, txn, channel, "", true).unwrap();

[18.291462]

[18.291552]

    output::output_repository_no_pending(repo, changes, txn, channel, "", true, None).unwrap();

Replacement in libpijul/src/tests/missing_context.rs at line 44 [18.291589]

B:BD[18.292966] → [18.292966:293050]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.292966]

[18.293050]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/missing_context.rs at line 52 [18.291589]
[18.293207]
[18.293207]
```
        None,
```

Replacement in libpijul/src/tests/missing_context.rs at line 94 [18.291589]

B:BD[18.294016] → [18.294016:294095]

B:BD[18.294095] → [27.13811:13891]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h2)?;

[18.294016]

[27.13891]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h2)?;

Insertion in libpijul/src/tests/missing_context.rs at line 104 [18.291589]
[18.294258]
[18.294258]
```
        None,
```

Replacement in libpijul/src/tests/missing_context.rs at line 112 [18.291589]

∅:D[22.7343] → [27.14243:14402]

B:BD[27.14243] → [27.14243:14402]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h2)?;

[22.7343]

[27.14402]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h2)?;

Replacement in libpijul/src/tests/missing_context.rs at line 155 [18.291589]
∅:D[22.7485] → [18.295552:295637]
∅:D[27.14869] → [18.295552:295637]
B:BD[18.295552] → [18.295552:295637]
```
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h).unwrap();
```
[22.7485]
[22.7486]
```
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h).unwrap();
```

Replacement in libpijul/src/tests/missing_context.rs at line 162 [18.291589]

∅:D[22.7627] → [65.2188:2265]

B:BD[65.2188] → [65.2188:2265]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[22.7627]

[65.2265]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/missing_context.rs at line 174 [18.291589]
[18.295894]
[18.295894]
```
        None,
```

Replacement in libpijul/src/tests/missing_context.rs at line 237 [18.291589]

B:BD[18.297968] → [18.297968:298044]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h)?;

[18.297968]

[18.298044]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/missing_context.rs at line 245 [18.291589]
[18.298201]
[18.298201]
```
        None,
```

Replacement in libpijul/src/tests/missing_context.rs at line 279 [18.291589]

B:BD[18.299215] → [18.299215:299294]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.299215]

[18.299294]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/missing_context.rs at line 287 [18.291589]
[18.299457]
[18.299457]
```
        None,
```

Replacement in libpijul/src/tests/missing_context.rs at line 307 [18.291589]

B:BD[18.300061] → [18.300061:300140]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, inv_h)?;

[18.300061]

[18.300140]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &inv_h)?;

Insertion in libpijul/src/tests/missing_context.rs at line 315 [18.291589]
[18.300303]
[18.300303]
```
        None,
```

Replacement in libpijul/src/tests/filesystem.rs at line 18 [18.300430]

B:BD[18.300887] → [18.300887:300988]

    std::fs::create_dir_all(f.path())?;
    let env = pristine::sanakirja::Pristine::new(f.path())?;

[18.300887]

[18.300988]

    let env = pristine::sanakirja::Pristine::new(f.path().join("pristine"))?;

Replacement in libpijul/src/tests/filesystem.rs at line 26 [18.300430]

B:BD[18.301307] → [18.301307:301466]

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

[18.301307]

[18.301466]

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

Replacement in libpijul/src/tests/filesystem.rs at line 55 [18.300430]

B:BD[18.302218] → [18.302218:302279]

    let env = pristine::sanakirja::Pristine::new(f.path())?;

[18.302218]

[18.302279]

    let env = pristine::sanakirja::Pristine::new(f.path().join("pristine"))?;

Replacement in libpijul/src/tests/filesystem.rs at line 64 [18.300430]

B:BD[18.302637] → [18.302637:302796]

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

[18.302637]

[18.302796]

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

Replacement in libpijul/src/tests/filesystem.rs at line 91 [18.300430]

B:BD[18.303520] → [18.303520:303581]

    let env = pristine::sanakirja::Pristine::new(f.path())?;

[18.303520]

[18.303581]

    let env = pristine::sanakirja::Pristine::new(f.path().join("pristine"))?;

Replacement in libpijul/src/tests/filesystem.rs at line 99 [18.300430]

B:BD[18.303900] → [18.303900:304059]

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

[18.303900]

[18.304059]

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

Replacement in libpijul/src/tests/filesystem.rs at line 123 [18.300430]

B:BD[18.304613] → [18.304613:304674]

    let env = pristine::sanakirja::Pristine::new(f.path())?;

[18.304613]

[18.304674]

    let env = pristine::sanakirja::Pristine::new(f.path().join("pristine"))?;

Replacement in libpijul/src/tests/filesystem.rs at line 137 [18.300430]

B:BD[18.305266] → [18.305266:305425]

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

[18.305266]

[18.305425]

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

Replacement in libpijul/src/tests/file_conflicts.rs at line 46 [18.305506]

B:BD[18.306856] → [18.306856:306940]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.306856]

[18.306940]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 54 [18.305506]
[18.307097]
[18.307097]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 80 [18.305506]

B:BD[18.307900] → [18.307900:307979]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.307900]

[22.8460]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 89 [18.305506]
[18.308220]
[18.308220]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 97 [18.305506]

B:BD[18.308376] → [18.308376:308453]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[18.308376]

[22.8534]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 106 [18.305506]
[18.308685]
[18.308685]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 118 [18.305506]
[18.308952]
[18.308952]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 131 [18.305506]
[18.309219]
[18.309219]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 148 [18.305506]
[18.309646]
[18.309646]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 155 [18.305506]

B:BD[18.309777] → [18.309777:309863]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_solution)?;

[18.309777]

[18.309863]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_solution)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 163 [18.305506]
[18.310042]
[18.310042]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 211 [18.305506]

B:BD[18.311582] → [18.311582:311666]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.311582]

[18.311666]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 219 [18.305506]
[18.311823]
[18.311823]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 246 [18.305506]

B:BD[18.312649] → [18.312649:312728]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.312649]

[22.8886]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 255 [18.305506]
[18.312953]
[18.312953]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 259 [18.305506]

B:BD[18.312996] → [18.312996:313073]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[18.312996]

[22.8960]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 268 [18.305506]
[18.313302]
[18.313302]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 301 [18.305506]

B:BD[18.314246] → [18.314246:314330]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, solution_alice)?;

[18.314246]

[18.314330]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &solution_alice)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 309 [18.305506]
[18.314503]
[18.314503]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 357 [18.305506]

B:BD[18.316120] → [18.316120:316204]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.316120]

[18.316204]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 365 [18.305506]
[18.316361]
[18.316361]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 394 [18.305506]

B:BD[18.317420] → [18.317420:317512]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, init_h).unwrap();

[18.317420]

[18.317512]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 402 [18.305506]
[18.317681]
[18.317681]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 416 [18.305506]

B:BD[18.318014] → [18.318014:318182]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, bob_h)?;
    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, alice_h)?;

[18.318014]

[18.318182]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &bob_h)?;
    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 425 [18.305506]
[18.318351]
[18.318351]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 454 [18.305506]
[63.5594]
[63.5594]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 461 [18.305506]

B:BD[18.318584] → [18.318584:318746]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, charlie_h)?;

[18.318584]

[22.9620]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &charlie_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 471 [18.305506]
[18.318971]
[18.318971]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 488 [18.305506]

∅:D[63.5867] → [18.319388:319544]

B:BD[18.319388] → [18.319388:319544]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, charlie_h)?;

[63.5867]

[22.9768]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &charlie_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 498 [18.305506]
[18.319757]
[18.319757]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 540 [18.305506]

B:BD[18.321163] → [18.321163:321247]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.321163]

[18.321247]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 548 [18.305506]
[18.321404]
[18.321404]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 573 [18.305506]

B:BD[18.322068] → [18.322068:322147]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.322068]

[22.10188]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 583 [18.305506]
[18.322394]
[18.322394]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 590 [18.305506]
B:BD[21.28488] → [21.28488:28514]
```
            OwnedPathId {
```
[21.28488]
[21.28514]
```
            &OwnedPathId {
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 612 [18.305506]

B:BD[18.323107] → [18.323107:323184]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[18.323107]

[22.10410]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 621 [18.305506]
[18.323397]
[18.323397]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 625 [18.305506]

B:BD[18.323517] → [18.323517:323601]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_solution)?;

[18.323517]

[22.10478]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_solution)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 634 [18.305506]
[18.323814]
[18.323814]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 672 [18.305506]

B:BD[18.325029] → [18.325029:325113]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.325029]

[18.325113]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 680 [18.305506]
[18.325270]
[18.325270]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 707 [18.305506]

B:BD[18.326041] → [18.326041:326120]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.326041]

[22.10830]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 718 [18.305506]
[18.326368]
[18.326368]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 742 [18.305506]

B:BD[18.327117] → [18.327117:327194]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[18.327117]

[22.11052]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 751 [18.305506]
[18.327407]
[18.327407]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 755 [18.305506]

B:BD[18.327527] → [18.327527:327611]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_solution)?;

[18.327527]

[22.11120]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_solution)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 764 [18.305506]
[18.327824]
[18.327824]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 804 [18.305506]

B:BD[18.329088] → [18.329088:329172]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.329088]

[18.329172]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 812 [18.305506]
[18.329329]
[18.329329]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 839 [18.305506]

B:BD[18.330077] → [18.330077:330156]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.330077]

[22.11472]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 849 [18.305506]
[18.330403]
[18.330403]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 873 [18.305506]

B:BD[18.331166] → [18.331166:331243]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;

[18.331166]

[22.11694]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 882 [18.305506]
[18.331456]
[18.331456]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 887 [18.305506]

B:BD[18.331577] → [18.331577:331661]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_solution)?;

[18.331577]

[22.11762]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_solution)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 896 [18.305506]
[18.331874]
[18.331874]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 941 [18.305506]

B:BD[18.333423] → [18.333423:333507]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.333423]

[18.333507]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 949 [18.305506]
[18.333664]
[18.333664]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 954 [18.305506]

B:BD[18.333815] → [18.333815:333907]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, init_h).unwrap();

[18.333815]

[18.333907]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 962 [18.305506]
[18.334092]
[18.334092]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1005 [18.305506]

B:BD[18.335246] → [18.335246:335408]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, charlie_h)?;

[18.335246]

[22.12274]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &charlie_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 1016 [18.305506]
[18.335671]
[18.335671]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1048 [18.305506]

B:BD[18.336631] → [18.336631:336787]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h)?;
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, charlie_h)?;

[18.336631]

[22.12496]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h)?;
    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &charlie_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 1058 [18.305506]
[18.337016]
[18.337016]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1067 [18.305506]

B:BD[18.337275] → [18.337275:337359]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_solution)?;

[18.337275]

[22.12632]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_solution)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 1076 [18.305506]
[18.337588]
[18.337588]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1083 [18.305506]

B:BD[18.337711] → [18.337711:337794]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, bob_h)?;

[18.337711]

[22.12700]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &bob_h)?;

Replacement in libpijul/src/tests/file_conflicts.rs at line 1086 [18.305506]

B:BD[18.337908] → [18.337908:337993]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, alice_h)?;

[18.337908]

[22.12780]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &alice_h)?;

Insertion in libpijul/src/tests/file_conflicts.rs at line 1095 [18.305506]
[18.338246]
[18.338246]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1107 [18.305506]
B:BD[18.338595] → [18.338595:338619]
```
        alice_solution,
```
[18.338595]
[18.338619]
```
        &alice_solution,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1117 [18.305506]
[18.338880]
[18.338880]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1170 [18.305506]

B:BD[18.340541] → [18.340541:340625]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h).unwrap();

[18.340541]

[18.340625]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1178 [18.305506]
[18.340782]
[18.340782]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1185 [18.305506]

B:BD[18.341012] → [18.341012:341097]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, alice_h).unwrap();

[18.341012]

[22.13156]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1194 [18.305506]
[18.341326]
[18.341326]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1214 [18.305506]
[18.341953]
[18.341953]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1222 [18.305506]

B:BD[18.342146] → [18.342146:342329]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h).unwrap();
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_resolution).unwrap();

[18.342146]

[18.342329]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h).unwrap();
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_resolution).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1231 [18.305506]
[18.342508]
[18.342508]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1240 [18.305506]

B:BD[18.342807] → [18.342807:342992]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, init_h).unwrap();
    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, alice_h).unwrap();

[18.342807]

[18.342992]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &init_h).unwrap();
    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &alice_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1249 [18.305506]
[18.343177]
[18.343177]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1270 [18.305506]

∅:D[63.5992] → [18.343693:343784]

B:BD[18.343693] → [18.343693:343784]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, bob_h).unwrap();

[63.5992]

[22.13526]

    apply::apply_change(&changes, &mut txn_charlie, &mut channel_charlie, &bob_h).unwrap();

Replacement in libpijul/src/tests/file_conflicts.rs at line 1277 [18.305506]
B:BD[18.343951] → [18.343951:343975]
```
        bob_resolution,
```
[18.343951]
[18.343975]
```
        &bob_resolution,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1288 [18.305506]
[18.344249]
[18.344249]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1298 [18.305506]

∅:D[63.6230] → [18.344643:344734]

B:BD[18.344643] → [18.344643:344734]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, charlie_h).unwrap();

[63.6230]

[22.13686]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &charlie_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1307 [18.305506]
[18.344975]
[18.344975]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1316 [18.305506]

B:BD[18.345216] → [18.345216:345303]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, charlie_h).unwrap();

[18.345216]

[22.13760]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &charlie_h).unwrap();

Insertion in libpijul/src/tests/file_conflicts.rs at line 1326 [18.305506]
[18.345533]
[18.345533]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1361 [18.305506]
B:BD[18.346664] → [18.346664:346720]
```
        .apply_change(&changes, &mut channel_bob, init)
```
[18.346664]
[18.346720]
```
        .apply_change(&changes, &mut channel_bob, &init)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1370 [18.305506]
[18.346896]
[18.346896]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1393 [18.305506]
B:BD[18.347602] → [18.347602:347661]
```
        .apply_change(&changes, &mut channel_bob, alice_h)
```
[18.347602]
[18.347661]
```
        .apply_change(&changes, &mut channel_bob, &alice_h)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1403 [18.305506]
[18.347917]
[18.347917]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1426 [18.305506]
[18.348701]
[18.348701]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1435 [18.305506]
B:BD[18.348891] → [18.348891:348950]
```
        .apply_change(&changes, &mut channel_alice, bob_h)
```
[18.348891]
[18.349038]
```
        .apply_change(&changes, &mut channel_alice, &bob_h)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1445 [18.305506]
[18.349236]
[18.349236]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1454 [18.305506]

B:BD[18.349505] → [18.349505:349569]

        .apply_change(&changes, &mut channel_alice, resolution)

[18.349505]

[18.349569]

        .apply_change(&changes, &mut channel_alice, &resolution)

Insertion in libpijul/src/tests/file_conflicts.rs at line 1463 [18.305506]
[18.349767]
[18.349767]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1499 [18.305506]
B:BD[18.350978] → [18.350978:351034]
```
        .apply_change(&changes, &mut channel_bob, init)
```
[18.350978]
[18.351034]
```
        .apply_change(&changes, &mut channel_bob, &init)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1508 [18.305506]
[18.351210]
[18.351210]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1540 [18.305506]

B:BD[18.352208] → [18.352208:352268]

        .apply_change(&changes, &mut channel_alice, bob_h1)

[18.352208]

[18.352356]

        .apply_change(&changes, &mut channel_alice, &bob_h1)

Replacement in libpijul/src/tests/file_conflicts.rs at line 1545 [18.305506]

B:BD[18.352420] → [18.352420:352480]

        .apply_change(&changes, &mut channel_alice, bob_h2)

[18.352420]

[18.352568]

        .apply_change(&changes, &mut channel_alice, &bob_h2)

Insertion in libpijul/src/tests/file_conflicts.rs at line 1566 [18.305506]
[18.353171]
[18.353171]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1600 [18.305506]
B:BD[18.354270] → [18.354270:354326]
```
        .apply_change(&changes, &mut channel_bob, init)
```
[18.354270]
[18.354326]
```
        .apply_change(&changes, &mut channel_bob, &init)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1609 [18.305506]
[18.354502]
[18.354502]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1632 [18.305506]
B:BD[18.355202] → [18.355202:355261]
```
        .apply_change(&changes, &mut channel_bob, alice_h)
```
[18.355202]
[18.355261]
```
        .apply_change(&changes, &mut channel_bob, &alice_h)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1642 [18.305506]
[18.355517]
[18.355517]
```
        None,
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1659 [18.305506]
[18.356095]
[18.356095]
```
        None,
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1668 [18.305506]
B:BD[18.356285] → [18.356285:356344]
```
        .apply_change(&changes, &mut channel_alice, bob_h)
```
[18.356285]
[18.356344]
```
        .apply_change(&changes, &mut channel_alice, &bob_h)
```
Insertion in libpijul/src/tests/file_conflicts.rs at line 1678 [18.305506]
[18.356630]
[18.356630]
```
        None,
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 1687 [18.305506]

B:BD[18.356892] → [18.356892:356956]

        .apply_change(&changes, &mut channel_alice, resolution)

[18.356892]

[18.356956]

        .apply_change(&changes, &mut channel_alice, &resolution)

Insertion in libpijul/src/tests/file_conflicts.rs at line 1696 [18.305506]
[18.357154]
[18.357154]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 25 [18.357372]

B:BD[18.358305] → [18.358305:358377]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.358305]

[18.358377]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 33 [18.357372]
[18.358530]
[18.358530]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 61 [18.357372]

B:BD[18.359463] → [18.359463:359536]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.359463]

[18.359536]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 69 [18.357372]
[18.359693]
[18.359693]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 121 [18.357372]

B:BD[18.361378] → [18.361378:361459]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.361378]

[18.361459]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 129 [18.357372]
[18.361612]
[18.361612]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 137 [18.357372]

B:BD[18.361806] → [18.361806:361890]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.361806]

[18.361890]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 145 [18.357372]
[18.362043]
[18.362043]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 161 [18.357372]
[18.362547]
[18.362547]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 191 [18.357372]

B:BD[18.363593] → [18.363593:363665]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.363593]

[18.363665]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 199 [18.357372]
[18.363818]
[18.363818]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 211 [18.357372]

B:BD[18.364189] → [18.364189:364265]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, init_h)?;

[18.364189]

[18.364265]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 219 [18.357372]
[18.364426]
[18.364426]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 255 [18.357372]

B:BD[18.365514] → [18.365514:365587]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.365514]

[18.365587]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 263 [18.357372]
[18.365744]
[18.365744]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 309 [18.357372]

B:BD[18.367282] → [18.367282:367446]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, charlie_h).unwrap();

[18.367282]

[18.367446]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &charlie_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 318 [18.357372]
[18.367599]
[18.367599]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 325 [18.357372]

B:BD[18.367755] → [18.367755:367839]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.367755]

[18.367839]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 333 [18.357372]
[18.367992]
[18.367992]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 367 [18.357372]

B:BD[18.369024] → [18.369024:369192]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alice_h).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bob_h).unwrap();

[18.369024]

[18.369192]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alice_h).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bob_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 376 [18.357372]
[18.369353]
[18.369353]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 383 [18.357372]

B:BD[18.369530] → [18.369530:369707]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, resolution).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, resolution2).unwrap();

[18.369530]

[18.369707]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &resolution).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &resolution2).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 392 [18.357372]
[18.369868]
[18.369868]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 426 [18.357372]

B:BD[18.370913] → [18.370913:370985]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.370913]

[18.370985]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 434 [18.357372]
[18.371138]
[18.371138]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 457 [18.357372]

B:BD[18.371914] → [18.371914:371987]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.371914]

[18.371987]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 465 [18.357372]
[18.372144]
[18.372144]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 497 [18.357372]

B:BD[18.373238] → [18.373238:373319]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.373238]

[18.373319]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 505 [18.357372]
[18.373472]
[18.373472]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 511 [18.357372]

B:BD[18.373614] → [18.373614:373698]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.373614]

[18.373698]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 519 [18.357372]
[18.373851]
[18.373851]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 549 [18.357372]

B:BD[18.374812] → [18.374812:374884]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.374812]

[18.374884]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 557 [18.357372]
[18.375033]
[18.375033]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 580 [18.357372]

B:BD[18.375789] → [18.375789:375862]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.375789]

[18.375862]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 588 [18.357372]
[18.376013]
[18.376013]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 631 [18.357372]
[18.377305]
[18.377305]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 640 [18.357372]

B:BD[18.377595] → [18.377595:377744]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution)?;

[18.377595]

[18.377744]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution)?;

Insertion in libpijul/src/tests/conflict.rs at line 649 [18.357372]
[18.377893]
[18.377893]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 682 [18.357372]

B:BD[18.379010] → [18.379010:379082]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.379010]

[18.379082]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 690 [18.357372]
[18.379231]
[18.379231]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 713 [18.357372]

B:BD[18.379987] → [18.379987:380060]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.379987]

[18.380060]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 721 [18.357372]
[18.380211]
[18.380211]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 752 [18.357372]
[18.381147]
[18.381147]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 760 [18.357372]

B:BD[18.381418] → [18.381418:381567]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution)?;

[18.381418]

[18.381567]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution)?;

Insertion in libpijul/src/tests/conflict.rs at line 769 [18.357372]
[18.381716]
[18.381716]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 806 [18.357372]

B:BD[18.382900] → [18.382900:382972]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.382900]

[18.382972]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 814 [18.357372]
[18.383121]
[18.383121]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 848 [18.357372]

B:BD[18.384098] → [18.384098:384176]

        apply::apply_change(&changes, &mut txn, &mut channel_alice, *bob_h)?;

[18.384098]

[18.384176]

        apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 857 [18.357372]
[18.384333]
[18.384333]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 894 [18.357372]
[18.385430]
[18.385430]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 904 [18.357372]

B:BD[18.385760] → [18.385760:385838]

        apply::apply_change(&changes, &mut txn, &mut channel_bob, *alice_h)?;

[18.385760]

[18.385838]

        apply::apply_change(&changes, &mut txn, &mut channel_bob, &*alice_h)?;

Replacement in libpijul/src/tests/conflict.rs at line 906 [18.357372]

B:BD[18.385844] → [18.385844:385924]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, conflict_edits)?;

[18.385844]

[18.385924]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &conflict_edits)?;

Insertion in libpijul/src/tests/conflict.rs at line 914 [18.357372]
[18.386073]
[18.386073]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 950 [18.357372]

B:BD[18.387282] → [18.387282:387354]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.387282]

[18.387354]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 958 [18.357372]
[18.387507]
[18.387507]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 985 [18.357372]

B:BD[18.388439] → [18.388439:388512]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.388439]

[18.388512]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 993 [18.357372]
[18.388669]
[18.388669]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1036 [18.357372]

B:BD[18.390058] → [18.390058:390139]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.390058]

[18.390139]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1044 [18.357372]
[18.390292]
[18.390292]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1051 [18.357372]

B:BD[18.390448] → [18.390448:390532]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.390448]

[22.19331]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1060 [18.357372]
[18.390745]
[18.390745]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1090 [18.357372]

B:BD[18.391733] → [18.391733:391805]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.391733]

[18.391805]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1098 [18.357372]
[18.391958]
[18.391958]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1125 [18.357372]

B:BD[18.392890] → [18.392890:392963]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.392890]

[18.392963]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1133 [18.357372]
[18.393120]
[18.393120]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1181 [18.357372]

B:BD[18.394452] → [18.394452:394533]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.394452]

[18.394533]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1189 [18.357372]
[18.394686]
[18.394686]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1196 [18.357372]

B:BD[18.394842] → [18.394842:394926]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.394842]

[22.19994]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1205 [18.357372]
[18.395139]
[18.395139]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1338 [18.357372]

B:BD[18.399351] → [18.399351:399423]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.399351]

[18.399423]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1346 [18.357372]
[18.399576]
[18.399576]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1373 [18.357372]

B:BD[18.400508] → [18.400508:400581]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.400508]

[18.400581]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1381 [18.357372]
[18.400738]
[18.400738]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1399 [18.357372]

B:BD[18.401256] → [18.401256:401337]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.401256]

[18.401337]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1407 [18.357372]
[18.401490]
[18.401490]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1415 [18.357372]

B:BD[18.401673] → [18.401673:401757]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution).unwrap();

[18.401673]

[18.401757]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1423 [18.357372]
[18.401910]
[18.401910]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1462 [18.357372]

B:BD[18.403210] → [18.403210:403282]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.403210]

[18.403282]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1470 [18.357372]
[18.403435]
[18.403435]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1500 [18.357372]

B:BD[18.404426] → [18.404426:404499]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.404426]

[18.404499]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1508 [18.357372]
[18.404656]
[18.404656]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1525 [18.357372]

B:BD[18.405243] → [18.405243:405324]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.405243]

[18.405324]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1533 [18.357372]
[18.405477]
[18.405477]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1552 [18.357372]

B:BD[18.406026] → [18.406026:406116]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, resolution_bob).unwrap();

[18.406026]

[18.406116]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &resolution_bob).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1560 [18.357372]
[18.406273]
[18.406273]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1568 [18.357372]

B:BD[18.406500] → [18.406500:406590]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution_alice).unwrap();

[18.406500]

[18.406590]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution_alice).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1576 [18.357372]
[18.406743]
[18.406743]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1630 [18.357372]

B:BD[18.408475] → [18.408475:408563]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, p_alice[0]).unwrap();

[18.408475]

[18.408563]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &p_alice[0]).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1638 [18.357372]
[18.408720]
[18.408720]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1655 [18.357372]

B:BD[18.409309] → [18.409309:409393]

        apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, *p).unwrap();

[18.409309]

[22.21531]

        apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, p).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1668 [18.357372]
[18.409631]
[18.409631]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 1692 [18.357372]
[18.410330]
[18.410330]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1700 [18.357372]

∅:D[27.28017] → [18.410481:410568]

B:BD[18.410481] → [18.410481:410568]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, p_bob).unwrap();

[27.28017]

[22.21686]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &p_bob).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1709 [18.357372]
[18.410793]
[18.410793]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1717 [18.357372]

B:BD[18.411023] → [18.411023:411115]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, resolution).unwrap();

[18.411023]

[18.411115]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1725 [18.357372]
[18.411278]
[18.411278]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1774 [18.357372]

B:BD[18.412880] → [18.412880:412968]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, p_alice[0]).unwrap();

[18.412880]

[18.412968]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &p_alice[0]).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1782 [18.357372]
[18.413125]
[18.413125]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1796 [18.357372]

B:BD[18.413565] → [18.413565:413649]

        apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, *p).unwrap();

[18.413565]

[18.413649]

        apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, p).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1806 [18.357372]
[18.413868]
[18.413868]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 1829 [18.357372]
[18.414523]
[18.414523]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1837 [18.357372]

B:BD[18.414733] → [18.414733:414912]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, p_bob).unwrap();
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, resolution).unwrap();

[18.414733]

[18.414912]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &p_bob).unwrap();
    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 1846 [18.357372]
[18.415075]
[18.415075]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1878 [18.357372]

B:BD[18.416187] → [18.416187:416259]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.416187]

[18.416259]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1886 [18.357372]
[18.416412]
[18.416412]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1898 [18.357372]

B:BD[18.416783] → [18.416783:416859]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, init_h)?;

[18.416783]

[18.416859]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1906 [18.357372]
[18.417020]
[18.417020]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1940 [18.357372]

B:BD[18.417976] → [18.417976:418049]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.417976]

[18.418049]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 1948 [18.357372]
[18.418206]
[18.418206]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 1966 [18.357372]
[18.418765]
[18.418765]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 1971 [18.357372]

B:BD[18.418887] → [18.418887:419036]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, resolution)?;

[18.418887]

[22.22561]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &resolution)?;

Replacement in libpijul/src/tests/conflict.rs at line 1983 [18.357372]

B:BD[18.419271] → [18.419271:419346]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bob_h)?;

[18.419271]

[22.22633]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bob_h)?;

Replacement in libpijul/src/tests/conflict.rs at line 1985 [18.357372]
∅:D[22.22712] → [18.419423:419500]
∅:D[27.28918] → [18.419423:419500]
B:BD[18.419423] → [18.419423:419500]
```
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alice_h)?;
```
[22.22712]
[22.22713]
```
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alice_h)?;
```
Replacement in libpijul/src/tests/conflict.rs at line 1987 [18.357372]
∅:D[22.22792] → [18.419577:419657]
∅:D[27.28989] → [18.419577:419657]
B:BD[18.419577] → [18.419577:419657]
```
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, resolution)?;
```
[22.22792]
[22.22793]
```
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &resolution)?;
```

Replacement in libpijul/src/tests/conflict.rs at line 2016 [18.357372]

B:BD[18.420710] → [18.420710:420782]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.420710]

[18.420782]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2024 [18.357372]
[18.420935]
[18.420935]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2036 [18.357372]

B:BD[18.421339] → [18.421339:421415]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, init_h)?;

[18.421339]

[18.421415]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2044 [18.357372]
[18.421576]
[18.421576]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2083 [18.357372]

B:BD[18.422771] → [18.422771:422844]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h)?;

[18.422771]

[18.422844]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2091 [18.357372]
[18.423001]
[18.423001]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2114 [18.357372]

B:BD[18.423734] → [18.423734:423815]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h).unwrap();

[18.423734]

[18.423815]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2122 [18.357372]
[18.423968]
[18.423968]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2141 [18.357372]

B:BD[18.424570] → [18.424570:424661]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alices_resolution).unwrap();

[18.424570]

[18.424661]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alices_resolution).unwrap();

Replacement in libpijul/src/tests/conflict.rs at line 2143 [18.357372]

B:BD[18.424695] → [18.424695:424778]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, charlie_h).unwrap();

[18.424695]

[22.23464]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &charlie_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2153 [18.357372]
[18.425022]
[18.425022]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 2180 [18.357372]
[18.425914]
[18.425914]
```
        None,
```
Insertion in libpijul/src/tests/conflict.rs at line 2198 [18.357372]
[18.426422]
[18.426422]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2237 [18.357372]

B:BD[18.427746] → [18.427746:427818]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, init_h)?;

[18.427746]

[18.427818]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2245 [18.357372]
[18.427971]
[18.427971]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2291 [18.357372]

B:BD[18.429544] → [18.429544:429766]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_alice, bob_h3)?;

[18.429544]

[18.429766]

    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_alice, &bob_h3)?;

Insertion in libpijul/src/tests/conflict.rs at line 2301 [18.357372]
[18.429923]
[18.429923]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2324 [18.357372]

B:BD[18.430656] → [18.430656:430902]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h1).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h2).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, alice_h3).unwrap();

[18.430656]

[18.430902]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h1).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h2).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alice_h3).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2334 [18.357372]
[18.431055]
[18.431055]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2356 [18.357372]

B:BD[18.431817] → [18.431817:432355]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, init_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alice_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alice_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alice_h3)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bob_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bob_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bob_h3)?;

[18.431817]

[18.432355]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &init_h)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alice_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alice_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alice_h3)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bob_h1)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bob_h2)?;
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bob_h3)?;

Insertion in libpijul/src/tests/conflict.rs at line 2370 [18.357372]
[18.432516]
[18.432516]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2385 [18.357372]

B:BD[18.432813] → [18.432813:432904]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, alices_resolution).unwrap();

[18.432813]

[22.24198]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &alices_resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2395 [18.357372]
[18.433148]
[18.433148]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2403 [18.357372]

B:BD[18.433351] → [18.433351:433434]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, charlie_h).unwrap();

[18.433351]

[22.24342]

    apply::apply_change(&changes, &mut txn, &mut channel_bob, &charlie_h).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2420 [18.357372]
[18.433918]
[18.433918]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2437 [18.357372]

B:BD[18.434473] → [18.434473:434661]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, alices_resolution).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, bobs_resolution).unwrap();

[18.434473]

[22.24486]

    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &alices_resolution).unwrap();
    apply::apply_change(&changes, &mut txn, &mut channel_charlie, &bobs_resolution).unwrap();

Insertion in libpijul/src/tests/conflict.rs at line 2454 [18.357372]
[18.435138]
[18.435138]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2499 [18.357372]

B:BD[18.436595] → [18.436595:436671]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h)?;

[18.436595]

[18.436671]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2507 [18.357372]
[18.436828]
[18.436828]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2524 [18.357372]

B:BD[18.437318] → [18.437318:437394]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, ab)?;

[18.437318]

[22.24725]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &ab)?;

Insertion in libpijul/src/tests/conflict.rs at line 2534 [18.357372]
[18.437652]
[18.437652]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2588 [18.357372]

B:BD[18.439343] → [18.439343:439419]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, init_h)?;

[18.439343]

[18.439419]

    apply::apply_change(&changes, &mut txn_bob, &mut channel_bob, &init_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2596 [18.357372]
[18.439576]
[18.439576]
```
        None,
```

Replacement in libpijul/src/tests/conflict.rs at line 2609 [18.357372]

B:BD[18.440000] → [18.440000:440079]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, bob_h)?;

[18.440000]

[18.440079]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_h)?;

Insertion in libpijul/src/tests/conflict.rs at line 2617 [18.357372]
[18.440242]
[18.440242]
```
        None,
```
Replacement in libpijul/src/tests/conflict.rs at line 2627 [18.357372]
B:BD[21.29278] → [21.29278:29320]
```
        let (inode, vertex) = x.unwrap();
```
[21.29278]
[18.440461]
```
        let (&inode, &vertex) = x.unwrap();
```

Replacement in libpijul/src/tests/conflict.rs at line 2631 [18.357372]

B:BD[18.440589] → [21.29321:29394]

            if let Some(next) = txn.get_revtree(inode_, None).unwrap() {

[18.440589]

[18.440653]

            if let Some(next) = txn.get_revtree(&inode_, None).unwrap() {

Replacement in libpijul/src/tests/conflict.rs at line 2638 [18.357372]

B:BD[18.440857] → [22.25096:25176]

        if !is_alive(txn, T::graph(&channel), vertex.inode_vertex()).unwrap() {

[18.440857]

[27.31350]

        if !is_alive(txn, T::graph(txn, &channel), &vertex.inode_vertex()).unwrap() {

Replacement in libpijul/src/tests/conflict.rs at line 2641 [18.357372]
B:BD[27.31407] → [22.25177:25213]
```
                T::graph(&channel),
```
[27.31407]
[18.440983]
```
                T::graph(txn, &channel),
```
Replacement in libpijul/src/tests/conflict.rs at line 2654 [18.357372]
B:BD[18.441311] → [27.31408:31447]
```
                tree_path(txn, vertex)
```
[18.441311]
[18.441349]
```
                tree_path(txn, &vertex)
```

Replacement in libpijul/src/tests/clone.rs at line 54 [18.441393]

B:BD[18.443244] → [18.443244:443325]

            apply::apply_change(&changes, &mut txn2, &mut channel, *h).unwrap();

[18.443244]

[22.25350]

            apply::apply_change(&changes, &mut txn2, &mut channel, h).unwrap();

Insertion in libpijul/src/tests/clone.rs at line 63 [18.441393]
[18.443589]
[18.443589]
```
                None,
```

Replacement in libpijul/src/tests/clone.rs at line 119 [18.441393]

B:BD[18.445332] → [18.445332:445408]

        apply::apply_change(&changes, &mut txn2, &mut channel, h).unwrap();

[18.445332]

[18.445408]

        apply::apply_change(&changes, &mut txn2, &mut channel, &h).unwrap();

Insertion in libpijul/src/tests/clone.rs at line 127 [18.441393]
[18.445586]
[18.445586]
```
            None,
```

Replacement in libpijul/src/tests/clone.rs at line 137 [18.441393]

B:BD[18.445808] → [18.445808:445885]

        apply::apply_change(&changes, &mut txn2, &mut channel, h2).unwrap();

[18.445808]

[18.445885]

        apply::apply_change(&changes, &mut txn2, &mut channel, &h2).unwrap();

Insertion in libpijul/src/tests/clone.rs at line 145 [18.441393]
[18.446060]
[18.446060]
```
            None,
```

Replacement in libpijul/src/tests/change.rs at line 76 [18.446445]

B:BD[18.448734] → [18.448734:448824]

    apply::apply_local_change(&mut txn, &mut channel, &change0, hash0, &rec.updatables)?;

[18.448734]

[18.448824]

    apply::apply_local_change(&mut txn, &mut channel, &change0, &hash0, &rec.updatables)?;

Replacement in libpijul/src/tests/change.rs at line 129 [18.446445]

B:BD[18.449978] → [18.449978:450057]

    apply::apply_local_change(txn, channel, &change0, hash, &rec.updatables)?;

[18.449978]

[18.450057]

    apply::apply_local_change(txn, channel, &change0, &hash, &rec.updatables)?;

Replacement in libpijul/src/tests/change.rs at line 174 [18.446445]

B:BD[18.451597] → [18.451597:451888]

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

[18.451597]

[18.451888]

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

Replacement in libpijul/src/tests/change.rs at line 182 [18.446445]

B:BD[18.452043] → [18.452043:452206]

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

[18.452043]

[18.452206]

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

Replacement in libpijul/src/tests/change.rs at line 227 [18.446445]

B:BD[18.453555] → [18.453555:453683]

            error!("change0.changes = {:#?}", change0.changes);
            error!("change1.changes = {:#?}", change1.changes);

[18.453555]

[18.453683]

            trace!("change0.changes = {:#?}", change0.changes);
            trace!("change1.changes = {:#?}", change1.changes);

Replacement in libpijul/src/tests/change.rs at line 231 [18.446445]

B:BD[18.453779] → [18.453779:453869]

                error!("change0: {:#?}", a);
                error!("change1: {:#?}", b);

[18.453779]

[18.453869]

                trace!("change0: {:#?}", a);
                trace!("change1: {:#?}", b);
                for (a, b) in a.iter().zip(b.iter()) {
                    if a != b {
                        error!("change0 -> {:#?}", a);
                        error!("change1 -> {:#?}", b);
                    }
                }

Replacement in libpijul/src/tests/add_file.rs at line 37 [18.454125]

B:BD[21.30324] → [21.30324:30385]

        let (key, meta, file) = it.next().unwrap().unwrap();

[21.30324]

[18.455413]

        let (key, _, meta, file) = it.next().unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 42 [18.454125]

B:BD[21.30485] → [21.30485:30545]

        let (file_key, _, _) = it.next().unwrap().unwrap();

[21.30485]

[21.30545]

        let (file_key, _, _, _) = it.next().unwrap().unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 98 [18.454125]
B:BD[18.457239] → [18.457239:457289]
```
fn del_file_test() -> Result<(), anyhow::Error> {
```
[18.457239]
[18.457289]
```
fn del_file_test() {
```

Replacement in libpijul/src/tests/add_file.rs at line 104 [18.454125]

B:BD[18.457443] → [18.457443:457501]

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

[18.457443]

[18.457501]

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

Replacement in libpijul/src/tests/add_file.rs at line 107 [18.454125]

B:BD[18.457550] → [18.457550:457648]

        txn.add_file("dir/file")?;
        let mut channel = txn.open_or_create_channel("main")?;

[18.457550]

[18.457648]

        txn.add_file("dir/file").unwrap();
        let mut channel = txn.open_or_create_channel("main").unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 111 [18.454125]

B:BD[18.457716] → [18.457716:457793]

        record_all_output(&mut repo, &changes, &mut txn, &mut channel, "")?;

[18.457716]

[22.25614]

        record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 118 [18.454125]

B:BD[18.458037] → [18.458037:458109]

        repo.remove_path("dir/file")?;
        txn.remove_file("dir")?;

[18.458037]

[18.458109]

        repo.remove_path("dir/file").unwrap();
        txn.remove_file("dir").unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 127 [18.454125]

B:BD[18.458320] → [18.458320:458397]

        record_all_output(&mut repo, &changes, &mut txn, &mut channel, "")?;

[18.458320]

[22.25682]

        record_all_output(&mut repo, &changes, &mut txn, &mut channel, "").unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 137 [18.454125]

B:BD[18.458708] → [18.458708:458778]

        txn.add_file("dir2/file")?;
        txn.remove_file("dir2")?;

[18.458708]

[21.31279]

        txn.add_file("dir2/file").unwrap();
        txn.remove_file("dir2").unwrap();

Replacement in libpijul/src/tests/add_file.rs at line 141 [18.454125]
B:BD[18.458927] → [18.458927:458950]
```
        txn.commit()?;
```
[18.458927]
[18.458950]
```
        txn.commit().unwrap();
```
Replacement in libpijul/src/tests/add_file.rs at line 145 [18.454125]
B:BD[18.458963] → [18.458963:458999]
```
        let txn = env.txn_begin()?;
```
[18.458963]
[18.458999]
```
        let txn = env.txn_begin().unwrap();
```
Deletion in libpijul/src/tests/add_file.rs at line 152 [18.454125]
B:BD[18.459214] → [30.2860:2871]
```
    Ok(())
```

Replacement in libpijul/src/tests/add_file.rs at line 181 [18.454125]

B:BD[30.3977] → [30.3977:4076]

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

[30.3977]

[30.4076]

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

Replacement in libpijul/src/tests/add_file.rs at line 289 [18.454125]

B:BD[18.462833] → [18.462833:462905]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, alice0)?;

[18.462833]

[18.462905]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, &alice0)?;

Insertion in libpijul/src/tests/add_file.rs at line 297 [18.454125]
[18.463058]
[18.463058]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 303 [18.454125]

B:BD[18.463214] → [18.463214:463286]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, alice1)?;

[18.463214]

[18.463286]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, &alice1)?;

Insertion in libpijul/src/tests/add_file.rs at line 311 [18.454125]
[18.463439]
[18.463439]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 362 [18.454125]

B:BD[18.465433] → [18.465433:465505]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, alice0)?;

[18.465433]

[18.465505]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, &alice0)?;

Insertion in libpijul/src/tests/add_file.rs at line 370 [18.454125]
[18.465658]
[18.465658]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 374 [18.454125]

B:BD[18.465717] → [18.465717:465789]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, alice1)?;

[18.465717]

[18.465789]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, &alice1)?;

Insertion in libpijul/src/tests/add_file.rs at line 382 [18.454125]
[18.465942]
[18.465942]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 388 [18.454125]

B:BD[18.466058] → [18.466058:466130]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, alice2)?;

[18.466058]

[18.466130]

    apply::apply_change(&changes, &mut txn_bob, &mut channel, &alice2)?;

Insertion in libpijul/src/tests/add_file.rs at line 396 [18.454125]
[18.466283]
[18.466283]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 473 [18.454125]

B:BD[18.468992] → [18.468992:469050]

        .apply_change(&changes, &mut channel_bob, alice1)

[18.468992]

[18.469050]

        .apply_change(&changes, &mut channel_bob, &alice1)

Insertion in libpijul/src/tests/add_file.rs at line 482 [18.454125]
[18.469226]
[18.469226]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 488 [18.454125]

B:BD[18.469431] → [18.469431:469489]

        .apply_change(&changes, &mut channel_bob, alice2)

[18.469431]

[18.469489]

        .apply_change(&changes, &mut channel_bob, &alice2)

Insertion in libpijul/src/tests/add_file.rs at line 498 [18.454125]
[18.469725]
[18.469725]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 502 [18.454125]

B:BD[18.469782] → [18.469782:469840]

        .apply_change(&changes, &mut channel_bob, alice3)

[18.469782]

[18.469840]

        .apply_change(&changes, &mut channel_bob, &alice3)

Insertion in libpijul/src/tests/add_file.rs at line 512 [18.454125]
[18.470076]
[18.470076]
```
        None,
```

Replacement in libpijul/src/tests/add_file.rs at line 522 [18.454125]

B:BD[18.470374] → [18.470374:470430]

            .apply_change(&changes, &mut channel, bob1)

[18.470374]

[18.470430]

            .apply_change(&changes, &mut channel, &bob1)

Insertion in libpijul/src/tests/add_file.rs at line 533 [18.454125]
[18.470723]
[18.470723]
```
            None,
```

Replacement in libpijul/src/tests/add_file.rs at line 540 [18.454125]

B:BD[18.470883] → [18.470883:470939]

            .apply_change(&changes, &mut channel, bob2)

[18.470883]

[18.470939]

            .apply_change(&changes, &mut channel, &bob2)

Insertion in libpijul/src/tests/add_file.rs at line 550 [18.454125]
[18.471231]
[18.471231]
```
            None,
```
Insertion in libpijul/src/tests/add_file.rs at line 563 [18.454125]
[18.471575]
[18.471575]
```
            None,
```
Insertion in libpijul/src/tests/add_file.rs at line 576 [18.454125]
[18.471939]
[18.471939]
```
            None,
```

Replacement in libpijul/src/tests/add_file.rs at line 584 [18.454125]

B:BD[18.472144] → [18.472144:472200]

            .apply_change(&changes, &mut channel, bob1)

[18.472144]

[18.472200]

            .apply_change(&changes, &mut channel, &bob1)

Insertion in libpijul/src/tests/add_file.rs at line 595 [18.454125]
[18.472493]
[18.472493]
```
            None,
```

Replacement in libpijul/src/tests/add_file.rs at line 606 [18.454125]

B:BD[18.472825] → [18.472825:472881]

            .apply_change(&changes, &mut channel, bob2)

[18.472825]

[18.472881]

            .apply_change(&changes, &mut channel, &bob2)

Insertion in libpijul/src/tests/add_file.rs at line 615 [18.454125]
[18.473105]
[18.473105]
```
            None,
```
Insertion in libpijul/src/tests/add_file.rs at line 628 [18.454125]
[18.473449]
[18.473449]
```
            None,
```
Insertion in libpijul/src/tests/add_file.rs at line 673 [18.454125]
[18.475068]
[18.475068]
```
        None,
```
Replacement in libpijul/src/tests/add_file.rs at line 728 [18.454125]
B:BD[18.476496] → [18.476496:476514]
```
        h_alice2,
```
[18.476496]
[18.476514]
```
        &h_alice2,
```

Replacement in libpijul/src/small_string.rs at line 12 [18.480474]

B:BD[18.480774] → [18.480774:480895]

#[derive(Clone, Copy)]
pub struct SmallStr<'a> {
    pub p: *const u8,
    pub marker: std::marker::PhantomData<&'a ()>,

[18.480774]

[18.480895]

pub struct SmallStr {
    len: u8,
    _str: [u8]

Replacement in libpijul/src/small_string.rs at line 25 [18.480474]
B:BD[18.481114] → [18.481114:481151]
```
        self.as_small_str().fmt(fmt)
```
[18.481114]
[18.481151]
```
        use std::ops::Deref;
        self.deref().fmt(fmt)
```
Replacement in libpijul/src/small_string.rs at line 30 [18.480474]
B:BD[18.481160] → [18.481160:481198]
```
impl<'a> PartialEq for SmallStr<'a> {
```
[18.481160]
[18.481198]
```
impl PartialEq for SmallStr {
```

Insertion in libpijul/src/small_string.rs at line 36 [18.480474]

[18.481285]

impl std::ops::Deref for SmallString {
    type Target = SmallStr;
    fn deref(&self) -> &Self::Target {
        let len = self.len as usize;
        unsafe {
            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, 1 + len))
        }
    }
}
impl AsRef<SmallStr> for SmallString {
    fn as_ref(&self) -> &SmallStr {
        let len = self.len as usize;
        unsafe {
            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, 1 + len))
        }
    }
}
impl AsMut<SmallStr> for SmallString {
    fn as_mut(&mut self) -> &mut SmallStr {
        let len = self.len as usize;
        unsafe {
            std::mem::transmute(std::slice::from_raw_parts_mut(self as *mut Self as *mut u8, 1 + len))
        }
    }
}
impl std::ops::DerefMut for SmallString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        let len = self.len as usize;
        unsafe {
            std::mem::transmute(std::slice::from_raw_parts_mut(self as *mut Self as *mut u8, 1 + len))
        }
    }
}

Replacement in libpijul/src/small_string.rs at line 81 [18.480474]

B:BD[18.481501] → [18.481501:481663]

    assert_eq!(s0.as_small_str(), s1.as_small_str());
    assert_eq!(s0.as_small_str(), s0.as_small_str());
    assert_eq!(s1.as_small_str(), s1.as_small_str());

[18.481501]

[18.481663]

    assert_eq!(s0, s1);
    assert_eq!(s0, s0);
    assert_eq!(s1, s1);

Deletion in libpijul/src/small_string.rs at line 90 [18.480474]
B:BD[18.481782] → [18.481782:481847]
```
    assert_eq!(format!("{:?}", s.as_small_str()), "\"blabla\"");
```
Replacement in libpijul/src/small_string.rs at line 92 [18.480474]
B:BD[18.481850] → [18.481850:481882]
```
impl<'a> Eq for SmallStr<'a> {}
```
[18.481850]
[18.481882]
```
impl Eq for SmallStr {}
```
Replacement in libpijul/src/small_string.rs at line 100 [18.480474]
B:BD[18.482032] → [18.482032:482158]
```
/*
impl<'a> std::hash::Hash for SmallStr<'a> {
fn hash<H: std::hash::Hasher>(&self, x: &mut H) {
self.as_str().hash(x)
}
}
*/
```
[18.482032]
[18.482158]
Replacement in libpijul/src/small_string.rs at line 107 [18.480474]
B:BD[18.482290] → [18.482290:482329]
```
impl<'a> PartialOrd for SmallStr<'a> {
```
[18.482290]
[18.482329]
```
impl PartialOrd for SmallStr {
```
Replacement in libpijul/src/small_string.rs at line 112 [18.480474]
B:BD[18.482455] → [18.482455:482487]
```
impl<'a> Ord for SmallStr<'a> {
```
[18.482455]
[18.482487]
```
impl Ord for SmallStr {
```
Deletion in libpijul/src/small_string.rs at line 133 [18.480474]
B:BD[18.482993] → [18.482993:483045]
```
    assert!(s0.as_small_str() < s1.as_small_str());
```
Insertion in libpijul/src/small_string.rs at line 134 [18.480474]
[18.483067]
[18.483067]
```
    assert!(s0 < s1);
```
Replacement in libpijul/src/small_string.rs at line 138 [18.480474]
B:BD[18.483125] → [18.483125:483169]
```
impl<'a> std::fmt::Debug for SmallStr<'a> {
```
[18.483125]
[18.483169]
```
impl std::fmt::Debug for SmallStr {
```

Deletion in libpijul/src/small_string.rs at line 204 [18.480474]

B:BD[18.484725] → [18.484725:485173]

    }
    /// ```ignore
    /// use libpijul::small_string::*;
    /// let mut s = SmallString::from_str("blah");
    /// let s_ = s.as_small_str();
    /// let s2_ = s_;
    /// let s3_ = s_.clone();
    /// assert_eq!(s_, s2_);
    /// assert_eq!(s_, s3_);
    /// ```
    pub fn as_small_str(&self) -> SmallStr {
        SmallStr {
            p: self as *const SmallString as *const u8,
            marker: std::marker::PhantomData,
        }

Replacement in libpijul/src/small_string.rs at line 207 [18.480474]
B:BD[18.485215] → [18.485215:485252]
```
        self.as_small_str().as_str()
```
[18.485215]
[18.485252]
```
        use std::ops::Deref;
        self.deref().as_str()
```
Replacement in libpijul/src/small_string.rs at line 212 [18.480474]
B:BD[18.485297] → [18.485297:485336]
```
        self.as_small_str().as_bytes()
```
[18.485297]
[18.485336]
```
        use std::ops::Deref;
        self.deref().as_bytes()
```

Replacement in libpijul/src/small_string.rs at line 216 [18.480474]

B:BD[18.485344] → [18.485344:485489]


impl SmallStr<'static> {
    pub const EMPTY: SmallStr<'static> = SmallStr {
        p: [0].as_ptr(),
        marker: std::marker::PhantomData,

[18.485344]

[18.485489]

/*
impl SmallStr {
    pub const EMPTY: &'static SmallStr = &SmallStr {
        len: 0,
        str: [][..]

Replacement in libpijul/src/small_string.rs at line 223 [18.480474]
B:BD[18.485498] → [18.485498:485523]
```
impl<'a> SmallStr<'a> {
```
[18.485498]
[18.485523]
```
*/
impl SmallStr {
```
Replacement in libpijul/src/small_string.rs at line 242 [18.480474]
B:BD[18.486038] → [18.486038:486076]
```
        unsafe { (*self.p) as usize }
```
[18.486038]
[18.486076]
```
        self.len as usize
```
Replacement in libpijul/src/small_string.rs at line 245 [18.480474]
B:BD[18.486083] → [18.486083:486121]
```
    pub fn as_str(&self) -> &'a str {
```
[18.486083]
[18.486121]
```
    pub fn as_str(&self) -> &str {
```

Replacement in libpijul/src/small_string.rs at line 249 [18.480474]

B:BD[18.486194] → [18.486194:486317]

    pub fn as_bytes(&self) -> &'a [u8] {
        unsafe { std::slice::from_raw_parts(self.p.offset(1), *self.p as usize) }

[18.486194]

[18.486317]

    pub fn as_bytes(&self) -> &[u8] {
        let s: &[u8] = unsafe { std::mem::transmute(self) };
        &s[1..]

Deletion in libpijul/src/small_string.rs at line 278 [18.480474]

B:BD[18.486861] → [18.486861:487065]

        let s = SmallString::from_str("blah");
        let s_ = s.as_small_str();
        let s2_ = s_;
        let s3_ = s_.clone();
        assert_eq!(s_, s2_);
        assert_eq!(s_, s3_);
    }
    {

Replacement in libpijul/src/small_string.rs at line 279 [18.480474]
B:BD[18.487112] → [18.487112:487158]
```
        assert!(s.as_small_str().is_empty());
```
[18.487112]
[18.487158]
```
        assert!(s.is_empty());
```
Replacement in libpijul/src/small_string.rs at line 281 [18.480474]
B:BD[18.487186] → [18.487186:487233]
```
        assert!(!s.as_small_str().is_empty());
```
[18.487186]
[18.487233]
```
        assert!(!s.is_empty());
```
Replacement in libpijul/src/small_string.rs at line 285 [18.480474]
B:BD[18.487292] → [18.487292:487349]
```
        assert_eq!(s.as_small_str().len(), "blah".len())
```
[18.487292]
[18.487349]
```
        assert_eq!(s.len(), "blah".len())
```

Replacement in libpijul/src/small_string.rs at line 289 [18.480474]

B:BD[18.487358] → [18.487358:487619]

/// An internal "unsafe" version of a [`small_string::SmallStr`], used
/// to circumvent the absence of associated type constructors in Rust
/// (else this would be borrow on a table).
#[derive(Clone, Copy)]
#[doc(hidden)]
pub struct UnsafeSmallStr(*const u8);

[18.487358]

[18.487619]

impl sanakirja::UnsizedStorable for SmallStr {
    const ALIGN: usize = 1;

Replacement in libpijul/src/small_string.rs at line 292 [18.480474]

B:BD[18.487620] → [18.487620:487781]

impl std::fmt::Debug for UnsafeSmallStr {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        unsafe { self.to_small_str().fmt(fmt) }

[18.487620]

[18.487781]

    fn size(&self) -> usize {
        1 + self.len as usize

Insertion in libpijul/src/small_string.rs at line 295 [18.480474]

[18.487787]

    unsafe fn write_to_page(&self, p: *mut u8) {
        std::ptr::copy(&self.len, p, 1 + self.len as usize);
        debug!("writing {:?}", std::slice::from_raw_parts(p, 1+self.len as usize));
    }
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
        smallstr_from_raw_ptr(p)
    }
    unsafe fn onpage_size(p: *const u8) -> usize {
        let len = *p as usize;
        debug!("onpage_size {:?}", std::slice::from_raw_parts(p, 1+len as usize));
        1 + len
    }

Replacement in libpijul/src/small_string.rs at line 309 [18.480474]

B:BD[18.487790] → [18.487790:487899]

impl UnsafeSmallStr {
    pub fn from_small_str(u: SmallStr) -> UnsafeSmallStr {
        UnsafeSmallStr(u.p)

[18.487790]

[18.487899]

impl sanakirja::Storable for SmallStr {
    fn compare<T>(&self, _: &T, x: &Self) -> std::cmp::Ordering {
        self.cmp(x)

Replacement in libpijul/src/small_string.rs at line 313 [18.480474]

B:BD[18.487905] → [18.487905:488063]

    pub unsafe fn to_small_str<'a>(&self) -> SmallStr<'a> {
        SmallStr {
            p: self.0,
            marker: std::marker::PhantomData,
        }

[18.487905]

[18.488063]

    type PageReferences = std::iter::Empty<u64>;
    fn page_references(&self) -> Self::PageReferences {
        std::iter::empty()

Replacement in libpijul/src/small_string.rs at line 319 [18.480474]

B:BD[18.488072] → [18.488072:488859]

impl sanakirja::Representable for UnsafeSmallStr {
    fn alignment() -> sanakirja::Alignment {
        sanakirja::Alignment::B1
    }
    fn onpage_size(&self) -> u16 {
        unsafe {
            let len = (*self.0) as u16;
            1 + len
        }
    }
    unsafe fn write_value(&self, p: *mut u8) {
        std::ptr::copy(self.0, p, self.onpage_size() as usize)
    }
    unsafe fn read_value(p: *const u8) -> Self {
        UnsafeSmallStr(p)
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        let a = UnsafeSmallStr(self.0).to_small_str();
        let b = x.to_small_str();
        a.as_str().cmp(b.as_str())
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()

[18.488072]

[18.488859]

unsafe fn smallstr_from_raw_ptr<'a>(p: *const u8) -> &'a SmallStr {
    let len = *p as usize;
    std::mem::transmute(std::slice::from_raw_parts(p, 1 + len as usize))
}
#[test]
fn smallstr_repr() {
    use sanakirja::UnsizedStorable;
    let o = SmallString::from_str("blablabla");
    let mut x = vec![0u8; 200];
    unsafe {
        o.write_to_page(x.as_mut_ptr());
        let p = smallstr_from_raw_ptr(x.as_ptr());
        assert_eq!(p.as_str(), "blablabla")

Replacement in libpijul/src/record.rs at line 50 [18.488880]

B:BD[18.489422] → [18.489422:489479]

    pub(crate) redundant: Vec<(Vertex<ChangeId>, Edge)>,

[18.489422]

[18.489479]

    pub(crate) redundant: Vec<(Vertex<ChangeId>, SerializedEdge)>,

Replacement in libpijul/src/record.rs at line 161 [18.488880]

B:BD[18.492241] → [21.32087:32184]

fn get_inodes<T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
    txn: &T,

[18.492241]

[22.28003]

fn get_inodes<'a, T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
    txn: &'a T,

Replacement in libpijul/src/record.rs at line 164 [18.488880]

∅:D[22.28029] → [21.32210:32293]

B:BD[21.32210] → [21.32210:32293]

    inode: Inode,
) -> Result<Option<Position<ChangeId>>, TxnErr<T::GraphError>> {

[22.28029]

[21.32293]

    inode: &Inode,
) -> Result<Option<&'a Position<ChangeId>>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/record.rs at line 168 [18.488880]

B:BD[18.492412] → [43.1136:1201]

            .get_changeset(txn.changes(channel), vertex.change)?

[18.492412]

[18.492478]

            .get_changeset(txn.changes(channel), &vertex.change)?

Replacement in libpijul/src/record.rs at line 214 [18.488880]

B:BD[18.493753] → [21.32865:32947]

            } else if let Some(vertex) = get_inodes(txn, &channel, item.inode)? {

[18.493753]

[66.0]

            } else if let Some(&vertex) = get_inodes(txn, &channel, &item.inode)? {

Replacement in libpijul/src/record.rs at line 267 [18.488880]

B:BD[18.495974] → [18.495974:496047]

        let name_start = ChangePosition(self.rec.contents.len() as u64);

[18.495974]

[18.496047]

        let name_start = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 270 [18.488880]

B:BD[18.496160] → [18.496160:496231]

        let name_end = ChangePosition(self.rec.contents.len() as u64);

[18.496160]

[18.496294]

        let name_end = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 272 [18.488880]

B:BD[18.496329] → [18.496329:496401]

        let inode_pos = ChangePosition(self.rec.contents.len() as u64);

[18.496329]

[18.496401]

        let inode_pos = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 276 [18.488880]

B:BD[18.496480] → [18.496480:496552]

            let start = ChangePosition(self.rec.contents.len() as u64);

[18.496480]

[18.496552]

            let start = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 278 [18.488880]

B:BD[18.496630] → [18.496630:496780]

            let end = ChangePosition(self.rec.contents.len() as u64);
            self.rec.largest_file = self.rec.largest_file.max(end.0 - start.0);

[18.496630]

[18.496780]

            let end = ChangePosition(self.rec.contents.len().into());
            self.rec.largest_file = self.rec.largest_file.max(end.0.as_u64() - start.0.as_u64());

Replacement in libpijul/src/record.rs at line 281 [18.488880]

B:BD[18.496823] → [18.496823:496931]

                let s = start.0 as usize;
                let e = (end.0 as usize).min(s + CHECK_UTF8 + 4);

[18.496823]

[18.496931]

                let s = start.0.into();
                let e = end.0.as_usize().min(s + CHECK_UTF8 + 4);

Insertion in libpijul/src/record.rs at line 379 [18.488880]
[18.500045]
[43.1284]
Insertion in libpijul/src/record.rs at line 381 [18.488880]
[43.1378]
[21.33350]
```
            debug!("name_ = {:?}", name_);
```

Replacement in libpijul/src/record.rs at line 383 [18.488880]

B:BD[21.33382] → [21.33382:33439]

            if !name_.flag.contains(EdgeFlags::PARENT) {

[21.33382]

[21.33439]

            if !name_.flag().contains(EdgeFlags::PARENT) {
                debug!("continue");

Replacement in libpijul/src/record.rs at line 387 [18.488880]

∅:D[21.33479] → [18.500208:500308]

B:BD[18.500208] → [18.500208:500308]

            debug!("name_ = {:?}", name_);
            if name_.flag.contains(EdgeFlags::DELETED) {

[21.33479]

[18.500308]

            if name_.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/record.rs at line 392 [18.488880]

B:BD[18.500452] → [43.1379:1468]

            let name_dest = txn.find_block_end(txn.graph(channel), name_.dest).unwrap();

[18.500452]

[18.500531]

            let name_dest = txn.find_block_end(txn.graph(channel), name_.dest()).unwrap();

Replacement in libpijul/src/record.rs at line 395 [18.488880]

B:BD[23.11892] → [21.33567:33653]

                .get_contents(|p| txn.get_external(p).unwrap(), name_dest, &mut name)

[23.11892]

[23.11969]

                .get_contents(|p| txn.get_external(&p).unwrap().map(From::from), *name_dest, &mut name)

Replacement in libpijul/src/record.rs at line 404 [18.488880]

∅:D[67.86] → [68.395:495]

∅:D[15.905] → [68.395:495]

B:BD[18.500926] → [68.395:495]

            if let Some(v_papa) = iter_adjacent(txn, txn.graph(channel), name_dest, f0, f1)?.next()

[15.905]

[68.495]

            if let Some(v_papa) = iter_adjacent(txn, txn.graph(channel), *name_dest, f0, f1)?.next()

Replacement in libpijul/src/record.rs at line 407 [18.488880]

B:BD[21.33790] → [67.87:150]

                if !v_papa.flag.contains(EdgeFlags::DELETED) {

[21.33790]

[67.150]

                if !v_papa.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/record.rs at line 411 [18.488880]

B:BD[67.272] → [67.272:329]

                        parent: v_papa.dest.to_option(),

[67.272]

[67.329]

                        parent: v_papa.dest().to_option(),

Replacement in libpijul/src/record.rs at line 520 [18.488880]

B:BD[21.34395] → [22.29116:29186]

∅:D[22.29186] → [21.34466:34542]

B:BD[21.34466] → [21.34466:34542]

            let child = txn.find_block(channel, child.dest).unwrap();
            for grandchild in iter_adjacent(txn, channel, child, f0, f1)? {

[21.34395]

[21.34542]

            let child = txn.find_block(channel, child.dest()).unwrap();
            for grandchild in iter_adjacent(txn, channel, *child, f0, f1)? {

Replacement in libpijul/src/record.rs at line 525 [18.488880]

B:BD[21.34626] → [21.34626:34711]

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

[21.34626]

[21.34711]

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

Replacement in libpijul/src/record.rs at line 527 [18.488880]

B:BD[21.34801] → [21.34801:34886]

                        if let Some(path) = crate::fs::inode_filename(txn, inode)? {

[21.34801]

[21.34886]

                        if let Some(path) = crate::fs::inode_filename(txn, *inode)? {

Replacement in libpijul/src/record.rs at line 538 [18.488880]

B:BD[5.281] → [5.281:371]

                        .get_contents(|p| txn.get_external(p).unwrap(), child, &mut name)

[5.281]

[5.371]

                        .get_contents(|p| txn.get_external(&p).unwrap().map(From::from), *child, &mut name)

Replacement in libpijul/src/record.rs at line 555 [18.488880]
∅:D[5.888] → [18.504535:504576]
B:BD[18.504535] → [18.504535:504576]
```
                        grandchild.dest,
```
[5.888]
[21.35074]
```
                        grandchild.dest(),
```

Replacement in libpijul/src/record.rs at line 589 [18.488880]

B:BD[18.505236] → [21.35431:35487]

        for x in txn.iter_tree(fileid.clone(), None)? {

[18.505236]

[21.35487]

        for x in txn.iter_tree(&fileid, None)? {

Replacement in libpijul/src/record.rs at line 613 [18.488880]
B:BD[18.506196] → [18.506196:506236]
```
                    inode: child_inode,
```
[18.506196]
[18.506236]
```
                    inode: *child_inode,
```

Replacement in libpijul/src/record.rs at line 621 [18.488880]

B:BD[21.35616] → [43.1811:1912]

                self.record_deleted_file(txn, txn.graph(channel), working_copy, &full_path, vertex)?

[21.35616]

[18.506617]

                self.record_deleted_file(txn, txn.graph(channel), working_copy, &full_path, *vertex)?

Replacement in libpijul/src/record.rs at line 671 [18.488880]

B:BD[18.508068] → [18.508068:508141]

        let name_start = ChangePosition(self.rec.contents.len() as u64);

[18.508005]

[23.12529]

        let name_start = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 674 [18.488880]

B:BD[18.508255] → [18.508255:508326]

        let name_end = ChangePosition(self.rec.contents.len() as u64);

[18.508255]

[18.508326]

        let name_end = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/record.rs at line 676 [18.488880]

B:BD[18.508361] → [18.508361:508444]

        let name = &self.rec.contents[name_start.0 as usize..name_end.0 as usize];

[18.508361]

[21.36030]

        let name = &self.rec.contents[name_start.0.as_usize()..name_end.0.as_usize()];

Replacement in libpijul/src/record.rs at line 727 [18.488880]

B:BD[18.510318] → [18.510318:510384]

                self.rec.contents.truncate(name_start.0 as usize)

[18.510318]

[18.510384]

                self.rec.contents.truncate(name_start.0.as_usize())

Replacement in libpijul/src/record.rs at line 730 [18.488880]

B:BD[18.510415] → [18.510415:510477]

            self.rec.contents.truncate(name_start.0 as usize)

[18.510415]

[18.510477]

            self.rec.contents.truncate(name_start.0.as_usize())

Replacement in libpijul/src/record.rs at line 775 [18.488880]

B:BD[21.36364] → [21.36364:36438]

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

[21.36364]

[21.36438]

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

Replacement in libpijul/src/record.rs at line 780 [18.488880]

B:BD[18.511818] → [18.511818:511930]

        if !parent.flag.contains(EdgeFlags::PSEUDO) {
            if parent.flag.contains(EdgeFlags::DELETED) {

[18.511818]

[18.511930]

        if !parent.flag().contains(EdgeFlags::PSEUDO) {
            if parent.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/record.rs at line 783 [18.488880]

B:BD[18.511977] → [18.511977:512040]

                    previous: parent.flag - EdgeFlags::PARENT,

[18.511977]

[18.512040]

                    previous: parent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 785 [18.488880]

B:BD[18.512104] → [18.512104:512155]

                    from: parent.dest.to_option(),

[18.512104]

[18.512155]

                    from: parent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 787 [18.488880]

B:BD[18.512219] → [18.512219:512282]

                    introduced_by: Some(parent.introduced_by),

[18.512219]

[18.512282]

                    introduced_by: Some(parent.introduced_by()),

Replacement in libpijul/src/record.rs at line 791 [18.488880]

B:BD[18.512379] → [18.512379:512449]

                    .entry((parent.dest, current_pos.inode_vertex()))

[18.512379]

[69.93]

                    .entry((parent.dest(), current_pos.inode_vertex()))

Replacement in libpijul/src/record.rs at line 796 [18.488880]

B:BD[18.512573] → [18.512573:512643]

                    .entry((parent.dest, current_pos.inode_vertex()))

[18.512573]

[69.141]

                    .entry((parent.dest(), current_pos.inode_vertex()))

Replacement in libpijul/src/record.rs at line 798 [18.488880]
∅:D[69.188] → [18.512687:512738]
B:BD[18.512687] → [18.512687:512738]
```
                v.push(Some(parent.introduced_by))
```
[69.188]
[18.512738]
```
                v.push(Some(parent.introduced_by()))
```

Replacement in libpijul/src/record.rs at line 802 [18.488880]

B:BD[18.512793] → [22.29428:29505]

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

[18.512793]

[21.36549]

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

Replacement in libpijul/src/record.rs at line 805 [18.488880]

B:BD[21.36592] → [21.36592:36671]

                |p| txn.get_external(p).unwrap(),
                parent_dest,

[21.36592]

[21.36671]

                |p| txn.get_external(&p).unwrap().map(From::from),
                *parent_dest,

Replacement in libpijul/src/record.rs at line 821 [18.488880]
B:BD[27.34881] → [27.34881:34906]
```
            parent_dest,
```
[27.34881]
[27.34906]
```
            *parent_dest,
```
Replacement in libpijul/src/record.rs at line 827 [18.488880]
B:BD[21.36856] → [21.36856:36878]
```
                .flag
```
[21.36856]
[21.36878]
```
                .flag()
```

Replacement in libpijul/src/record.rs at line 829 [18.488880]

B:BD[21.36943] → [21.36943:37007]

                || grandparent.flag.contains(EdgeFlags::PSEUDO)

[21.36943]

[21.37007]

                || grandparent.flag().contains(EdgeFlags::PSEUDO)

Replacement in libpijul/src/record.rs at line 834 [18.488880]

B:BD[18.513816] → [22.29506:29597]

            let grandparent_dest = txn.find_block_end(channel, grandparent.dest).unwrap();

[18.513816]

[18.513908]

            let grandparent_dest = txn.find_block_end(channel, grandparent.dest()).unwrap();

Replacement in libpijul/src/record.rs at line 841 [18.488880]

B:BD[18.514150] → [18.514150:514232]

            let grandparent_changed = parent_pos != grandparent.dest.to_option();

[18.514150]

[18.514232]

            let grandparent_changed = parent_pos != grandparent.dest().to_option();

Replacement in libpijul/src/record.rs at line 844 [18.488880]

B:BD[18.514307] → [18.514307:514370]

            if grandparent.flag.contains(EdgeFlags::DELETED) {

[18.514307]

[18.514370]

            if grandparent.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/record.rs at line 848 [18.488880]

B:BD[18.514525] → [18.514525:514597]

                        previous: grandparent.flag - EdgeFlags::PARENT,

[18.514525]

[18.514597]

                        previous: grandparent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 850 [18.488880]

B:BD[18.514665] → [18.514665:514725]

                        from: grandparent.dest.to_option(),

[18.514665]

[18.514725]

                        from: grandparent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 852 [18.488880]

B:BD[18.514778] → [18.514778:514850]

                        introduced_by: Some(grandparent.introduced_by),

[18.514778]

[18.514850]

                        introduced_by: Some(grandparent.introduced_by()),

Replacement in libpijul/src/record.rs at line 854 [18.488880]

B:BD[18.514874] → [18.514874:514967]

                    if !parent_was_resurrected && !parent.flag.contains(EdgeFlags::PSEUDO) {

[18.514874]

[18.514967]

                    if !parent_was_resurrected && !parent.flag().contains(EdgeFlags::PSEUDO) {

Replacement in libpijul/src/record.rs at line 856 [18.488880]

B:BD[18.515018] → [18.515018:515089]

                            previous: parent.flag - EdgeFlags::PARENT,

[18.515018]

[18.515089]

                            previous: parent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 858 [18.488880]

B:BD[18.515161] → [18.515161:515220]

                            from: parent.dest.to_option(),

[18.515161]

[18.515220]

                            from: parent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 860 [18.488880]

B:BD[18.515292] → [18.515292:515363]

                            introduced_by: Some(parent.introduced_by),

[18.515292]

[18.515363]

                            introduced_by: Some(parent.introduced_by()),

Replacement in libpijul/src/record.rs at line 868 [18.488880]

B:BD[18.515617] → [18.515617:515681]

                        .entry((grandparent.dest, parent_dest))

[18.515617]

[69.189]

                        .entry((grandparent.dest(), parent_dest))

Replacement in libpijul/src/record.rs at line 870 [18.488880]

∅:D[69.240] → [18.515729:515789]

B:BD[18.515729] → [18.515729:515789]

                    v.push(Some(grandparent.introduced_by))

[69.240]

[18.515789]

                    v.push(Some(grandparent.introduced_by()))

Replacement in libpijul/src/record.rs at line 874 [18.488880]

B:BD[18.515910] → [18.515910:515973]

                    previous: parent.flag - EdgeFlags::PARENT,

[18.515910]

[18.515973]

                    previous: parent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 876 [18.488880]

B:BD[18.516058] → [18.516058:516114]

                    from: grandparent.dest.to_option(),

[18.516058]

[18.516114]

                    from: grandparent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 878 [18.488880]

B:BD[18.516163] → [18.516163:516231]

                    introduced_by: Some(grandparent.introduced_by),

[18.516163]

[18.516231]

                    introduced_by: Some(grandparent.introduced_by()),

Replacement in libpijul/src/record.rs at line 881 [18.488880]

B:BD[18.516334] → [18.516334:516423]

                if !parent_was_resurrected && !parent.flag.contains(EdgeFlags::PSEUDO) {

[18.516334]

[18.516423]

                if !parent_was_resurrected && !parent.flag().contains(EdgeFlags::PSEUDO) {

Replacement in libpijul/src/record.rs at line 883 [18.488880]

B:BD[18.516470] → [18.516470:516537]

                        previous: parent.flag - EdgeFlags::PARENT,

[18.516470]

[18.516537]

                        previous: parent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 885 [18.488880]

B:BD[18.516605] → [18.516605:516660]

                        from: parent.dest.to_option(),

[18.516605]

[18.516660]

                        from: parent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 887 [18.488880]

B:BD[18.516728] → [18.516728:516795]

                        introduced_by: Some(parent.introduced_by),

[18.516728]

[18.516795]

                        introduced_by: Some(parent.introduced_by()),

Replacement in libpijul/src/record.rs at line 892 [18.488880]

B:BD[18.516887] → [18.516887:516947]

                    .entry((grandparent.dest, parent_dest))

[18.516887]

[69.241]

                    .entry((grandparent.dest(), *parent_dest))

Replacement in libpijul/src/record.rs at line 894 [18.488880]
∅:D[69.288] → [18.516991:517048]
B:BD[18.516991] → [18.516991:517048]
```
                v.push(Some(grandparent.introduced_by));
```
[69.288]
[18.517048]
```
                v.push(Some(grandparent.introduced_by()));
```

Replacement in libpijul/src/record.rs at line 952 [18.488880]

B:BD[18.518868] → [21.37365:37435]

            if let Some(path) = tree_path(txn, vertex.start_pos())? {

[18.518868]

[18.518936]

            if let Some(path) = tree_path(txn, &vertex.start_pos())? {

Replacement in libpijul/src/record.rs at line 968 [18.488880]

B:BD[37.3605] → [21.37505:37589]

                if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None)? {

[37.3605]

[37.3688]

                if let Some(inode) = txn.get_revinodes(&vertex.start_pos(), None)? {

Replacement in libpijul/src/record.rs at line 974 [18.488880]

B:BD[37.3893] → [37.3893:3965]

                        .insert(inode, vertex.start_pos().to_option());

[37.3893]

[37.3965]

                        .insert(*inode, vertex.start_pos().to_option());

Replacement in libpijul/src/record.rs at line 977 [18.488880]

B:BD[37.4030] → [37.4030:4119]

                        .insert(self.rec.actions.len(), InodeUpdate::Deleted { inode });

[37.4030]

[18.520235]

                        .insert(self.rec.actions.len(), InodeUpdate::Deleted { inode: *inode });

Replacement in libpijul/src/record.rs at line 993 [18.488880]

B:BD[22.29629] → [22.29629:29681]

                    .find_block(channel, edge.dest)

[22.29629]

[22.29681]

                    .find_block(channel, edge.dest())

Replacement in libpijul/src/record.rs at line 996 [18.488880]

B:BD[18.520791] → [18.520791:520860]

                    assert!(!edge.flag.contains(EdgeFlags::FOLDER));

[18.520791]

[18.520860]

                    assert!(!edge.flag().contains(EdgeFlags::FOLDER));

Replacement in libpijul/src/record.rs at line 998 [18.488880]

B:BD[18.520886] → [18.520886:520952]

                } else if edge.flag.contains(EdgeFlags::FOLDER) {

[18.520886]

[18.520952]

                } else if edge.flag().contains(EdgeFlags::FOLDER) {

Replacement in libpijul/src/record.rs at line 1004 [18.488880]

B:BD[18.521124] → [18.521124:521217]

                if visited.insert(edge.dest) {
                    stack.push((dest, inode))

[18.521124]

[18.521217]

                if visited.insert(edge.dest()) {
                    stack.push((*dest, inode))

Replacement in libpijul/src/record.rs at line 1030 [18.488880]

B:BD[21.38019] → [21.38019:38077]

            if !parent.flag.contains(EdgeFlags::PARENT) {

[21.38019]

[21.38077]

            if !parent.flag().contains(EdgeFlags::PARENT) {

Replacement in libpijul/src/record.rs at line 1033 [18.488880]

∅:D[21.38117] → [27.35822:35884]

B:BD[27.35822] → [27.35822:35884]

B:BD[27.35884] → [22.29746:29827]

            assert!(parent.flag.contains(EdgeFlags::FOLDER));
            let parent_dest = txn.find_block_end(channel, parent.dest).unwrap();

[21.38117]

[27.35967]

            assert!(parent.flag().contains(EdgeFlags::FOLDER));
            let parent_dest = txn.find_block_end(channel, parent.dest()).unwrap();

Replacement in libpijul/src/record.rs at line 1038 [18.488880]
B:BD[18.521581] → [27.36035:36064]
```
                parent_dest,
```
[18.521581]
[18.521605]
```
                *parent_dest,
```

Replacement in libpijul/src/record.rs at line 1043 [18.488880]

B:BD[21.38266] → [21.38266:38399]

                if !grandparent.flag.contains(EdgeFlags::PARENT)
                    || grandparent.flag.contains(EdgeFlags::PSEUDO)

[21.38266]

[21.38399]

                if !grandparent.flag().contains(EdgeFlags::PARENT)
                    || grandparent.flag().contains(EdgeFlags::PSEUDO)

Replacement in libpijul/src/record.rs at line 1048 [18.488880]

∅:D[21.38465] → [18.522385:522527]

B:BD[18.522385] → [18.522385:522527]

                assert!(grandparent.flag.contains(EdgeFlags::PARENT));
                assert!(grandparent.flag.contains(EdgeFlags::FOLDER));

[21.38465]

[18.522527]

                assert!(grandparent.flag().contains(EdgeFlags::PARENT));
                assert!(grandparent.flag().contains(EdgeFlags::FOLDER));

Replacement in libpijul/src/record.rs at line 1051 [18.488880]

B:BD[18.522564] → [18.522564:522632]

                    previous: grandparent.flag - EdgeFlags::PARENT,

[18.522564]

[18.522632]

                    previous: grandparent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 1053 [18.488880]

B:BD[18.522717] → [18.522717:522773]

                    from: grandparent.dest.to_option(),

[18.522717]

[18.522773]

                    from: grandparent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 1055 [18.488880]

B:BD[18.522822] → [18.522822:522890]

                    introduced_by: Some(grandparent.introduced_by),

[18.522822]

[18.522890]

                    introduced_by: Some(grandparent.introduced_by()),

Replacement in libpijul/src/record.rs at line 1058 [18.488880]

B:BD[18.522924] → [18.522924:522982]

            if !parent.flag.contains(EdgeFlags::PSEUDO) {

[18.522924]

[18.522982]

            if !parent.flag().contains(EdgeFlags::PSEUDO) {

Replacement in libpijul/src/record.rs at line 1060 [18.488880]

B:BD[18.523019] → [18.523019:523082]

                    previous: parent.flag - EdgeFlags::PARENT,

[18.523019]

[18.523082]

                    previous: parent.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/record.rs at line 1062 [18.488880]

B:BD[18.523167] → [18.523167:523218]

                    from: parent.dest.to_option(),

[18.523167]

[18.523218]

                    from: parent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 1064 [18.488880]

B:BD[18.523262] → [18.523262:523325]

                    introduced_by: Some(parent.introduced_by),

[18.523262]

[18.523325]

                    introduced_by: Some(parent.introduced_by()),

Replacement in libpijul/src/record.rs at line 1108 [18.488880]

B:BD[21.38660] → [21.38660:38725]

                    if parent.flag.contains(EdgeFlags::PSEUDO) {

[21.38660]

[21.38725]

                    if parent.flag().contains(EdgeFlags::PSEUDO) {

Replacement in libpijul/src/record.rs at line 1111 [18.488880]

∅:D[21.38781] → [18.524658:524799]

B:BD[18.524658] → [18.524658:524799]

                    assert!(parent.flag.contains(EdgeFlags::PARENT));
                    assert!(!parent.flag.contains(EdgeFlags::FOLDER));

[21.38781]

[18.524799]

                    assert!(parent.flag().contains(EdgeFlags::PARENT));
                    assert!(!parent.flag().contains(EdgeFlags::FOLDER));

Replacement in libpijul/src/record.rs at line 1114 [18.488880]

B:BD[18.524842] → [18.524842:524909]

B:BD[18.524909] → [22.29828:29914]

∅:D[22.29914] → [18.524978:525033]

B:BD[18.524978] → [18.524978:525033]

                        previous: parent.flag - EdgeFlags::PARENT,
                        flag: (parent.flag - EdgeFlags::PARENT) | EdgeFlags::DELETED,
                        from: parent.dest.to_option(),

[18.524842]

[18.525033]

                        previous: parent.flag() - EdgeFlags::PARENT,
                        flag: (parent.flag() - EdgeFlags::PARENT) | EdgeFlags::DELETED,
                        from: parent.dest().to_option(),

Replacement in libpijul/src/record.rs at line 1118 [18.488880]

B:BD[18.525077] → [18.525077:525144]

                        introduced_by: Some(parent.introduced_by),

[18.525077]

[18.525144]

                        introduced_by: Some(parent.introduced_by()),

Insertion in libpijul/src/pristine/vertex.rs at line 1 [18.525242]
[18.525242]
[18.525298]
```
use super::L64;
```

Replacement in libpijul/src/pristine/vertex.rs at line 6 [18.525242]

B:BD[18.525440] → [18.525440:525532]

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]

[18.525440]

[18.525532]

#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]

Insertion in libpijul/src/pristine/vertex.rs at line 17 [18.525242]

[18.525822]

impl<T: std::fmt::Debug> std::fmt::Debug for Vertex<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(fmt, "V({:?}[{}:{}])", self.change, (self.start.0).0, (self.end.0).0)
    }
}

Replacement in libpijul/src/pristine/vertex.rs at line 85 [18.525242]
B:BD[18.527553] → [18.527553:527589]
```
pub struct ChangePosition(pub u64);
```
[18.527553]
[18.527589]
```
pub struct ChangePosition(pub super::L64);
```

Replacement in libpijul/src/pristine/vertex.rs at line 88 [18.525242]

B:BD[18.527612] → [18.527612:527740]

    pub(crate) const ROOT: ChangePosition = ChangePosition(0);
    pub(crate) const BOTTOM: ChangePosition = ChangePosition(1);

[18.527612]

[18.527740]

    pub(crate) const ROOT: ChangePosition = ChangePosition(L64(0u64));
    pub(crate) const BOTTOM: ChangePosition = ChangePosition(L64(1u64.to_le()));

Replacement in libpijul/src/pristine/vertex.rs at line 95 [18.525242]
B:BD[18.527869] → [18.527869:527911]
```
        ChangePosition(self.0 + x as u64)
```
[18.527869]
[18.527911]
```
        ChangePosition(self.0 + x)
```

Replacement in libpijul/src/pristine/vertex.rs at line 102 [18.525242]

B:BD[18.528055] → [18.528055:528087]

        (self.0 - x.0) as usize

[18.528055]

[18.528087]

        let a: u64 = self.0.into();
        let b: u64 = x.0.into();
        (a - b) as usize
    }
}
impl ChangePosition {
    pub(crate) fn us(&self) -> usize {
        u64::from_le((self.0).0) as usize
    }
}
impl From<ChangePosition> for u64 {
    fn from(f: ChangePosition) -> u64 {
        u64::from_le((f.0).0)

Insertion in libpijul/src/pristine/vertex.rs at line 119 [18.525242]
[18.528095]
[18.528150]
Deletion in libpijul/src/pristine/vertex.rs at line 129 [18.525242]
B:BD[18.528415] → [18.528415:528457]
```
use byteorder::{ByteOrder, LittleEndian};
```
Replacement in libpijul/src/pristine/vertex.rs at line 134 [18.525242]
B:BD[18.528619] → [18.528619:528676]
```
        LittleEndian::write_u64(&mut bytes, self.pos.0);
```
[18.528619]
[18.528676]
```
        self.pos.0.to_slice_le(&mut bytes);
```

Replacement in libpijul/src/pristine/vertex.rs at line 158 [18.525242]

B:BD[70.379] → [70.379:430]

            .map(|_| LittleEndian::read_u64(&dec))

[70.379]

[70.430]

            .map(|_| L64::from_slice_le(&dec))

Replacement in libpijul/src/pristine/vertex.rs at line 199 [18.525242]
B:BD[18.530709] → [18.530709:530741]
```
        pos: ChangePosition(0),
```
[18.530709]
[18.530741]
```
        pos: ChangePosition(L64(0u64)),
```
Replacement in libpijul/src/pristine/vertex.rs at line 204 [18.525242]
B:BD[18.530861] → [18.530861:530893]
```
        pos: ChangePosition(0),
```
[18.530861]
[18.530893]
```
        pos: ChangePosition(L64(0u64)),
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 2 [18.531056]
B:BD[18.531126] → [18.531126:531151]
B:BD[18.531151] → [22.29915:29995]
∅:D[22.29995] → [18.531171:531262]
B:BD[18.531171] → [18.531171:531262]
```
use crate::small_string;
use ::sanakirja::{Alignment, Commit, Db, Representable, Transaction, UnsafeDb};
use byteorder::{ByteOrder, LittleEndian};
use rand::rngs::ThreadRng;
use rand::thread_rng;
```
[18.531126]
[18.531262]
```
use ::sanakirja::*;
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 11 [18.531056]
B:BD[18.531446] → [71.22:82]
```
    pub env: Arc<::sanakirja::Env<::sanakirja::Exclusive>>,
```
[18.531446]
[18.531482]
```
    pub env: Arc<::sanakirja::Env>,
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 13 [18.531056]

[18.531484]


type P<K, V> = btree::page::Page<K, V>;
type Db<K, V> = btree::Db<K, V>;
type UP<K, V> = btree::page_unsized::Page<K, V>;
type UDb<K, V> = btree::Db_<K, V, UP<K, V>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 63 [18.531056]

B:BD[23.13187] → [22.29996:30053]

        let env = ::sanakirja::Env::try_new(name, size);

[23.13187]

[71.138]

        let env = ::sanakirja::Env::new(name, size, 2);

Replacement in libpijul/src/pristine/sanakirja.rs at line 81 [18.531056]

B:BD[18.532113] → [22.30182:30252]

            env: Arc::new(::sanakirja::Env::new_nolock(name, size)?),

[18.532113]

[18.532181]

            env: Arc::new(::sanakirja::Env::new_nolock(name, size, 2)?),

Replacement in libpijul/src/pristine/sanakirja.rs at line 89 [18.531056]

B:BD[18.532397] → [22.30253:30315]

            env: Arc::new(::sanakirja::Env::new_anon(size)?),

[18.532397]

[18.532457]

            env: Arc::new(::sanakirja::Env::new_anon(size, 2)?),

Replacement in libpijul/src/pristine/sanakirja.rs at line 115 [18.531056]

B:BD[18.532869] → [27.36508:36706]

        fn begin(
            txn: ::sanakirja::Txn<
                ::sanakirja::Exclusive,
                Arc<::sanakirja::Env<::sanakirja::Exclusive>>,
            >,
        ) -> Option<Txn> {

[18.532869]

[18.532949]

        fn begin(txn: ::sanakirja::Txn<Arc<::sanakirja::Env>>) -> Option<Txn> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 117 [18.531056]

B:BD[18.532972] → [18.532972:533810]

                channels: txn.root(Root::Channels as usize)?,
                external: txn.root(Root::External as usize)?,
                internal: txn.root(Root::Internal as usize)?,
                inodes: txn.root(Root::Inodes as usize)?,
                revinodes: txn.root(Root::RevInodes as usize)?,
                tree: txn.root(Root::Tree as usize)?,
                revtree: txn.root(Root::RevTree as usize)?,
                revdep: txn.root(Root::RevDep as usize)?,
                touched_files: txn.root(Root::TouchedFiles as usize)?,
                rev_touched_files: txn.root(Root::RevTouchedFiles as usize)?,
                partials: txn.root(Root::Partials as usize)?,
                dep: txn.root(Root::Dep as usize)?,
                remotes: txn.root(Root::Remotes as usize)?,
                rng: thread_rng(),

[18.532972]

[18.533810]

                channels: txn.root_db(Root::Channels as usize)?,
                external: txn.root_db(Root::External as usize)?,
                internal: txn.root_db(Root::Internal as usize)?,
                inodes: txn.root_db(Root::Inodes as usize)?,
                revinodes: txn.root_db(Root::RevInodes as usize)?,
                tree: txn.root_db(Root::Tree as usize)?,
                revtree: txn.root_db(Root::RevTree as usize)?,
                revdep: txn.root_db(Root::RevDep as usize)?,
                touched_files: txn.root_db(Root::TouchedFiles as usize)?,
                rev_touched_files: txn.root_db(Root::RevTouchedFiles as usize)?,
                partials: txn.root_db(Root::Partials as usize)?,
                dep: txn.root_db(Root::Dep as usize)?,
                remotes: txn.root_db(Root::Remotes as usize)?,

Replacement in libpijul/src/pristine/sanakirja.rs at line 146 [18.531056]

B:BD[18.534298] → [18.534298:534407]

                .root(Root::Channels as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534298]

[18.534407]

                .root_db(Root::Channels as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 149 [18.531056]

B:BD[18.534433] → [18.534433:534542]

                .root(Root::External as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534433]

[18.534542]

                .root_db(Root::External as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 152 [18.531056]

B:BD[18.534568] → [18.534568:534677]

                .root(Root::Internal as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534568]

[18.534677]

                .root_db(Root::Internal as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 155 [18.531056]

B:BD[18.534701] → [18.534701:534808]

                .root(Root::Inodes as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534701]

[18.534808]

                .root_db(Root::Inodes as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 158 [18.531056]

B:BD[18.534835] → [18.534835:534945]

                .root(Root::RevInodes as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534835]

[18.534945]

                .root_db(Root::RevInodes as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 161 [18.531056]

B:BD[18.534967] → [18.534967:535072]

                .root(Root::Tree as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.534967]

[18.535072]

                .root_db(Root::Tree as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 164 [18.531056]

B:BD[18.535097] → [18.535097:535205]

                .root(Root::RevTree as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535097]

[18.535205]

                .root_db(Root::RevTree as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 167 [18.531056]

B:BD[18.535229] → [18.535229:535336]

                .root(Root::RevDep as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535229]

[18.535336]

                .root_db(Root::RevDep as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 170 [18.531056]

B:BD[18.535357] → [18.535357:535461]

                .root(Root::Dep as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535357]

[18.535461]

                .root_db(Root::Dep as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 173 [18.531056]

B:BD[18.535492] → [18.535492:535605]

                .root(Root::TouchedFiles as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535492]

[18.535605]

                .root_db(Root::TouchedFiles as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 176 [18.531056]

B:BD[18.535640] → [18.535640:535756]

                .root(Root::RevTouchedFiles as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535640]

[18.535756]

                .root_db(Root::RevTouchedFiles as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 179 [18.531056]

B:BD[18.535782] → [18.535782:535891]

                .root(Root::Partials as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),

[18.535782]

[18.535891]

                .root_db(Root::Partials as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 182 [18.531056]

B:BD[18.535916] → [18.535916:536055]

                .root(Root::Remotes as usize)
                .unwrap_or_else(|| txn.create_db().unwrap()),
            rng: thread_rng(),

[18.535916]

[18.536055]

                .root_db(Root::Remotes as usize)
                .unwrap_or_else(|| btree::create_db_(&mut txn).unwrap()),

Deletion in libpijul/src/pristine/sanakirja.rs at line 191 [18.531056]

B:BD[18.536204] → [18.536204:536442]

type Graph = ::sanakirja::Db<Vertex<ChangeId>, Edge>;
type ChangeSet = ::sanakirja::Db<ChangeId, ApplyTimestamp>;
type RevChangeSet = ::sanakirja::Db<ApplyTimestamp, (ChangeId, Merkle)>;
type ChannelStates = ::sanakirja::Db<Merkle, u64>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 192 [18.531056]

B:BD[18.536443] → [27.36707:36938]

pub type Txn = GenericTxn<
    ::sanakirja::Txn<::sanakirja::Exclusive, Arc<::sanakirja::Env<::sanakirja::Exclusive>>>,
>;
pub type MutTxn<T> =
    GenericTxn<::sanakirja::MutTxn<Arc<::sanakirja::Env<::sanakirja::Exclusive>>, T>>;

[18.536443]

[18.536591]

pub type Txn = GenericTxn<::sanakirja::Txn<Arc<::sanakirja::Env>>>;
pub type MutTxn<T> = GenericTxn<::sanakirja::MutTxn<Arc<::sanakirja::Env>, T>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 203 [18.531056]
B:BD[18.536988] → [18.536988:537041]
```
pub struct GenericTxn<T: ::sanakirja::Transaction> {
```
[18.536988]
[22.30333]
```
pub struct GenericTxn<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 207 [18.531056]
B:BD[22.30387] → [22.30387:30425]
```
    pub internal: Db<Hash, ChangeId>,
```
[22.30387]
[22.30425]
```
    pub internal: Db<SerializedHash, ChangeId>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 209 [18.531056]
B:BD[22.30444] → [22.30444:30482]
```
    pub external: Db<ChangeId, Hash>,
```
[22.30444]
[18.537121]
```
    pub external: Db<ChangeId, SerializedHash>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 213 [18.531056]

B:BD[18.537211] → [18.537211:537284]

    tree: Db<UnsafePathId, Inode>,
    revtree: Db<Inode, UnsafePathId>,

[18.537211]

[18.537284]

    tree: UDb<PathId, Inode>,
    revtree: UDb<Inode, PathId>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 222 [18.531056]

B:BD[18.537466] → [18.537466:537793]

    partials: Db<UnsafeSmallStr, Position<ChangeId>>,
    channels: Db<UnsafeSmallStr, (Graph, ChangeSet, RevChangeSet, ChannelStates, u64, u64)>,
    remotes: Db<UnsafeSmallStr, (Db<u64, (Hash, Merkle)>, Db<Hash, u64>, Db<Merkle, u64>)>,
    rng: ThreadRng,
    open_channels: RefCell<HashMap<SmallString, ChannelRef<Self>>>,

[18.537466]

[18.537793]

    partials: UDb<SmallStr, Position<ChangeId>>,
    channels: UDb<SmallStr, T6>,
    remotes: UDb<SmallStr, T3>,
    pub(crate) open_channels: RefCell<HashMap<SmallString, ChannelRef<Self>>>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 232 [18.531056]

B:BD[18.538066] → [18.538066:538133]

unsafe impl<T: ::sanakirja::Transaction> Send for GenericTxn<T> {}

[18.538066]

[18.538133]

unsafe impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> Send for GenericTxn<T> {}

Deletion in libpijul/src/pristine/sanakirja.rs at line 234 [18.531056]

B:BD[18.538134] → [18.538134:538243]

#[derive(Debug)]
pub struct DatabaseReport {
    pub refs: usize,
    pub stats: ::sanakirja::Statistics,
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 235 [18.531056]

B:BD[18.538254] → [18.538254:539439]

B:BD[18.539439] → [21.39467:39585]

∅:D[21.39585] → [18.539516:539904]

B:BD[18.539516] → [18.539516:539904]

    pub fn check_database(&self) -> DatabaseReport {
        let mut refs = HashMap::new();
        self.txn.references(&mut refs, self.internal);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.external);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.inodes);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.revinodes);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.tree);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.revtree);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.revdep);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.dep);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.touched_files);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.rev_touched_files);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.partials);
        info!("refs = {:?}", refs);
        self.txn.references(&mut refs, self.channels);
        info!("refs = {:?}", refs);
        for x in self.txn.iter(&self.channels, None).unwrap() {
            let (a, (g, c, r, s, _, _)) = x.unwrap();
            info!("channel = {:?}", a);
            self.txn.references(&mut refs, g);
            info!("refs = {:?}", refs);
            self.txn.references(&mut refs, c);
            info!("refs = {:?}", refs);
            self.txn.references(&mut refs, r);
            info!("refs = {:?}", refs);
            self.txn.references(&mut refs, s);
            info!("refs = {:?}", refs);

[18.538254]

[18.539904]

    pub fn check_database(&self) {
        let mut refs = std::collections::BTreeMap::new();
        debug!("check: internal 0x{:x}", self.internal.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.internal, &mut refs).unwrap();
        debug!("check: external 0x{:x}", self.external.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.external, &mut refs).unwrap();
        debug!("check: inodes 0x{:x}", self.inodes.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.inodes, &mut refs).unwrap();
        debug!("check: revinodes 0x{:x}", self.revinodes.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.revinodes, &mut refs).unwrap();
        debug!("check: tree 0x{:x}", self.tree.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.tree, &mut refs).unwrap();
        debug!("check: revtree 0x{:x}", self.revtree.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.revtree, &mut refs).unwrap();
        debug!("check: revdep 0x{:x}", self.revdep.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.revdep, &mut refs).unwrap();
        debug!("check: dep 0x{:x}", self.dep.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.dep, &mut refs).unwrap();
        debug!("check: touched_files 0x{:x}", self.touched_files.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.touched_files, &mut refs).unwrap();
        debug!("check: rev_touched_files 0x{:x}", self.rev_touched_files.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.rev_touched_files, &mut refs).unwrap();
        debug!("check: partials 0x{:x}", self.partials.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.partials, &mut refs).unwrap();
        debug!("check: channels 0x{:x}", self.channels.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.channels, &mut refs).unwrap();
        for x in btree::iter(&self.txn, &self.channels, None).unwrap() {
            let (name, tup) = x.unwrap();
            debug!("check: channel name: {:?}", name.as_str());
            let graph: Db<Vertex<ChangeId>, SerializedEdge> = Db::from_page(tup.0[0].into());
            let changes: Db<ChangeId, L64> = Db::from_page(tup.0[1].into());
            let revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(tup.0[2].into());
            let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.0[3].into());
            debug!("check: graph 0x{:x}", graph.db);
            ::sanakirja::debug::add_refs(&self.txn, &graph, &mut refs).unwrap();
            debug!("check: changes 0x{:x}", changes.db);
            ::sanakirja::debug::add_refs(&self.txn, &changes, &mut refs).unwrap();
            debug!("check: revchanges 0x{:x}", revchanges.db);
            ::sanakirja::debug::add_refs(&self.txn, &revchanges, &mut refs).unwrap();
            debug!("check: states 0x{:x}", states.db);
            ::sanakirja::debug::add_refs(&self.txn, &states, &mut refs).unwrap();

Replacement in libpijul/src/pristine/sanakirja.rs at line 277 [18.531056]

B:BD[18.539914] → [18.539914:540004]

B:BD[18.540004] → [21.39586:39694]

∅:D[21.39694] → [18.540071:540597]

B:BD[18.540071] → [18.540071:540597]

B:BD[18.540597] → [21.39695:39813]

∅:D[21.39813] → [18.540674:541955]

B:BD[18.540674] → [18.540674:541955]

        self.txn.references(&mut refs, self.remotes);
        info!("refs = {:?}", refs);
        for x in self.txn.iter(&self.remotes, None).unwrap() {
            let (a, (u, v, w)) = x.unwrap();
            info!("remote = {:?}", a);
            self.txn.references(&mut refs, u);
            info!("refs = {:?}", refs);
            self.txn.references(&mut refs, v);
            info!("refs = {:?}", refs);
            self.txn.references(&mut refs, w);
            info!("refs = {:?}", refs);
        }
        let stats = self.txn.statistics();
        let report = DatabaseReport {
            refs: refs.len(),
            stats: stats.clone(),
        };
        let mut channel_roots: Vec<UnsafeDb> = Vec::new();
        for x in self.txn.iter(&self.channels, None).unwrap() {
            let (a, (g, c, r, s, _, _)) = x.unwrap();
            info!("channel: {:?}", a);
            unsafe {
                channel_roots.push(std::mem::transmute(g));
                channel_roots.push(std::mem::transmute(c));
                channel_roots.push(std::mem::transmute(r));
                channel_roots.push(std::mem::transmute(s));
            }
        }
        ::sanakirja::debug_(&self.txn, &channel_roots[..], "debug_sanakirja", true);
        self.txn.check_references(&mut refs);
        info!("stats = {:?}", stats);
        let occupied_pages =
            stats.total_pages - stats.free_pages.len() - stats.bookkeeping_pages.len();
        for i in 1..(stats.total_pages as u64) {
            let p = i * 4096;
            if !refs.contains_key(&p)
                && !stats.free_pages.contains(&p)
                && !stats.bookkeeping_pages.contains(&p)
            {
                panic!("does not contain {:?} ({:?})", i, p);
            }
        }
        // check that there is no intersection.
        for (r, _) in refs.iter() {
            if stats.free_pages.contains(r) {
                panic!("referenced page is free: {:?}", r);
            }
            if stats.bookkeeping_pages.contains(r) {
                panic!("referenced page is a bookkeeping page: {:?}", r);
            }

[18.539914]

[18.541955]

        debug!("check: remotes 0x{:x}", self.remotes.db);
        ::sanakirja::debug::add_refs(&self.txn, &self.remotes, &mut refs).unwrap();
        for x in btree::iter(&self.txn, &self.remotes, None).unwrap() {
            let (name, tup) = x.unwrap();
            debug!("check: remote name: {:?}", name.as_str());
            let remote: UDb<SmallStr, T3> = UDb::from_page(tup.0[0].into());
            let rev: UDb<SerializedHash, L64> = UDb::from_page(tup.0[1].into());
            let states: UDb<SerializedMerkle, L64> = UDb::from_page(tup.0[2].into());
            debug!("check: remote 0x{:x}", remote.db);
            ::sanakirja::debug::add_refs(&self.txn, &remote, &mut refs).unwrap();
            debug!("check: rev 0x{:x}", rev.db);
            ::sanakirja::debug::add_refs(&self.txn, &rev, &mut refs).unwrap();
            debug!("check: states 0x{:x}", states.db);
            ::sanakirja::debug::add_refs(&self.txn, &states, &mut refs).unwrap();

Replacement in libpijul/src/pristine/sanakirja.rs at line 292 [18.531056]

B:BD[18.541965] → [18.541965:542213]

        for p in stats.free_pages.iter() {
            if stats.bookkeeping_pages.contains(p) {
                panic!("bookkeeping inter free: {:?}", p);
            }
        }
        assert_eq!(1 + refs.len(), occupied_pages);
        report

[18.541965]

[18.542213]

        ::sanakirja::debug::add_free_refs(&self.txn, &mut refs).unwrap();
        ::sanakirja::debug::check_free(&self.txn, &refs);

Replacement in libpijul/src/pristine/sanakirja.rs at line 297 [18.531056]

B:BD[18.542222] → [21.39814:39878]

∅:D[23.13699] → [18.542300:542345]

∅:D[21.39878] → [18.542300:542345]

B:BD[18.542300] → [18.542300:542345]

impl<T: ::sanakirja::Transaction> GraphTxnT for GenericTxn<T> {
    type Graph = Db<Vertex<ChangeId>, Edge>;

[18.542222]

[21.39879]

impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> GraphTxnT for GenericTxn<T> {
    type Graph = Db<Vertex<ChangeId>, SerializedEdge>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 301 [18.531056]

B:BD[18.542403] → [21.39919:40074]

    sanakirja_get!(graph, Vertex<ChangeId>, Edge, GraphError);
    fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>> {

[21.39918]

[18.542532]

    sanakirja_get!(graph, Vertex<ChangeId>, SerializedEdge, GraphError);
    fn get_external(
        &self,
        p: &ChangeId,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>> {
        debug!("get_external {:?}", p);

Replacement in libpijul/src/pristine/sanakirja.rs at line 308 [18.531056]

B:BD[18.542557] → [21.40075:40196]

            Ok(Some(Hash::None))
        } else if let Ok(x) = self.txn.get(&self.external, p, None) {
            Ok(x)

[18.542557]

[18.542586]

            Ok(Some(&HASH_NONE))

Replacement in libpijul/src/pristine/sanakirja.rs at line 310 [18.531056]

B:BD[18.542603] → [21.40197:40254]

            Err(TxnErr(SanakirjaError::PristineCorrupt))

[18.542603]

[18.542653]

            match btree::get(&self.txn, &self.external, p, None) {
                Ok(Some((k, v))) if k == p => Ok(Some(v)),
                Ok(_) => Ok(None),
                Err(e) => {
                    error!("{:?}", e);
                    Err(TxnErr(SanakirjaError::PristineCorrupt))
                }
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 321 [18.531056]

B:BD[27.36940] → [21.40255:40347]

∅:D[21.40347] → [18.542746:542778]

B:BD[18.542746] → [18.542746:542778]

B:BD[18.542778] → [21.40348:40473]

    fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>> {
        if let Hash::None = p {
            Ok(Some(ChangeId::ROOT))
        } else if let Ok(x) = self.txn.get(&self.internal, p, None) {
            Ok(x)

[27.36940]

[22.30483]

    fn get_internal(&self, p: &SerializedHash) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>> {
        if p.t == HashAlgorithm::None as u8 {
            Ok(Some(&ChangeId::ROOT))

Replacement in libpijul/src/pristine/sanakirja.rs at line 325 [18.531056]

B:BD[22.30500] → [22.30500:30557]

            Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.30500]

[22.30557]

            match btree::get(&self.txn, &self.internal, &p, None) {
                Ok(Some((k, v))) if k == p => Ok(Some(v)),
                Ok(_) => Ok(None),
                Err(e) => {
                    error!("{:?}", e);
                    Err(TxnErr(SanakirjaError::PristineCorrupt))
                }
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 346 [18.531056]

B:BD[22.30830] → [22.30830:31257]

        let edge = Edge {
            flag: min_flag,
            dest,
            introduced_by: ChangeId::ROOT,
        };
        if let Ok((cursor, _)) = self.txn.set_cursors(g, Some((key, Some(edge)))) {
            Ok(Adj {
                cursor,
                key,
                min_flag,
                max_flag,
            })
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }

[22.30830]

[22.31257]

        let edge = SerializedEdge::new(min_flag, dest.change, dest.pos, ChangeId::ROOT);
        let mut cursor = btree::cursor::Cursor::new(&self.txn, g).map_err(TxnErr)?;
        cursor.set(&self.txn, &key, Some(&edge))?;
        Ok(Adj {
            cursor,
            key,
            min_flag,
            max_flag,
        })

Replacement in libpijul/src/pristine/sanakirja.rs at line 357 [18.531056]
B:BD[22.31264] → [22.31264:31296]
```
    fn next_adj(
        &self,
```
[22.31264]
[22.31296]
```
    fn next_adj<'a>(
        &'a self,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 361 [18.531056]

B:BD[22.31348] → [22.31348:31406]

    ) -> Option<Result<Edge, TxnErr<Self::GraphError>>> {

[22.31348]

[22.31406]

    ) -> Option<Result<&'a SerializedEdge, TxnErr<Self::GraphError>>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 369 [18.531056]

B:BD[22.31538] → [22.31538:31604]

    ) -> Result<Vertex<ChangeId>, BlockError<Self::GraphError>> {

[22.31538]

[22.31604]

    ) -> Result<&Vertex<ChangeId>, BlockError<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 377 [18.531056]

B:BD[22.31749] → [22.31749:31815]

    ) -> Result<Vertex<ChangeId>, BlockError<Self::GraphError>> {

[22.31749]

[22.31815]

    ) -> Result<&Vertex<ChangeId>, BlockError<Self::GraphError>> {

Deletion in libpijul/src/pristine/sanakirja.rs at line 382 [18.531056]

B:BD[22.31868] → [22.31868:32626]

unsafe fn next_graph<T: ::sanakirja::Transaction>(
    txn: &T,
    cursor: &mut ::sanakirja::Cursor,
) -> Result<Option<(Vertex<ChangeId>, Edge)>, BlockError<SanakirjaError>> {
    match ::sanakirja::next::<_, Vertex<ChangeId>, Edge>(txn, cursor) {
        Ok(x) => Ok(x),
        Err(::sanakirja::CRCError {}) => Err(BlockError::Txn(SanakirjaError::PristineCorrupt)),
    }
}
unsafe fn prev_graph<T: ::sanakirja::Transaction>(
    txn: &T,
    cursor: &mut ::sanakirja::Cursor,
) -> Result<Option<(Vertex<ChangeId>, Edge)>, BlockError<SanakirjaError>> {
    match ::sanakirja::prev::<_, Vertex<ChangeId>, Edge>(txn, cursor) {
        Ok(x) => Ok(x),
        Err(::sanakirja::CRCError {}) => Err(BlockError::Txn(SanakirjaError::PristineCorrupt)),
    }
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 383 [18.531056]

B:BD[22.32641] → [22.32641:32700]

pub fn next_adj<T: ::sanakirja::Transaction>(
    txn: &T,

[22.32641]

[22.32700]

pub fn next_adj<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(
    txn: &'a T,

Replacement in libpijul/src/pristine/sanakirja.rs at line 386 [18.531056]
B:BD[22.32717] → [22.32717:32769]
```
) -> Option<Result<Edge, TxnErr<SanakirjaError>>> {
```
[22.32717]
[22.32769]
```
) -> Option<Result<&'a SerializedEdge, TxnErr<SanakirjaError>>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 388 [18.531056]

B:BD[22.32780] → [22.32780:32903]

        let x: Result<Option<(Vertex<ChangeId>, Edge)>, _> =
            unsafe { ::sanakirja::next(txn, &mut a.cursor) };

[22.32780]

[22.32903]

        let x: Result<Option<(&Vertex<ChangeId>, &SerializedEdge)>, _> = a.cursor.next(txn);

Replacement in libpijul/src/pristine/sanakirja.rs at line 391 [18.531056]

B:BD[22.32955] → [22.32955:33145]

                debug!("adjacent iterator: {:?} {:?}", v, e);
                if v == a.key {
                    if e.flag >= a.min_flag {
                        if e.flag <= a.max_flag {

[22.32955]

[22.33145]

                if *v == a.key {
                    if e.flag() >= a.min_flag {
                        if e.flag() <= a.max_flag {

Replacement in libpijul/src/pristine/sanakirja.rs at line 399 [18.531056]
B:BD[22.33315] → [22.33315:33353]
```
                } else if v > a.key {
```
[22.33315]
[22.33353]
```
                } else if *v > a.key {
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 405 [18.531056]
B:BD[22.33502] → [22.33502:33553]
```
                debug!("adjacent iterator: over");
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 412 [18.531056]

B:BD[22.33630] → [22.33630:33744]

pub fn find_block<T: ::sanakirja::Transaction>(
    txn: &T,
    graph: &::sanakirja::Db<Vertex<ChangeId>, Edge>,

[22.33630]

[22.33744]

pub fn find_block<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(
    txn: &'a T,
    graph: &::sanakirja::btree::Db<Vertex<ChangeId>, SerializedEdge>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 416 [18.531056]
B:BD[22.33771] → [22.33771:33831]
```
) -> Result<Vertex<ChangeId>, BlockError<SanakirjaError>> {
```
[22.33771]
[22.33831]
```
) -> Result<&'a Vertex<ChangeId>, BlockError<SanakirjaError>> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 418 [18.531056]
B:BD[22.33859] → [22.33859:33892]
```
        return Ok(Vertex::ROOT);
```
[22.33859]
[22.33892]
```
        return Ok(&Vertex::ROOT);
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 424 [18.531056]

B:BD[22.33989] → [22.33989:34253]

    };
    debug!(target: "libpijul::find_block", "find_block {:?}", key);
    let mut cursor = if let Ok((cursor, _)) = txn.set_cursors(&graph, Some((key, None))) {
        cursor
    } else {
        return Err(BlockError::Txn(SanakirjaError::PristineCorrupt));

Replacement in libpijul/src/pristine/sanakirja.rs at line 425 [18.531056]

B:BD[22.34260] → [22.34260:34341]

    let mut k = if let Some((k, _)) = unsafe { next_graph(txn, &mut cursor)? } {

[22.34260]

[22.34341]

    let mut cursor =
        btree::cursor::Cursor::new(txn, &graph).map_err(|x| BlockError::Txn(x.into()))?;
    let mut k = if let Some((k, _)) = cursor.set(txn, &key, None).map_err(|x| BlockError::Txn(x.into()))? {
        k
    } else if let Some((k, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {

Replacement in libpijul/src/pristine/sanakirja.rs at line 434 [18.531056]

B:BD[22.34423] → [22.34423:34696]

    debug!("k = {:?}", k);
    // The only guarantee here is that k is either the first key
    // >= `key`, or the key just before that. We might need to
    // rewind by one step if key is strictly larger than the
    // result (i.e. if `p` is in the middle of the key).

[22.34423]

[22.34696]

    // The only guarantee here is that k is either the first key >=
    // `key`. We might need to rewind by one step if key is strictly
    // larger than the result (i.e. if `p` is in the middle of the
    // key).

Replacement in libpijul/src/pristine/sanakirja.rs at line 439 [18.531056]

B:BD[22.34773] → [22.34773:34923]

        debug!(target: "libpijul::find_block", "find_block while {:?}", k);
        if let Some((k_, _)) = unsafe { prev_graph(txn, &mut cursor)? } {

[22.34773]

[22.34923]

        if let Some((k_, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {

Deletion in libpijul/src/pristine/sanakirja.rs at line 446 [18.531056]
B:BD[22.35005] → [22.35005:35080]
```
        debug!(target: "libpijul::find_block", "find_block loop {:?}", k);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 453 [18.531056]

B:BD[22.35355] → [22.35355:35429]

        if let Some((k_, _)) = unsafe { next_graph(txn, &mut cursor)? } {

[22.35355]

[22.35429]

        if let Some((k_, _)) = cursor.next(txn).map_err(|x| BlockError::Txn(x.into()))? {

Deletion in libpijul/src/pristine/sanakirja.rs at line 459 [18.531056]
B:BD[22.35500] → [22.35500:35572]
```
    debug!(target: "libpijul::find_block", "find_block None, {:?}", k);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 463 [18.531056]

B:BD[22.35630] → [22.35630:35748]

pub fn find_block_end<T: ::sanakirja::Transaction>(
    txn: &T,
    graph: &::sanakirja::Db<Vertex<ChangeId>, Edge>,

[22.35630]

[22.35748]

pub fn find_block_end<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(
    txn: &'a T,
    graph: &::sanakirja::btree::Db<Vertex<ChangeId>, SerializedEdge>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 467 [18.531056]
B:BD[22.35775] → [22.35775:35835]
```
) -> Result<Vertex<ChangeId>, BlockError<SanakirjaError>> {
```
[22.35775]
[22.35835]
```
) -> Result<&'a Vertex<ChangeId>, BlockError<SanakirjaError>> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 469 [18.531056]
B:BD[22.35863] → [22.35863:35896]
```
        return Ok(Vertex::ROOT);
```
[22.35863]
[22.35896]
```
        return Ok(&Vertex::ROOT);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 476 [18.531056]

B:BD[22.36000] → [22.36000:36384]

    debug!(target: "libpijul::find_block_end", "find_block_end {:?}, p.change.0 = {:?}", key, p.change.0);
    let mut cursor = if let Ok((cursor, _)) = txn.set_cursors(&graph, Some((key, None))) {
        cursor
    } else {
        return Err(BlockError::Txn(SanakirjaError::PristineCorrupt));
    };
    let mut k = if let Some((k, _)) = unsafe { next_graph(txn, &mut cursor)? } {

[22.36000]

[22.36384]

    let mut cursor = ::sanakirja::btree::cursor::Cursor::new(txn, graph)
        .map_err(|x| BlockError::Txn(x.into()))?;
    let mut k = if let Some((k, _)) = cursor
        .set(txn, &key, None)
        .map_err(|x| BlockError::Txn(x.into()))?
    {
        k
    } else if let Some((k, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {

Deletion in libpijul/src/pristine/sanakirja.rs at line 488 [18.531056]

B:BD[22.36466] → [22.36466:36581]

    // The only guarantee here is that k is either the first key
    // before `key`, or the key just before that.

Deletion in libpijul/src/pristine/sanakirja.rs at line 489 [18.531056]

B:BD[22.36592] → [22.36592:36705]

        debug!(target: "libpijul::find_block_end", "find_block_end loop {:?} k.change.0 = {:?}", k, k.change.0);

Replacement in libpijul/src/pristine/sanakirja.rs at line 502 [18.531056]

B:BD[22.37183] → [22.37183:37257]

        if let Some((k_, _)) = unsafe { prev_graph(txn, &mut cursor)? } {

[22.37183]

[22.37257]

        if let Some((k_, _)) = cursor.prev(txn).map_err(|x| BlockError::Txn(x.into()))? {

Deletion in libpijul/src/pristine/sanakirja.rs at line 510 [18.531056]

B:BD[22.37414] → [22.37414:37525]

    debug!(target: "libpijul::find_block_end", "find_block_end k(0) = {:?} k.change.0 = {:?}", k, k.change.0);

Replacement in libpijul/src/pristine/sanakirja.rs at line 511 [18.531056]

B:BD[22.37600] → [22.37600:37674]

        if let Some((k_, _)) = unsafe { next_graph(txn, &mut cursor)? } {

[22.37600]

[22.37674]

        if let Some((k_, _)) = cursor.next(txn).map_err(|x| BlockError::Txn(x.into()))? {

Deletion in libpijul/src/pristine/sanakirja.rs at line 517 [18.531056]

B:BD[22.37729] → [22.37729:37841]

    debug!(target: "libpijul::find_block_end", "find_block_end k(1) = {:?}, k.change.0 = {:?}", k, k.change.0);

Deletion in libpijul/src/pristine/sanakirja.rs at line 520 [18.531056]
B:BD[22.37966] → [22.37966:37988]
```
        debug!("ok");
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 527 [18.531056]

B:BD[22.38085] → [22.38085:38122]

    pub cursor: ::sanakirja::Cursor,

[22.38085]

[22.38122]

    pub cursor: ::sanakirja::btree::cursor::Cursor<
        Vertex<ChangeId>,
        SerializedEdge,
        P<Vertex<ChangeId>, SerializedEdge>,
    >,

Replacement in libpijul/src/pristine/sanakirja.rs at line 537 [18.531056]

B:BD[22.38214] → [22.38214:38322]

impl<T: ::sanakirja::Transaction> GraphIter for GenericTxn<T> {
    type GraphCursor = ::sanakirja::Cursor;

[22.38214]

[22.38322]

impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> GraphIter for GenericTxn<T> {
    type GraphCursor = ::sanakirja::btree::cursor::Cursor<
        Vertex<ChangeId>,
        SerializedEdge,
        P<Vertex<ChangeId>, SerializedEdge>,
    >;

Replacement in libpijul/src/pristine/sanakirja.rs at line 545 [18.531056]

B:BD[22.38422] → [22.38422:38528]

∅:D[22.38528] → [21.40474:40531]

B:BD[18.542828] → [21.40474:40531]

B:BD[21.40531] → [22.38529:38539]

        if let Ok((cursor, _)) = self.txn.set_cursors(&g, None) {
            Ok(cursor)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }

[22.38422]

[22.38539]

        Ok(::sanakirja::btree::cursor::Cursor::new(&self.txn, &g)?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 548 [18.531056]
B:BD[22.38546] → [22.38546:38580]
```
    fn next_graph(
        &self,
```
[22.38546]
[22.38580]
```
    fn next_graph<'txn>(
        &'txn self,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 552 [18.531056]

B:BD[22.38640] → [22.38640:38777]

    ) -> Option<Result<(Vertex<ChangeId>, Edge), TxnErr<Self::GraphError>>> {
        match unsafe { ::sanakirja::next(&self.txn, a) } {

[22.38640]

[22.38777]

    ) -> Option<Result<(&'txn Vertex<ChangeId>, &'txn SerializedEdge), TxnErr<Self::GraphError>>>
    {
        match a.next(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 557 [18.531056]

B:BD[22.38847] → [22.38847:38944]

            Err(::sanakirja::CRCError {}) => Some(Err(TxnErr(SanakirjaError::PristineCorrupt))),

[22.38847]

[18.542878]

            Err(e) => {
                error!("{:?}", e);
                Some(Err(TxnErr(SanakirjaError::PristineCorrupt)))
            }

Insertion in libpijul/src/pristine/sanakirja.rs at line 565 [18.531056]

[18.542895]

[22.38945]

// There is a choice here: the datastructure for `revchanges` is
// intuitively a list. Moreover, when removing a change, we must
// recompute the entire merkle tree after the removed change.
//
// This seems to indicate that a linked list could be an appropriate
// structure (a growable array is excluded because amortised
// complexity is not really acceptable here).
//
// However, we want to be able to answers queries such as "when was
// change X introduced?" without having to read the entire database.
//
// Additionally, even though `SerializedMerkle` has only one
// implementation, and is therefore sized in the current
// implementation, we can't exclude that other algorithms may be
// added, which means that the pages inside linked lists won't even be
// randomly-accessible arrays.

Replacement in libpijul/src/pristine/sanakirja.rs at line 582 [18.531056]

B:BD[22.38966] → [22.38966:39127]

    pub graph: Db<Vertex<ChangeId>, Edge>,
    pub changes: Db<ChangeId, u64>,
    pub revchanges: Db<u64, (ChangeId, Merkle)>,
    pub states: Db<Merkle, u64>,

[22.38966]

[22.39127]

    pub graph: Db<Vertex<ChangeId>, SerializedEdge>,
    pub changes: Db<ChangeId, L64>,
    pub revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>>,
    pub states: UDb<SerializedMerkle, L64>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 591 [18.531056]
∅:D[22.39224] → [21.40535:40601]
B:BD[18.542895] → [21.40535:40601]
```
impl<T: ::sanakirja::Transaction> ChannelTxnT for GenericTxn<T> {
```
[22.39224]
[22.39225]
```
impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> ChannelTxnT for GenericTxn<T> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 594 [18.531056]

B:BD[21.40642] → [43.2022:2104]

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

[21.40642]

[22.39313]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 601 [18.531056]
∅:D[43.2226] → [22.39456:39486]
B:BD[22.39456] → [22.39456:39486]
```
        channel.apply_counter
```
[43.2226]
[22.39486]
```
        channel.apply_counter.into()
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 604 [18.531056]
∅:D[43.2289] → [22.39547:39577]
B:BD[22.39547] → [22.39547:39577]
```
        channel.last_modified
```
[43.2289]
[22.39577]
```
        channel.last_modified.into()
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 613 [18.531056]

B:BD[22.39780] → [22.39780:39899]

    type Changeset = ::sanakirja::Db<ChangeId, u64>;
    type RevChangeset = ::sanakirja::Db<u64, (ChangeId, Merkle)>;

[22.39780]

[21.40695]

    type Changeset = Db<ChangeId, L64>;
    type RevChangeset = UDb<L64, Pair<ChangeId, SerializedMerkle>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 619 [18.531056]

B:BD[22.39972] → [22.39972:40198]

        c: ChangeId,
    ) -> Result<Option<u64>, TxnErr<Self::GraphError>> {
        if let Ok(x) = self.txn.get(channel, c, None) {
            Ok(x)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.39972]

[22.40198]

        c: &ChangeId,
    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {
        match btree::get(&self.txn, channel, c, None) {
            Ok(Some((k, x))) if k == c => Ok(Some(x)),
            Ok(x) => {
                debug!("get_changeset = {:?}", x);
                Ok(None)
            },
            Err(e) => {
                error!("{:?}", e);
                Err(TxnErr(SanakirjaError::PristineCorrupt))
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 636 [18.531056]

B:BD[22.40295] → [22.40295:40534]

        c: u64,
    ) -> Result<Option<(ChangeId, Merkle)>, TxnErr<Self::GraphError>> {
        if let Ok(x) = self.txn.get(revchanges, c, None) {
            Ok(x)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.40295]

[22.40534]

        c: &L64,
    ) -> Result<Option<&Pair<ChangeId, SerializedMerkle>>, TxnErr<Self::GraphError>> {
        match btree::get(&self.txn, revchanges, c, None) {
            Ok(Some((k, x))) if k == c => Ok(Some(x)),
            Ok(_) => Ok(None),
            Err(e) => {
                error!("{:?}", e);
                Err(TxnErr(SanakirjaError::PristineCorrupt))
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 648 [18.531056]

B:BD[22.40551] → [22.40551:40599]

    type ChangesetCursor = ::sanakirja::Cursor;

[22.40551]

[22.40599]

    type ChangesetCursor = ::sanakirja::btree::cursor::Cursor<ChangeId, L64, P<ChangeId, L64>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 654 [18.531056]

B:BD[22.40713] → [22.40713:40815]

    ) -> Result<Cursor<Self, &'a Self, Self::ChangesetCursor, ChangeId, u64>, TxnErr<SanakirjaError>>

[22.40713]

[22.40815]

    ) -> Result<Cursor<Self, &'a Self, Self::ChangesetCursor, ChangeId, L64>, TxnErr<SanakirjaError>>

Replacement in libpijul/src/pristine/sanakirja.rs at line 656 [18.531056]

B:BD[22.40821] → [22.40821:41125]

        if let Ok((cursor, _)) = self.txn.set_cursors(&channel, pos.map(|x| (x, None))) {
            Ok(Cursor {
                cursor,
                txn: self,
                marker: std::marker::PhantomData,
            })
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.40821]

[22.41125]

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

Insertion in libpijul/src/pristine/sanakirja.rs at line 660 [18.531056]

[22.41135]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 669 [18.531056]

B:BD[22.41142] → [22.41142:41193]

    type RevchangesetCursor = ::sanakirja::Cursor;

[22.41142]

[22.41193]

    type RevchangesetCursor = ::sanakirja::btree::cursor::Cursor<
        L64,
        Pair<ChangeId, SerializedMerkle>,
        UP<L64, Pair<ChangeId, SerializedMerkle>>,
    >;

Replacement in libpijul/src/pristine/sanakirja.rs at line 678 [18.531056]
B:BD[22.41321] → [22.41321:41347]
```
        pos: Option<u64>,
```
[22.41321]
[22.41347]
```
        pos: Option<L64>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 680 [18.531056]

B:BD[22.41364] → [22.41364:41441]

        Cursor<Self, RT, Self::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.41364]

[22.41441]

        Cursor<Self, RT, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 683 [18.531056]

B:BD[22.41481] → [22.41481:41777]

        if let Ok((cursor, _)) = txn.txn.set_cursors(channel, pos.map(|x| (x, None))) {
            Ok(Cursor {
                cursor,
                txn,
                marker: std::marker::PhantomData,
            })
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.41481]

[22.41777]

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

Insertion in libpijul/src/pristine/sanakirja.rs at line 687 [18.531056]

[22.41787]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 699 [18.531056]
B:BD[22.41886] → [22.41886:41912]
```
        pos: Option<u64>,
```
[22.41886]
[22.41912]
```
        pos: Option<L64>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 701 [18.531056]

B:BD[22.41929] → [22.41929:42015]

        RevCursor<Self, &'a Self, Self::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.41929]

[22.42015]

        RevCursor<Self, &'a Self, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 704 [18.531056]

B:BD[22.42055] → [22.42055:42387]

        let cursor = if let Some(pos) = pos {
            if let Ok((x, _)) = self.txn.set_cursors(channel, Some((pos, None))) {
                x
            } else {
                return Err(TxnErr(SanakirjaError::PristineCorrupt));
            }
        } else if let Ok(x) = self.txn.set_cursors_last(channel) {
            x

[22.42055]

[22.42387]

        let mut cursor = btree::cursor::Cursor::new(&self.txn, channel)?;
        if let Some(ref pos) = pos {
            cursor.set(&self.txn, pos, None)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 708 [18.531056]

B:BD[22.42404] → [22.42404:42469]

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

[22.42404]

[22.42469]

            cursor.set_last(&self.txn)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 713 [18.531056]

B:BD[22.42546] → [22.42546:42592]

            marker: std::marker::PhantomData,

[22.42546]

[22.42592]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 722 [18.531056]

B:BD[22.42705] → [22.42705:42855]

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

[22.42705]

[22.42855]

    ) -> Result<Option<(&L64, &Pair<ChangeId, SerializedMerkle>)>, TxnErr<SanakirjaError>> {
        if let Ok(x) = cursor.next(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 732 [18.531056]

B:BD[22.43058] → [22.43058:43208]

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

[22.43058]

[22.43208]

    ) -> Result<Option<(&L64, &Pair<ChangeId, SerializedMerkle>)>, TxnErr<SanakirjaError>> {
        if let Ok(x) = cursor.prev(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 743 [18.531056]

B:BD[22.43406] → [22.43406:43546]

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

[22.43406]

[22.43546]

    ) -> Result<Option<(&ChangeId, &L64)>, TxnErr<SanakirjaError>> {
        if let Ok(x) = cursor.next(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 753 [18.531056]

B:BD[22.43743] → [22.43743:43883]

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

[22.43743]

[22.43883]

    ) -> Result<Option<(&ChangeId, &L64)>, TxnErr<SanakirjaError>> {
        if let Ok(x) = cursor.prev(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 761 [18.531056]
B:BD[46.3011] → [51.661:709]
```
    type States = ::sanakirja::Db<Merkle, u64>;
```
[46.3011]
[51.709]
```
    type States = UDb<SerializedMerkle, L64>;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 768 [18.531056]

∅:D[51.847] → [46.3085:3161]

B:BD[46.3085] → [46.3085:3161]

B:BD[46.3161] → [51.848:892]

        m: Merkle,
    ) -> Result<Option<u64>, TxnErr<Self::GraphError>> {
        Ok(self.txn.get(channel, m, None)?)

[51.847]

[22.43985]

        m: &SerializedMerkle,
    ) -> Result<Option<L64>, TxnErr<Self::GraphError>> {
        match btree::get(&self.txn, channel, m, None)? {
            Some((k, v)) if k == m => Ok(Some(*v)),
            _ => Ok(None)
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 777 [18.531056]

B:BD[21.41051] → [21.41051:41114]

impl<T: ::sanakirja::Transaction> DepsTxnT for GenericTxn<T> {

[21.41051]

[21.41114]

impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> DepsTxnT for GenericTxn<T> {

Insertion in libpijul/src/pristine/sanakirja.rs at line 784 [18.531056]

[21.41360]

    type DepCursor = ::sanakirja::btree::cursor::Cursor<ChangeId, ChangeId, P<ChangeId, ChangeId>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 788 [18.531056]
B:BD[21.41494] → [21.41494:41515]
```
        p: ChangeId,
```
[21.41494]
[21.41515]
```
        p: &ChangeId,
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 800 [18.531056]

[21.41987]


    type Touched_filesCursor = ::sanakirja::btree::cursor::Cursor<
        Position<ChangeId>,
        ChangeId,
        P<Position<ChangeId>, ChangeId>,
    >;

Insertion in libpijul/src/pristine/sanakirja.rs at line 807 [18.531056]

[21.42053]


    type Rev_touched_filesCursor = ::sanakirja::btree::cursor::Cursor<
        ChangeId,
        Position<ChangeId>,
        P<ChangeId, Position<ChangeId>>,
    >;

Replacement in libpijul/src/pristine/sanakirja.rs at line 816 [18.531056]
B:BD[21.42158] → [21.42158:42179]
```
        k: ChangeId,
```
[21.42158]
[21.42179]
```
        k: &ChangeId,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 826 [18.531056]
B:BD[21.42404] → [21.42404:42425]
```
        k: ChangeId,
```
[21.42404]
[21.42425]
```
        k: &ChangeId,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 836 [18.531056]
B:BD[21.42651] → [21.42651:42682]
```
        k: Position<ChangeId>,
```
[21.42651]
[21.42682]
```
        k: &Position<ChangeId>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 846 [18.531056]
B:BD[21.42946] → [21.42946:42967]
```
        k: ChangeId,
```
[21.42946]
[21.42967]
```
        k: &ChangeId,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 855 [18.531056]

B:BD[21.43211] → [21.43211:43274]

impl<T: ::sanakirja::Transaction> TreeTxnT for GenericTxn<T> {

[21.43211]

[21.43274]

impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> TreeTxnT for GenericTxn<T> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 865 [18.531056]

B:BD[18.545779] → [18.545779:545820]

B:BD[18.545820] → [21.43460:43606]

∅:D[21.43606] → [18.545909:546725]

B:BD[18.545909] → [18.545909:546725]

    type Tree = Db<UnsafePathId, Inode>;
    sanakirja_table_get!(
        tree,
        PathId,
        Inode,
        TreeError,
        (UnsafePathId::from_fileid(key), value),
    );
    sanakirja_iter!(
        tree,
        OwnedPathId,
        Inode,
        if let Some((ref k, ref v)) = pos {
            info!("tree iter {:?} {:?}", k, v);
            Some((UnsafePathId::from_fileid(k.as_file_id()), *v))
        } else {
            None
        },
        map(|(k, v): (UnsafePathId, Inode)| (unsafe { k.to_fileid().to_owned() }, v))
    );
    sanakirja_iter!(
        revtree,
        Inode,
        OwnedPathId,
        if let Some((ref k, ref v)) = pos {
            let v = if let Some(ref v) = *v {
                Some(UnsafePathId::from_fileid(v.as_file_id()))
            } else {
                None
            };
            Some((*k, v))
        } else {
            None
        },
        map(|(k, v): (Inode, UnsafePathId)| (k, unsafe { v.to_fileid().to_owned() }))
    );

[18.545760]

[27.36941]

    type Tree = UDb<PathId, Inode>;
    sanakirja_table_get!(tree, PathId, Inode, TreeError,);
    type TreeCursor =
        ::sanakirja::btree::cursor::Cursor<PathId, Inode, UP<PathId, Inode>>;
    sanakirja_iter!(tree, PathId, Inode,);
    type RevtreeCursor =
        ::sanakirja::btree::cursor::Cursor<Inode, PathId, UP<Inode, PathId>>;
    sanakirja_iter!(revtree, Inode, PathId);

Replacement in libpijul/src/pristine/sanakirja.rs at line 874 [18.531056]

∅:D[27.36942] → [18.546744:546862]

B:BD[18.546744] → [18.546744:546862]

B:BD[18.546862] → [21.43607:43626]

∅:D[21.43626] → [18.546862:547109]

B:BD[18.546862] → [18.546862:547109]

    type Revtree = Db<Inode, UnsafePathId>;
    sanakirja_table_get!(
        revtree,
        Inode,
        PathId,
        TreeError,
        (
            key,
            if let Some(value) = value {
                Some(UnsafePathId::from_fileid(value))
            } else {
                None
            }
        ),
        map(|value| unsafe { value.to_fileid() })
    );

[27.36942]

[27.36945]

    type Revtree = UDb<Inode, PathId>;
    sanakirja_table_get!(revtree, Inode, PathId, TreeError,);

Replacement in libpijul/src/pristine/sanakirja.rs at line 877 [18.531056]

B:BD[18.548625] → [18.548625:548747]

    type Partials = Db<UnsafeSmallStr, Position<ChangeId>>;
    sanakirja_cursor!(
        partials,
        SmallString,

[27.36946]

[18.548747]

    type Partials = UDb<SmallStr, Position<ChangeId>>;
    type PartialsCursor = ::sanakirja::btree::cursor::Cursor<
        SmallStr,

Replacement in libpijul/src/pristine/sanakirja.rs at line 881 [18.531056]

B:BD[18.548775] → [18.548775:549082]

        if let Some((ref k, ref v)) = pos {
            Some((UnsafeSmallStr::from_small_str(k.as_small_str()), *v))
        } else {
            None
        },
        map(|(k, v): (UnsafeSmallStr, Position<ChangeId>)| (
            unsafe { k.to_small_str().to_owned() },
            v
        ))
    );

[18.548775]

[21.43627]

        UP<SmallStr, Position<ChangeId>>,
    >;
    sanakirja_cursor!(partials, SmallStr, Position<ChangeId>,);
    type InodesCursor =
        ::sanakirja::btree::cursor::Cursor<Inode, Position<ChangeId>, P<Inode, Position<ChangeId>>>;

Insertion in libpijul/src/pristine/sanakirja.rs at line 895 [18.531056]

[21.43857]

    #[cfg(debug_assertions)]
    type RevinodesCursor =
        ::sanakirja::btree::cursor::Cursor<Position<ChangeId>, Inode, P<Position<ChangeId>, Inode>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 912 [18.531056]

B:BD[21.44209] → [21.44209:44305]

        super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,

[21.44209]

[21.44305]

        super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallStr, Position<ChangeId>>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 916 [18.531056]

B:BD[21.44388] → [21.44388:44451]

        self.cursor_partials(&self.partials, Some((k0, None)))

[21.44388]

[22.43992]

        self.cursor_partials(&self.partials, Some((&k0, None)))

Replacement in libpijul/src/pristine/sanakirja.rs at line 920 [18.531056]
B:BD[22.44001] → [22.44001:44051]
```
impl<T: ::sanakirja::Transaction> GenericTxn<T> {
```
[22.44001]
[22.44051]
```
impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> GenericTxn<T> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 926 [18.531056]

B:BD[22.44210] → [22.44210:44869]

        if let Some((channel, changes, revchanges, states, counter, last_modified)) = self.txn.get(
            &self.channels,
            UnsafeSmallStr::from_small_str(name.as_small_str()),
            None,
        )? {
            debug!("unsafe_load_channel: found {:?} {:?}", changes, revchanges);
            Ok(Some(Channel {
                graph: channel,
                changes,
                revchanges,
                apply_counter: counter,
                states,
                name: name.clone(),
                last_modified,
            }))
        } else {
            debug!("unsafe_load_channel: not found");
            Ok(None)

[22.44210]

[22.44869]

        match btree::get(&self.txn, &self.channels, &name, None)? {
            Some((name_, tup)) => {
                assert_eq!(name_, name.as_ref());
                debug!("load_channel: {:?} {:?}", name, tup);
                Ok(Some(Channel {
                    graph: Db::from_page(tup.0[0].into()),
                    changes: Db::from_page(tup.0[1].into()),
                    revchanges: UDb::from_page(tup.0[2].into()),
                    states: UDb::from_page(tup.0[3].into()),
                    apply_counter: tup.0[4].into(),
                    last_modified: tup.0[5].into(),
                    name,
                }))
            }
            _ => {
                debug!("unsafe_load_channel: not found");
                Ok(None)
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 948 [18.531056]

B:BD[21.44460] → [21.44460:44519]

impl<T: ::sanakirja::Transaction> TxnT for GenericTxn<T> {

[21.44460]

[21.44519]

impl<T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>> TxnT for GenericTxn<T> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 953 [18.531056]

B:BD[21.44654] → [21.44654:44724]

        let h = if let Some(h) = Hash::from_prefix(s) {
            h

[21.44654]

[21.44724]

        let h: SerializedHash = if let Some(ref h) = Hash::from_prefix(s) {
            h.into()

Replacement in libpijul/src/pristine/sanakirja.rs at line 960 [18.531056]

B:BD[21.44884] → [21.44884:44974]

        for x in self
            .txn
            .iter(&self.internal, Some((h, None)))

[21.44884]

[21.44974]

        for x in btree::iter(&self.txn, &self.internal, Some((&h, None)))

Replacement in libpijul/src/pristine/sanakirja.rs at line 965 [18.531056]
B:BD[21.45168] → [21.45168:45191]
```
            if e < h {
```
[21.45168]
[21.45191]
```
            if e < &h {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 968 [18.531056]
[21.45238]
[21.45238]
```
                let e: Hash = e.into();
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 975 [18.531056]
B:BD[21.45487] → [21.45487:45529]
```
                    result = Some((e, i))
```
[21.45487]
[21.45529]
```
                    result = Some((e, *i))
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 994 [18.531056]

B:BD[21.46052] → [21.46052:46122]

        let h = if let Some(h) = Hash::from_prefix(s) {
            h

[21.46052]

[21.46122]

        let h: SerializedHash = if let Some(h) = Hash::from_prefix(s) {
            (&h).into()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1001 [18.531056]

B:BD[21.46282] → [21.46282:46369]

        for x in self
            .txn
            .iter(&remote.rev, Some((h, None)))

[21.46282]

[21.46369]

        for x in btree::iter(&self.txn, &remote.rev, Some((&h, None)))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1006 [18.531056]
B:BD[21.46555] → [21.46555:46578]
```
            if e < h {
```
[21.46555]
[21.46578]
```
            if e < &h {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 1009 [18.531056]
[21.46625]
[21.46625]
```
                let e: Hash = e.into();
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1055 [18.531056]

B:BD[18.550535] → [18.550535:550721]

B:BD[18.550721] → [21.47574:47595]

∅:D[21.47595] → [18.550741:551070]

B:BD[18.550741] → [18.550741:551070]

B:BD[18.551070] → [22.45271:45321]

∅:D[22.45321] → [18.551103:551128]

B:BD[18.551103] → [18.551103:551128]

B:BD[18.551128] → [21.47596:47633]

                if let Some(remote) = self.txn.get(
                    &self.remotes,
                    UnsafeSmallStr::from_small_str(name.as_small_str()),
                    None,
                )? {
                    let r = RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: remote.0,
                            rev: remote.1,
                            states: remote.2,
                        })),
                        name: name.clone(),
                    };
                    Ok(Some(v.insert(r).clone()))
                } else {
                    return Ok(None);

[18.550535]

[18.551161]

                match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name.as_ref() == name_ => {
                        debug!("load_remote: {:?} {:?}", name_, remote);
                        let r = Remote {
                            remote: UDb::from_page(remote.0[0].into()),
                            rev: UDb::from_page(remote.0[1].into()),
                            states: UDb::from_page(remote.0[2].into()),
                        };
                        for x in btree::iter(&self.txn, &r.remote, None).unwrap() {
                            debug!("remote -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.rev, None).unwrap() {
                            debug!("rev -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.states, None).unwrap() {
                            debug!("states -> {:?}", x);
                        }
                        for x in self.iter_remote(&r.remote, 0).unwrap() {
                            debug!("ITER {:?}", x);
                        }
                        let r = RemoteRef {
                            db: Rc::new(RefCell::new(r)),
                            name: name.clone(),
                        };
                        Ok(Some(v.insert(r).clone()))
                    }
                    _ => return Ok(None)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1091 [18.531056]

B:BD[18.551320] → [18.551320:551813]

    type Channels = Db<UnsafeSmallStr, (u64, u64, u64, u64, u64, u64)>;
    sanakirja_cursor!(
        channels,
        SmallString,
        (u64, u64, u64, u64, u64, u64),
        if let Some((ref k, ref v)) = pos {
            Some((UnsafeSmallStr::from_small_str(k.as_small_str()), *v))
        } else {
            None
        },
        map(|(k, v): (UnsafeSmallStr, (u64, u64, u64, u64, u64, u64))| (
            unsafe { k.to_small_str().to_owned() },
            v
        ))
    );

[18.551320]

[21.47694]

    type Channels = UDb<SmallStr, T6>;
    type ChannelsCursor = ::sanakirja::btree::cursor::Cursor<SmallStr, T6, UP<SmallStr, T6>>;
    sanakirja_cursor!(channels, SmallStr, T6,);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1099 [18.531056]

B:BD[18.551947] → [18.551947:552019]

B:BD[18.552019] → [21.47837:47947]

∅:D[21.47947] → [18.552125:552148]

B:BD[18.552125] → [18.552125:552148]

B:BD[18.552148] → [21.47948:47959]

        let name = UnsafeSmallStr::from_small_str(name.as_small_str());
        Ok(ChannelIterator {
            cursor: self.txn.set_cursors(&self.channels, Some((name, None)))?.0,
            txn: self,
        })

[18.551947]

[18.552158]

        let mut cursor = btree::cursor::Cursor::new(&self.txn, &self.channels)?;
        cursor.set(&self.txn, &name, None)?;
        Ok(ChannelIterator { cursor, txn: self })

Replacement in libpijul/src/pristine/sanakirja.rs at line 1104 [18.531056]

B:BD[18.552165] → [18.552165:552611]

    type Remotes = Db<UnsafeSmallStr, (u64, u64, u64)>;
    sanakirja_cursor!(
        remotes,
        SmallString,
        (u64, u64, u64),
        if let Some((ref k, ref v)) = pos {
            Some((UnsafeSmallStr::from_small_str(k.as_small_str()), *v))
        } else {
            None
        },
        map(|(k, v): (UnsafeSmallStr, (u64, u64, u64))| (
            unsafe { k.to_small_str().to_owned() },
            v
        ))
    );

[18.552165]

[21.47960]

    type Remotes = UDb<SmallStr, T3>;
    type RemotesCursor = ::sanakirja::btree::cursor::Cursor<SmallStr, T3, UP<SmallStr, T3>>;
    sanakirja_cursor!(remotes, SmallStr, T3);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1112 [18.531056]

B:BD[18.552744] → [18.552744:552816]

B:BD[18.552816] → [21.48102:48211]

∅:D[21.48211] → [18.552921:552944]

B:BD[18.552921] → [18.552921:552944]

B:BD[18.552944] → [21.48212:48223]

        let name = UnsafeSmallStr::from_small_str(name.as_small_str());
        Ok(RemotesIterator {
            cursor: self.txn.set_cursors(&self.remotes, Some((name, None)))?.0,
            txn: self,
        })

[18.552744]

[18.552954]

        let mut cursor = btree::cursor::Cursor::new(&self.txn, &self.remotes)?;
        cursor.set(&self.txn, &name, None)?;
        Ok(RemotesIterator { cursor, txn: self })

Replacement in libpijul/src/pristine/sanakirja.rs at line 1117 [18.531056]

B:BD[18.554517] → [18.554517:554745]

    type Remote = Db<u64, (Hash, Merkle)>;
    type Revremote = Db<Hash, u64>;
    type Remotestates = Db<Merkle, u64>;
    sanakirja_cursor!(remote, u64, (Hash, Merkle));
    sanakirja_rev_cursor!(remote, u64, (Hash, Merkle));

[18.552961]

[18.554745]

    type Remote = UDb<L64, Pair<SerializedHash, SerializedMerkle>>;
    type Revremote = UDb<SerializedHash, L64>;
    type Remotestates = UDb<SerializedMerkle, L64>;
    type RemoteCursor = ::sanakirja::btree::cursor::Cursor<
        L64,
        Pair<SerializedHash, SerializedMerkle>,
        UP<L64, Pair<SerializedHash, SerializedMerkle>>,
    >;
    sanakirja_cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);
    sanakirja_rev_cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1133 [18.531056]

B:BD[21.48241] → [21.48241:48323]

        super::Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,

[21.48241]

[21.48323]

        super::Cursor<
            Self,
            &'txn Self,
            Self::RemoteCursor,
            L64,
            Pair<SerializedHash, SerializedMerkle>,
        >,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1142 [18.531056]
∅:D[21.48365] → [18.554923:554975]
B:BD[18.554923] → [18.554923:554975]
```
        self.cursor_remote(remote, Some((k, None)))
```
[21.48365]
[18.554975]
```
        self.cursor_remote(remote, Some((&k.into(), None)))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1148 [18.531056]
B:BD[18.555063] → [18.555063:555087]
```
        k: Option<u64>,
```
[18.555063]
[21.48366]
```
        k: Option<L64>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1150 [18.531056]

B:BD[21.48383] → [21.48383:48468]

        super::RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,

[21.48383]

[21.48468]

        super::RevCursor<
            Self,
            &'txn Self,
            Self::RemoteCursor,
            L64,
            Pair<SerializedHash, SerializedMerkle>,
        >,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1159 [18.531056]
∅:D[21.48510] → [18.555174:555235]
B:BD[18.555174] → [18.555174:555235]
```
        self.rev_cursor_remote(remote, k.map(|k| (k, None)))
```
[21.48510]
[18.555235]
```
        self.rev_cursor_remote(remote, k.as_ref().map(|k| (k, None)))
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1169 [18.531056]

B:BD[18.555461] → [18.555461:555647]

B:BD[18.555647] → [21.48639:48660]

∅:D[21.48660] → [18.555667:556054]

B:BD[18.555667] → [18.555667:556054]

B:BD[18.556054] → [21.48661:48698]

                if let Some(remote) = self.txn.get(
                    &self.remotes,
                    UnsafeSmallStr::from_small_str(name.as_small_str()),
                    None,
                )? {
                    let r = RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: remote.0,
                            rev: remote.1,
                            states: remote.2,
                        })),
                        name: name.clone(),
                    };
                    v.insert(r);
                } else {
                    return Ok(None);

[18.555461]

[18.556087]

                match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name_ == name.as_ref() => {
                        let r = RemoteRef {
                            db: Rc::new(RefCell::new(Remote {
                                remote: UDb::from_page(remote.0[0].into()),
                                rev: UDb::from_page(remote.0[1].into()),
                                states: UDb::from_page(remote.0[2].into()),
                            })),
                            name: name.clone(),
                        };
                        v.insert(r);
                    }
                    _ => return Ok(None),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1192 [18.531056]

B:BD[21.48825] → [21.48825:48965]

    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
        Ok(self.txn.rev_iter(remote, None)?.next().transpose()?)

[21.48825]

[18.556369]

    ) -> Result<Option<(u64, &Pair<SerializedHash, SerializedMerkle>)>, TxnErr<Self::GraphError>>
    {
        if let Some(x) = btree::rev_iter(&self.txn, remote, None)?.next() {
            let (&k, v) = x?;
            Ok(Some((k.into(), v)))
        } else {
            Ok(None)
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1206 [18.531056]

B:BD[21.49053] → [21.49053:49216]

    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
        for x in self.txn.iter(remote, Some((n, None)))? {
            let (k, m) = x?;

[21.49053]

[21.49216]

    ) -> Result<Option<(u64, &Pair<SerializedHash, SerializedMerkle>)>, TxnErr<Self::GraphError>>
    {
        let n = n.into();
        for x in btree::iter(&self.txn, remote, Some((&n, None)))? {
            let (&k, m) = x?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1212 [18.531056]
B:BD[21.49240] → [21.49240:49281]
```
                return Ok(Some((k, m)));
```
[21.49240]
[21.49281]
```
                return Ok(Some((k.into(), m)));
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1221 [18.531056]
B:BD[21.49398] → [21.49398:49418]
```
        hash: Hash,
```
[21.49398]
[21.49418]
```
        hash: &SerializedHash,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1223 [18.531056]

B:BD[21.49468] → [21.49468:49541]

        Ok(self.txn.get(&remote.db.borrow().rev, hash, None)?.is_some())

[21.49468]

[18.556746]

        match btree::get(&self.txn, &remote.db.borrow().rev, hash, None)? {
            Some((k, _)) if k == hash => Ok(true),
            _ => Ok(false)
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1231 [18.531056]
B:BD[21.49616] → [21.49616:49635]
```
        m: Merkle,
```
[21.49616]
[21.49635]
```
        m: &SerializedMerkle,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1233 [18.531056]

B:BD[21.49685] → [21.49685:49758]

        Ok(self.txn.get(&remote.db.borrow().states, m, None)?.is_some())

[21.49685]

[18.556898]

        match btree::get(&self.txn, &remote.db.borrow().states, m, None)? {
            Some((k, _)) if k == m => Ok(true),
            _ => Ok(false)
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1244 [18.531056]

B:BD[18.558962] → [18.558962:559008]

        k: Vertex<ChangeId>,
        e: Edge,

[18.558962]

[21.50013]

        k: &Vertex<ChangeId>,
        e: &SerializedEdge,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1247 [18.531056]
∅:D[23.14321] → [18.559047:559101]
∅:D[21.50063] → [18.559047:559101]
B:BD[18.559047] → [18.559047:559101]
```
        Ok(self.txn.put(&mut self.rng, graph, k, e)?)
```
[21.50063]
[18.559101]
```
        Ok(btree::put(&mut self.txn, graph, k, e)?)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1253 [18.531056]

B:BD[18.559196] → [18.559196:559250]

        k: Vertex<ChangeId>,
        e: Option<Edge>,

[18.559196]

[21.50064]

        k: &Vertex<ChangeId>,
        e: Option<&SerializedEdge>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1256 [18.531056]
∅:D[23.14359] → [18.559289:559388]
∅:D[21.50114] → [18.559289:559388]
B:BD[18.559289] → [18.559289:559388]
```
        debug!("del_graph {:?} {:?}", k, e);
        Ok(self.txn.del(&mut self.rng, graph, k, e)?)
```
[21.50114]
[18.559388]
```
        Ok(btree::del(&mut self.txn, graph, k, e)?)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1258 [18.531056]

B:BD[18.559394] → [21.50115:50239]

    sanakirja_put_del!(internal, Hash, ChangeId, GraphError);
    sanakirja_put_del!(external, ChangeId, Hash, GraphError);

[18.559394]

[22.45388]

    sanakirja_put_del!(internal, SerializedHash, ChangeId, GraphError);
    sanakirja_put_del!(external, ChangeId, SerializedHash, GraphError);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1264 [18.531056]
B:BD[22.45461] → [22.45461:45492]
```
        key: Vertex<ChangeId>,
```
[22.45461]
[22.45492]
```
        key: &Vertex<ChangeId>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1266 [18.531056]
B:BD[22.45521] → [22.45521:45550]
```
        buf: &mut Vec<Edge>,
```
[22.45521]
[22.45550]
```
        buf: &mut Vec<SerializedEdge>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1270 [18.531056]

∅:D[72.66] → [22.45598:45677]

B:BD[22.45598] → [22.45598:45677]

        let (mut cursor, _) = self.txn.set_cursors(graph, Some((key, None)))?;

[72.66]

[22.45677]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 1273 [18.531056]

B:BD[22.45692] → [22.45692:45806]

            match unsafe { ::sanakirja::next::<_, Vertex<ChangeId>, Edge>(&self.txn, &mut cursor) }
            {

[22.45692]

[22.45806]

            match cursor.next(&self.txn) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1280 [18.531056]
B:BD[22.46004] → [22.46004:46036]
```
                    buf.push(v)
```
[22.46004]
[22.46036]
```
                    buf.push(*v)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1283 [18.531056]

B:BD[22.46089] → [22.46089:46212]

                Err(::sanakirja::CRCError {}) => {
                    return Err(TxnErr(SanakirjaError::PristineCorrupt))

[22.46089]

[22.46212]

                Err(e) => {
                    error!("{:?}", e);
                    return Err(TxnErr(SanakirjaError::PristineCorrupt));

Replacement in libpijul/src/pristine/sanakirja.rs at line 1290 [18.531056]

B:BD[22.46289] → [22.46289:46460]

            assert!(chi.introduced_by != ChangeId::ROOT || chi.flag.contains(EdgeFlags::PSEUDO));
            if chi.flag.contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {

[22.46289]

[22.46460]

            assert!(
                chi.introduced_by() != ChangeId::ROOT || chi.flag().contains(EdgeFlags::PSEUDO)
            );
            if chi.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1297 [18.531056]

B:BD[22.46549] → [22.46549:46599]

                    chi.flag - EdgeFlags::PARENT,

[22.46549]

[22.46599]

                    chi.flag() - EdgeFlags::PARENT,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1308 [18.531056]
B:BD[22.46941] → [22.46941:46980]
```
                    chi.introduced_by,
```
[22.46941]
[22.46980]
```
                    chi.introduced_by(),
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1312 [18.531056]
B:BD[22.47015] → [22.47015:47067]
```
            self.del_graph(graph, key, Some(chi))?;
```
[22.47015]
[22.47067]
```
            self.del_graph(graph, key, Some(&chi))?;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1315 [18.531056]

B:BD[22.47118] → [22.47118:47176]

                if chi.flag.contains(EdgeFlags::PARENT) {

[22.47118]

[22.47176]

                &if chi.flag().contains(EdgeFlags::PARENT) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1328 [18.531056]
B:BD[22.47560] → [22.47560:47581]
```
                chi,
```
[22.47560]
[22.47581]
```
                &chi,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1342 [18.531056]
B:BD[22.47850] → [22.47850:47888]
```
            channel.last_modified = t
```
[22.47850]
[22.47888]
```
            channel.last_modified = t.into()
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1344 [18.531056]

B:BD[22.47984] → [22.47984:48039]

            channel.last_modified = duration.as_secs()

[22.47984]

[22.48039]

            channel.last_modified = duration.as_secs().into()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1355 [18.531056]

B:BD[21.50340] → [22.48095:48159]

        if self.get_changeset(&channel.changes, p)?.is_none() {

[21.50340]

[18.560386]

        debug!("put_changes {:?} {:?}", p, h);
        if let Some(m) = self.get_changeset(&channel.changes, &p)? {
            debug!("found m = {:?}, p = {:?}", m, p);
            Ok(None)
        } else {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1362 [18.531056]

B:BD[18.560477] → [22.48160:48287]

∅:D[22.48287] → [21.50411:50528]

B:BD[18.560477] → [21.50411:50528]

            for i in self.txn.iter(&channel.changes, None).unwrap() {
                debug!("changes {:?}", i);
            }
            let m = if let Some(x) = self.txn.rev_iter(&channel.revchanges, None)?.next() {
                (x?.1).1

[18.560477]

[18.560596]

            let m = if let Some(x) = btree::rev_iter(&self.txn, &channel.revchanges, None)?.next() {
                (&(x?.1).b).into()

Deletion in libpijul/src/pristine/sanakirja.rs at line 1368 [18.531056]

B:BD[18.560694] → [22.48288:48367]

∅:D[22.48367] → [18.560812:560891]

B:BD[18.560812] → [18.560812:560891]

            assert!(self.get_revchangeset(&channel.revchanges, t)?.is_none());
            assert!(self.txn.put(&mut self.rng, &mut channel.changes, p, t)?);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1369 [18.531056]

B:BD[18.560916] → [18.560916:561074]

                .txn
                .put(&mut self.rng, &mut channel.revchanges, t, (p, m))?);
            Ok(Some(m))
        } else {
            Ok(None)

[18.560916]

[18.561074]

                .get_revchangeset(&channel.revchanges, &t.into())?
                .is_none());
            assert!(btree::put(
                &mut self.txn,
                &mut channel.changes,
                &p,
                &t.into()
            )?);
            assert!(btree::put(
                &mut self.txn,
                &mut channel.revchanges,
                &t.into(),
                &Pair { a: p, b: m.into() }
            )?);
            Ok(Some(m.into()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1394 [18.531056]

B:BD[18.561308] → [21.50646:50753]

∅:D[21.50753] → [18.561390:561450]

B:BD[18.561390] → [18.561390:561450]

        for x in self.txn.iter(&channel.revchanges, Some((t, None)))? {
            let (t_, (p, _)) = x?;
            if t_ >= t {
                repl.push((t_, p))

[18.561308]

[18.561450]

        let tl = t.into();
        for x in btree::iter(&self.txn, &channel.revchanges, Some((&tl, None)))? {
            let (t_, p) = x?;
            if *t_ >= tl {
                repl.push((*t_, p.a))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1402 [18.531056]

B:BD[18.561510] → [21.50754:50866]

∅:D[21.50866] → [18.561597:561645]

B:BD[18.561597] → [18.561597:561645]

        for x in self.txn.rev_iter(&channel.revchanges, Some((t, None)))? {
            let (t_, (_, m_)) = x?;
            if t_ < t {
                m = m_;

[18.561510]

[18.561645]

        for x in btree::rev_iter(&self.txn, &channel.revchanges, Some((&tl, None)))? {
            let (t_, mm) = x?;
            if t_ < &tl {
                m = (&mm.b).into();

Replacement in libpijul/src/pristine/sanakirja.rs at line 1411 [18.531056]

B:BD[18.561781] → [18.561781:561901]

B:BD[18.561901] → [21.50867:50929]

∅:D[21.50929] → [18.561962:562068]

B:BD[18.561962] → [18.561962:562068]

            self.txn
                .del(&mut self.rng, &mut channel.revchanges, *t_, None)?;
            if *t_ > t {
                m = m.next(&self.get_external(*p)?.unwrap());
                self.txn
                    .put(&mut self.rng, &mut channel.revchanges, *t_, (*p, m))?;

[18.561781]

[18.562068]

            btree::del(&mut self.txn, &mut channel.revchanges, t_, None)?;
            if *t_ > tl {
                m = m.next(&self.get_external(p)?.unwrap().into());
                btree::put(
                    &mut self.txn,
                    &mut channel.revchanges,
                    t_,
                    &Pair { a: *p, b: m.into() },
                )?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1422 [18.531056]

B:BD[18.562092] → [18.562092:562193]

        Ok(self
            .txn
            .del(&mut self.rng, &mut channel.changes, p, Some(t))?)

[18.562092]

[21.50930]

        Ok(btree::del(
            &mut self.txn,
            &mut channel.changes,
            &p,
            Some(&t.into()),
        )?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1442 [18.531056]

B:BD[21.51441] → [21.51441:51730]

    sanakirja_put_del!(
        tree,
        PathId,
        Inode,
        TreeError,
        UnsafePathId::from_fileid(k),
        v
    );
    sanakirja_put_del!(
        revtree,
        Inode,
        PathId,
        TreeError,
        k,
        UnsafePathId::from_fileid(v)
    );

[21.51441]

[21.51730]

    sanakirja_put_del!(tree, PathId, Inode, TreeError,);
    sanakirja_put_del!(revtree, Inode, PathId, TreeError,);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1451 [18.531056]

B:BD[21.51910] → [21.51910:52083]

        Ok(self.txn.put(
            &mut self.rng,
            &mut self.partials,
            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,
        )?)

[21.51910]

[18.562193]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 1460 [18.531056]

B:BD[21.52271] → [21.52271:52323]

        Ok(self.txn.del(
            &mut self.rng,

[21.52271]

[21.52323]

        Ok(btree::del(
            &mut self.txn,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1463 [18.531056]

B:BD[21.52355] → [21.52355:52432]

            UnsafeSmallStr::from_small_str(k.as_small_str()),
            e,

[21.52355]

[21.52432]

            &k,
            e.as_ref(),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1477 [18.531056]

B:BD[18.562404] → [18.562404:562600]

        self.txn.put(&mut self.rng, &mut remote.remote, k, v)?;
        self.txn.put(&mut self.rng, &mut remote.states, v.1, k)?;
        Ok(self.txn.put(&mut self.rng, &mut remote.rev, v.0, k)?)

[18.562404]

[18.562600]

        let h = (&v.0).into();
        let m: SerializedMerkle = (&v.1).into();
        btree::put(
            &mut self.txn,
            &mut remote.remote,
            &k.into(),
            &Pair { a: h, b: m.clone() },
        )?;
        btree::put(&mut self.txn, &mut remote.states, &m, &k.into())?;
        Ok(btree::put(&mut self.txn, &mut remote.rev, &h, &k.into())?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1495 [18.531056]

B:BD[18.562753] → [21.52662:52733]

∅:D[21.52733] → [18.562823:563075]

B:BD[18.562823] → [18.562823:563075]

        if let Some((h, m)) = self.txn.get(&remote.remote, k, None)? {
            self.txn.del(&mut self.rng, &mut remote.rev, h, None)?;
            self.txn.del(&mut self.rng, &mut remote.states, m, None)?;
            Ok(self.txn.del(&mut self.rng, &mut remote.remote, k, None)?)
        } else {
            Ok(false)

[18.562753]

[18.563075]

        let k = k.into();
        match btree::get(&self.txn, &remote.remote, &k, None)? {
            Some((k0, p)) if k0 == &k => {
                debug!("del_remote {:?} {:?}", k0, p);
                let p = p.clone();
                btree::del(&mut self.txn, &mut remote.rev, &p.a, None)?;
                btree::del(&mut self.txn, &mut remote.states, &p.b, None)?;
                Ok(btree::del(
                    &mut self.txn,
                    &mut remote.remote,
                    &k.into(),
                    None,
                )?)
            }
            x => {
                debug!("not found, {:?}", x);
                Ok(false)
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1517 [18.531056]
∅:D[23.14812] → [18.563190:563252]
∅:D[21.52835] → [18.563190:563252]
B:BD[18.563190] → [18.563190:563252]
```
        let name = small_string::SmallString::from_str(name);
```
[21.52835]
[18.563252]
```
        let name = crate::small_string::SmallString::from_str(name);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1521 [18.531056]

B:BD[18.563385] → [18.563385:563779]

B:BD[18.563779] → [21.52836:52857]

∅:D[21.52857] → [18.563799:564757]

B:BD[18.563799] → [18.563799:564757]

                let r = if let Some((
                    graph,
                    changes,
                    revchanges,
                    states,
                    apply_counter,
                    last_modified,
                )) = self.txn.get(
                    &self.channels,
                    UnsafeSmallStr::from_small_str(name.as_small_str()),
                    None,
                )? {
                    ChannelRef {
                        r: Rc::new(RefCell::new(Channel {
                            graph,
                            changes,
                            revchanges,
                            states,
                            apply_counter,
                            name: name.clone(),
                            last_modified,
                        })),
                    }
                } else {
                    let br = ChannelRef {
                        r: Rc::new(RefCell::new(Channel {
                            graph: self.txn.create_db()?,
                            changes: self.txn.create_db()?,
                            revchanges: self.txn.create_db()?,
                            states: self.txn.create_db()?,
                            apply_counter: 0,
                            name: name.clone(),
                            last_modified: 0,
                        })),

[18.563385]

[18.564757]

                let r =
                    match btree::get(&self.txn, &self.channels, &name, None)? {
                        Some((name_, b)) => {
                            assert_eq!(name_, name.as_ref());
                            ChannelRef {
                                r: Rc::new(RefCell::new(Channel {
                                    graph: Db::from_page(b.0[0].into()),
                                    changes: Db::from_page(b.0[1].into()),
                                    revchanges: UDb::from_page(b.0[2].into()),
                                    states: UDb::from_page(b.0[3].into()),
                                    apply_counter: b.0[4].into(),
                                    name: name.clone(),
                                    last_modified: b.0[5].into(),
                                })),
                            }
                        }
                        _ => {
                            let br = ChannelRef {
                                r: Rc::new(RefCell::new(Channel {
                                    graph: btree::create_db_(&mut self.txn)?,
                                    changes: btree::create_db_(&mut self.txn)?,
                                    revchanges: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                    apply_counter: 0,
                                    name: name.clone(),
                                    last_modified: 0,
                                })),
                            };
                            commit = Some(br.clone());
                            br
                        }

Deletion in libpijul/src/pristine/sanakirja.rs at line 1553 [18.531056]

B:BD[18.564780] → [18.564780:564869]

                    commit = Some(br.clone());
                    br
                };

Replacement in libpijul/src/pristine/sanakirja.rs at line 1570 [18.531056]

B:BD[18.565367] → [18.565367:565555]

        if self
            .txn
            .get(
                &self.channels,
                UnsafeSmallStr::from_small_str(name.as_small_str()),
                None,
            )

[18.565367]

[21.52924]

        match btree::get(&self.txn, &self.channels, &name, None)

Deletion in libpijul/src/pristine/sanakirja.rs at line 1572 [18.531056]
∅:D[21.52976] → [18.565555:565578]
B:BD[18.565555] → [18.565555:565578]
```
            .is_none()
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1573 [18.531056]

B:BD[18.565588] → [18.565588:565672]

B:BD[18.565672] → [23.14874:15638]

∅:D[23.15638] → [18.565984:566176]

B:BD[18.565984] → [18.565984:566176]

B:BD[18.566176] → [37.4215:4285]

∅:D[37.4285] → [18.566288:566324]

B:BD[18.566288] → [18.566288:566324]

B:BD[18.566324] → [23.15639:15714]

            let br = ChannelRef {
                r: Rc::new(RefCell::new(Channel {
                    graph: self
                        .txn
                        .fork(&mut self.rng, &channel.graph)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    changes: self
                        .txn
                        .fork(&mut self.rng, &channel.changes)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    revchanges: self
                        .txn
                        .fork(&mut self.rng, &channel.revchanges)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    states: self
                        .txn
                        .fork(&mut self.rng, &channel.states)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    name: name.clone(),
                    apply_counter: channel.apply_counter,
                    last_modified: channel.last_modified,
                })),
            };
            self.open_channels.borrow_mut().insert(name, br.clone());
            Ok(br)
        } else {
            Err(super::ForkError::ChannelNameExists(new_name.to_string()))

[18.565588]

[18.566455]

            Some((name_, _)) if name_ == name.as_ref() =>
                Err(super::ForkError::ChannelNameExists(new_name.to_string())),
            _ => {
                let br = ChannelRef {
                    r: Rc::new(RefCell::new(Channel {
                        graph: btree::fork_db(&mut self.txn, &channel.graph)
                            .map_err(|e| ForkError::Txn(e.into()))?,
                        changes: btree::fork_db(&mut self.txn, &channel.changes)
                            .map_err(|e| ForkError::Txn(e.into()))?,
                        revchanges: btree::fork_db(&mut self.txn, &channel.revchanges)
                            .map_err(|e| ForkError::Txn(e.into()))?,
                        states: btree::fork_db(&mut self.txn, &channel.states)
                            .map_err(|e| ForkError::Txn(e.into()))?,
                        name: name.clone(),
                        apply_counter: channel.apply_counter,
                        last_modified: channel.last_modified,
                    })),
                };
                self.open_channels.borrow_mut().insert(name, br.clone());
                Ok(br)
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1603 [18.531056]

B:BD[18.566667] → [18.566667:566855]

        if self
            .txn
            .get(
                &self.channels,
                UnsafeSmallStr::from_small_str(name.as_small_str()),
                None,
            )

[18.566667]

[21.53029]

        match btree::get(&self.txn, &self.channels, &name, None)

Deletion in libpijul/src/pristine/sanakirja.rs at line 1605 [18.531056]
∅:D[21.53081] → [18.566855:566878]
B:BD[18.566855] → [18.566855:566878]
```
            .is_none()
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1606 [18.531056]

B:BD[18.566888] → [2.0:163]

∅:D[2.163] → [23.15762:15840]

B:BD[18.566888] → [23.15762:15840]

B:BD[23.15840] → [2.164:203]

∅:D[2.203] → [23.15880:15970]

B:BD[23.15880] → [23.15880:15970]

            let mut dbs_channels: ::sanakirja::Db<UnsafeSmallStr, (u64, u64, u64, u64, u64, u64)> =
                unsafe { std::mem::transmute(self.channels) };
            self.txn
                .del(
                    &mut self.rng,
                    &mut dbs_channels,
                    UnsafeSmallStr::from_small_str(channel.borrow().name.as_small_str()),

[18.566888]

[23.15970]

            Some((name_, _)) if name_ == name.as_ref() =>
                Err(super::ForkError::ChannelNameExists(new_name.to_string())),
            _ => {
                btree::del(
                    &mut self.txn,
                    &mut self.channels,
                    &channel.borrow().name,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1615 [18.531056]

B:BD[23.16014] → [23.16014:16071]

B:BD[23.16071] → [2.204:278]

∅:D[73.217] → [18.566888:566916]

∅:D[2.278] → [18.566888:566916]

∅:D[23.16071] → [18.566888:566916]

B:BD[18.566888] → [18.566888:566916]

                .map_err(|e| ForkError::Txn(e.into()))?;
            self.channels = unsafe { std::mem::transmute(dbs_channels) };
            std::mem::drop(

[23.16014]

[18.566916]

                    .map_err(|e| ForkError::Txn(e.into()))?;
                std::mem::drop(
                    self.open_channels
                        .borrow_mut()
                        .remove(&channel.borrow().name)
                        .unwrap(),
                );
                std::cell::RefCell::borrow_mut(&std::rc::Rc::get_mut(&mut channel.r).unwrap()).name =
                    name.clone();

Replacement in libpijul/src/pristine/sanakirja.rs at line 1626 [18.531056]

B:BD[18.566985] → [18.566985:567356]

B:BD[18.567356] → [23.16072:16140]

                    .remove(&channel.borrow().name)
                    .unwrap(),
            );
            std::cell::RefCell::borrow_mut(&std::rc::Rc::get_mut(&mut channel.r).unwrap()).name =
                name.clone();
            self.open_channels
                .borrow_mut()
                .insert(name, channel.clone());
            Ok(())
        } else {
            Err(ForkError::ChannelNameExists(new_name.to_string()))

[18.566985]

[18.567487]

                    .insert(name, channel.clone());
                Ok(())
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1636 [18.531056]

B:BD[18.567726] → [18.567726:567915]

        let result = self.txn.del(
            &mut self.rng,
            &mut self.channels,
            UnsafeSmallStr::from_small_str(name.as_small_str()),
            None,
        )?;

[18.567726]

[18.567915]

        let result = btree::del(&mut self.txn, &mut self.channels, &name, None)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1642 [18.531056]
∅:D[23.16310] → [18.568095:568157]
∅:D[21.53261] → [18.568095:568157]
B:BD[18.568095] → [18.568095:568157]
```
        let name = small_string::SmallString::from_str(name);
```
[21.53261]
[18.568157]
```
        let name = crate::small_string::SmallString::from_str(name);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1646 [18.531056]

B:BD[18.568289] → [18.568289:568483]

B:BD[18.568483] → [21.53262:53283]

∅:D[21.53283] → [18.568503:569194]

B:BD[18.568503] → [18.568503:569194]

                let r = if let Some(remote) = self.txn.get(
                    &self.remotes,
                    UnsafeSmallStr::from_small_str(name.as_small_str()),
                    None,
                )? {
                    RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: remote.0,
                            rev: remote.1,
                            states: remote.2,
                        })),
                        name: name.clone(),
                    }
                } else {
                    let br = RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: self.txn.create_db()?,
                            rev: self.txn.create_db()?,
                            states: self.txn.create_db()?,
                        })),
                        name: name.clone(),

[18.568289]

[18.569194]

                let r =
                    match btree::get(&self.txn, &self.remotes, &name, None)? {
                        Some((name_, remote)) if name_ == name.as_ref() => {
                            RemoteRef {
                                db: Rc::new(RefCell::new(Remote {
                                    remote: UDb::from_page(remote.0[0].into()),
                                    rev: UDb::from_page(remote.0[1].into()),
                                    states: UDb::from_page(remote.0[2].into()),
                                })),
                                name: name.clone(),
                            }
                        }
                        _ => {
                            let br = RemoteRef {
                                db: Rc::new(RefCell::new(Remote {
                                    remote: btree::create_db_(&mut self.txn)?,
                                    rev: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                })),
                                name: name.clone(),
                            };
                            commit = Some(br.clone());
                            br
                        }

Deletion in libpijul/src/pristine/sanakirja.rs at line 1671 [18.531056]

B:BD[18.569217] → [18.569217:569306]

                    commit = Some(br.clone());
                    br
                };

Replacement in libpijul/src/pristine/sanakirja.rs at line 1686 [18.531056]

B:BD[18.569845] → [18.569845:570023]

        Ok(self.txn.del(
            &mut self.rng,
            &mut self.remotes,
            UnsafeSmallStr::from_small_str(name.as_small_str()),
            None,
        )?)

[18.569845]

[18.570023]

        Ok(btree::del(&mut self.txn, &mut self.remotes, &name, None)?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1694 [18.531056]

B:BD[18.570293] → [18.570293:570471]

        Ok(self.txn.del(
            &mut self.rng,
            &mut self.remotes,
            UnsafeSmallStr::from_small_str(name.as_small_str()),
            None,
        )?)

[18.570293]

[18.570471]

        Ok(btree::del(&mut self.txn, &mut self.remotes, &name, None)?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1710 [18.531056]

B:BD[18.571013] → [18.571013:571059]

            for (_, remote) in open_remotes {

[18.571013]

[18.571059]

            for (name, remote) in open_remotes {
                debug!("commit remote {:?}", name);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1715 [18.531056]

B:BD[18.571127] → [18.571127:571712]

        self.txn.set_root(Root::Tree as usize, self.tree);
        self.txn.set_root(Root::RevTree as usize, self.revtree);
        self.txn.set_root(Root::Inodes as usize, self.inodes);
        self.txn.set_root(Root::RevInodes as usize, self.revinodes);
        self.txn.set_root(Root::Internal as usize, self.internal);
        self.txn.set_root(Root::External as usize, self.external);
        self.txn.set_root(Root::RevDep as usize, self.revdep);
        self.txn.set_root(Root::Channels as usize, self.channels);
        self.txn.set_root(Root::Remotes as usize, self.remotes);

[18.571127]

[18.571712]

        self.txn.set_root(Root::Tree as usize, self.tree.db);
        self.txn.set_root(Root::RevTree as usize, self.revtree.db);
        self.txn.set_root(Root::Inodes as usize, self.inodes.db);
        self.txn.set_root(Root::RevInodes as usize, self.revinodes.db);
        self.txn.set_root(Root::Internal as usize, self.internal.db);
        self.txn.set_root(Root::External as usize, self.external.db);
        self.txn.set_root(Root::RevDep as usize, self.revdep.db);
        self.txn.set_root(Root::Channels as usize, self.channels.db);
        self.txn.set_root(Root::Remotes as usize, self.remotes.db);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1725 [18.531056]

B:BD[18.571729] → [18.571729:571858]

            .set_root(Root::TouchedFiles as usize, self.touched_files);
        self.txn.set_root(Root::Dep as usize, self.dep);

[18.571729]

[18.571858]

            .set_root(Root::TouchedFiles as usize, self.touched_files.db);
        self.txn.set_root(Root::Dep as usize, self.dep.db);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1728 [18.531056]

B:BD[18.571875] → [18.571875:572021]

            .set_root(Root::RevTouchedFiles as usize, self.rev_touched_files);
        self.txn.set_root(Root::Partials as usize, self.partials);

[18.571875]

[18.572021]

            .set_root(Root::RevTouchedFiles as usize, self.rev_touched_files.db);
        self.txn.set_root(Root::Partials as usize, self.partials.db);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1739 [18.531056]

B:BD[18.572209] → [18.572209:572420]

B:BD[18.572420] → [21.53621:53664]

∅:D[21.53664] → [18.572459:572491]

B:BD[18.572459] → [18.572459:572491]

B:BD[18.572491] → [74.247:300]

∅:D[74.300] → [18.572565:572629]

B:BD[18.572565] → [18.572565:572629]

B:BD[18.572629] → [69.357:379]

∅:D[69.379] → [18.572665:572696]

B:BD[18.572665] → [18.572665:572696]

B:BD[18.572696] → [21.53665:53681]

∅:D[21.53681] → [18.572711:572728]

B:BD[18.572711] → [18.572711:572728]

B:BD[18.572728] → [21.53682:53703]

        if let Some((channel, changes, revchanges, states, counter, last_modified)) = self.txn.get(
            &self.channels,
            UnsafeSmallStr::from_small_str(name.as_small_str()),
            None,
        )? {
            Ok(Some(Channel {
                graph: channel,
                changes,
                revchanges,
                states,
                apply_counter: counter,
                name,
                last_modified,
            }))
        } else {
            Ok(None)

[18.572209]

[18.572745]

        match btree::get(&self.txn, &self.channels, &name, None)? {
            Some((name_, c)) => {
                assert_eq!(name.as_ref(), name_);
                debug!("load_const_channel = {:?} {:?}", name_ ,c);
                Ok(Some(Channel {
                    graph: Db::from_page(c.0[0].into()),
                    changes: Db::from_page(c.0[1].into()),
                    revchanges: UDb::from_page(c.0[2].into()),
                    states: UDb::from_page(c.0[3].into()),
                    apply_counter: c.0[4].into(),
                    last_modified: c.0[5].into(),
                    name,
                }))
            }
            _ => Ok(None)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1771 [18.531056]

B:BD[18.573453] → [18.573453:573831]

        let mut dbs_channels: ::sanakirja::Db<UnsafeSmallStr, (u64, u64, u64, u64, u64, u64)> =
            unsafe { std::mem::transmute(self.channels) };
        debug!("Commit_channel, dbs_channels = {:?}", dbs_channels);
        self.txn.del(
            &mut self.rng,
            &mut dbs_channels,
            UnsafeSmallStr::from_small_str(channel.name.as_small_str()),

[18.573453]

[18.573831]

        debug!("Commit_channel, dbs_channels = {:?}", self.channels);
        btree::del(
            &mut self.txn,
            &mut self.channels,
            &channel.name,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1778 [18.531056]

B:BD[18.573861] → [18.573861:574049]

        debug!("Commit_channel, dbs_channels = {:?}", dbs_channels);
        self.channels = unsafe { std::mem::transmute(dbs_channels) };
        self.txn.put(
            &mut self.rng,

[18.573861]

[18.574049]

        let t6 = T6([
            channel.graph.db.into(),
            channel.changes.db.into(),
            channel.revchanges.db.into(),
            channel.states.db.into(),
            channel.apply_counter.into(),
            channel.last_modified.into(),
        ]);
        debug!("t6 = {:?}", t6);
        btree::put(
            &mut self.txn,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1790 [18.531056]

B:BD[18.574081] → [18.574081:574393]

            UnsafeSmallStr::from_small_str(channel.name.as_small_str()),
            (
                channel.graph,
                channel.changes,
                channel.revchanges,
                channel.states,
                channel.apply_counter,
                channel.last_modified,
            ),

[18.574081]

[18.574393]

            &channel.name,
            &t6,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1793 [18.531056]

B:BD[18.574405] → [18.574405:574480]

        debug!("Commit_channel, self.dbs.channels = {:?}", self.channels);

[18.574405]

[18.574480]

        debug!("Commit_channel, self.channels = {:?}", self.channels);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1808 [18.531056]

∅:D[23.16806] → [18.574980:575336]

∅:D[21.53791] → [18.574980:575336]

B:BD[18.574980] → [18.574980:575336]

        let mut dbs_remotes: ::sanakirja::Db<UnsafeSmallStr, (u64, u64, u64)> =
            unsafe { std::mem::transmute(self.remotes) };
        debug!("Commit_remote, dbs_remotes = {:?}", dbs_remotes);
        self.txn.del(
            &mut self.rng,
            &mut dbs_remotes,
            UnsafeSmallStr::from_small_str(remote.name.as_small_str()),

[21.53791]

[18.575336]

        btree::del(
            &mut self.txn,
            &mut self.remotes,
            &remote.name,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1814 [18.531056]

B:BD[18.575366] → [18.575366:575500]

        debug!("Commit_remote, dbs_remotes = {:?}", dbs_remotes);
        self.remotes = unsafe { std::mem::transmute(dbs_remotes) };

[18.575366]

[18.575500]

        debug!("Commit_remote, dbs_remotes = {:?}", self.remotes);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1816 [18.531056]
B:BD[18.575536] → [18.575536:575585]
```
        self.txn.put(
            &mut self.rng,
```
[18.575536]
[18.575585]
```
        btree::put(
            &mut self.txn,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1819 [18.531056]

B:BD[18.575616] → [18.575616:575729]

            UnsafeSmallStr::from_small_str(remote.name.as_small_str()),
            (r.remote, r.rev, r.states),

[18.575616]

[18.575729]

            &remote.name,
            &T3([
                r.remote.db.into(),
                r.rev.db.into(),
                r.states.db.into()
            ]),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1837 [18.531056]

B:BD[18.576153] → [18.576153:576850]

const CHANGE_ID_SIZE: usize = 8;
impl Representable for ChangeId {
    fn alignment() -> Alignment {
        Alignment::B8
    }
    fn onpage_size(&self) -> u16 {
        CHANGE_ID_SIZE as u16
    }
    unsafe fn write_value(&self, p: *mut u8) {
        LittleEndian::write_u64(std::slice::from_raw_parts_mut(p, 8), self.0)
    }
    unsafe fn read_value(p: *const u8) -> Self {
        ChangeId(LittleEndian::read_u64(std::slice::from_raw_parts(p, 8)))
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.0.cmp(&x.0)
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()
    }
}

[18.576098]

[18.576850]

direct_repr!(L64);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1839 [18.531056]
B:BD[18.576851] → [18.576851:576899]
```
const VERTEX_SIZE: usize = CHANGE_ID_SIZE + 16;
```
[18.576851]
[18.576899]
```
direct_repr!(ChangeId);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1841 [18.531056]

B:BD[18.576900] → [18.576900:578062]

impl Representable for Vertex<ChangeId> {
    fn alignment() -> Alignment {
        Alignment::B1
    }
    fn onpage_size(&self) -> u16 {
        VERTEX_SIZE as u16
    }
    unsafe fn write_value(&self, p: *mut u8) {
        let p = std::slice::from_raw_parts_mut(p, VERTEX_SIZE);
        LittleEndian::write_u64(p, self.change.0);
        LittleEndian::write_u64(&mut p[CHANGE_ID_SIZE..], self.start.0);
        LittleEndian::write_u64(&mut p[CHANGE_ID_SIZE + 8..], self.end.0);
    }
    unsafe fn read_value(p: *const u8) -> Self {
        let p = std::slice::from_raw_parts(p, VERTEX_SIZE);
        let change = LittleEndian::read_u64(p);
        let start = LittleEndian::read_u64(&p[CHANGE_ID_SIZE..]);
        let end = LittleEndian::read_u64(&p[CHANGE_ID_SIZE + 8..]);
        Vertex {
            change: ChangeId(change),
            start: ChangePosition(start),
            end: ChangePosition(end),
        }
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.cmp(&x)
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()
    }
}

[18.576900]

[18.578062]

direct_repr!(Vertex<ChangeId>);
direct_repr!(Position<ChangeId>);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1844 [18.531056]

B:BD[18.578063] → [18.578063:578926]

impl Representable for Position<ChangeId> {
    fn alignment() -> Alignment {
        Alignment::B1
    }
    fn onpage_size(&self) -> u16 {
        (CHANGE_ID_SIZE + 8) as u16
    }
    unsafe fn write_value(&self, p: *mut u8) {
        let p = std::slice::from_raw_parts_mut(p, CHANGE_ID_SIZE + 8);
        LittleEndian::write_u64(p, self.change.0);
        LittleEndian::write_u64(&mut p[CHANGE_ID_SIZE..], self.pos.0);
    }
    unsafe fn read_value(p: *const u8) -> Self {
        let p = std::slice::from_raw_parts(p, CHANGE_ID_SIZE + 8);
        let change = LittleEndian::read_u64(p);
        let pos = LittleEndian::read_u64(&p[CHANGE_ID_SIZE..]);
        Position {
            change: ChangeId(change),
            pos: ChangePosition(pos),
        }
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.cmp(&x)

[18.578063]

[18.578926]

direct_repr!(SerializedEdge);
impl Storable for PathId {
    fn compare<T>(&self, _: &T, x: &Self) -> std::cmp::Ordering {
        self.cmp(x)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1850 [18.531056]

B:BD[18.578932] → [18.578932:579028]

    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {

[18.578932]

[18.579028]

    type PageReferences = std::iter::Empty<u64>;
    fn page_references(&self) -> Self::PageReferences {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1855 [18.531056]

B:BD[18.579063] → [18.579063:579202]


impl Representable for Edge {
    fn alignment() -> Alignment {
        Alignment::B1
    }
    fn onpage_size(&self) -> u16 {
        25

[18.579063]

[18.579202]

impl UnsizedStorable for PathId {
    const ALIGN: usize = 8;
    fn size(&self) -> usize {
        9 + self.basename.len()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1860 [18.531056]

B:BD[18.579208] → [18.579208:579553]

    unsafe fn write_value(&self, p: *mut u8) {
        let s = std::slice::from_raw_parts_mut(p, 25);
        s[0] = (*self).flag.bits();
        LittleEndian::write_u64(&mut s[1..], (*self).dest.change.0);
        LittleEndian::write_u64(&mut s[9..], (*self).dest.pos.0);
        LittleEndian::write_u64(&mut s[17..], (*self).introduced_by.0);

[18.579208]

[18.579553]

    unsafe fn onpage_size(p: *const u8) -> usize {
        let len = *(p.add(8)) as usize;
        9 + len

Replacement in libpijul/src/pristine/sanakirja.rs at line 1864 [18.531056]

B:BD[18.579559] → [18.579559:580108]

    unsafe fn read_value(p: *const u8) -> Self {
        let s = std::slice::from_raw_parts(p, 25);
        Edge {
            flag: if let Some(b) = EdgeFlags::from_bits(s[0]) {
                b
            } else {
                panic!("read_value, edge = {:?}", s);
            },
            dest: Position {
                change: ChangeId(LittleEndian::read_u64(&s[1..])),
                pos: ChangePosition(LittleEndian::read_u64(&s[9..])),
            },
            introduced_by: ChangeId(LittleEndian::read_u64(&s[17..])),
        }

[18.579559]

[18.580108]

    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
        path_id_from_raw_ptr(p)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1867 [18.531056]

B:BD[18.580114] → [18.580114:580261]

    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        let a: &Edge = self;
        let b: &Edge = &x;
        a.cmp(b)

[18.580114]

[18.580261]

    unsafe fn write_to_page(&self, p: *mut u8) {
        *(p as *mut u64) = (self.parent_inode.0).0;
        self.basename.write_to_page(p.add(8))

Deletion in libpijul/src/pristine/sanakirja.rs at line 1871 [18.531056]

B:BD[18.580267] → [18.580267:580396]

    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()
    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1873 [18.531056]

B:BD[18.580399] → [18.580399:580608]

B:BD[18.580623] → [18.580623:580704]

/// An internal "unsafe" version of a [`pristine::PathId`], used to
/// circumvent the absence of associated type constructors in Rust
/// (else this would be borrow on a table).
#[derive(Clone, Copy, Debug)]
pub struct UnsafePathId {
    parent_inode: Inode,
    basename: UnsafeSmallStr,

[18.580399]

[18.580704]

unsafe fn path_id_from_raw_ptr<'a>(p: *const u8) -> &'a PathId {
    let len = *(p.add(8)) as usize;
    std::mem::transmute(std::slice::from_raw_parts(p, 1 + len as usize))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1877 [18.531056]

B:BD[18.580706] → [18.580706:581104]

impl UnsafePathId {
    pub fn from_fileid(f: PathId) -> UnsafePathId {
        UnsafePathId {
            parent_inode: f.parent_inode,
            basename: UnsafeSmallStr::from_small_str(f.basename),
        }
    }
    pub unsafe fn to_fileid<'a>(&self) -> PathId<'a> {
        PathId {
            parent_inode: self.parent_inode,
            basename: self.basename.to_small_str(),
        }

[18.580706]

[18.581104]


#[test]
fn pathid_repr() {
    let o = OwnedPathId {
        parent_inode: Inode::ROOT,
        basename: SmallString::from_str("blablabla")
    };
    let mut x = vec![0u8; 200];
    unsafe {
        o.write_to_page(x.as_mut_ptr());
        let p = path_id_from_raw_ptr(x.as_ptr());
        assert_eq!(p.basename.as_str(), "blablabla");
        assert_eq!(p.parent_inode, Inode::ROOT);

Deletion in libpijul/src/pristine/sanakirja.rs at line 1894 [18.531056]

B:BD[18.581113] → [18.581113:581991]

impl Representable for UnsafePathId {
    fn alignment() -> Alignment {
        Alignment::B1
    }
    fn onpage_size(&self) -> u16 {
        INODE_SIZE + self.basename.onpage_size()
    }
    unsafe fn write_value(&self, p: *mut u8) {
        self.parent_inode.write_value(p);
        self.basename.write_value(p.offset(INODE_SIZE as isize));
    }
    unsafe fn read_value(p: *const u8) -> Self {
        UnsafePathId {
            parent_inode: Inode::read_value(p),
            basename: UnsafeSmallStr::read_value(p.offset(INODE_SIZE as isize)),
        }
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        let a: PathId = self.to_fileid();
        let b: PathId = x.to_fileid();
        a.cmp(&b)
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()
    }
}

Deletion in libpijul/src/pristine/sanakirja.rs at line 1895 [18.531056]

B:BD[18.581992] → [18.581992:582666]

const INODE_SIZE: u16 = 8;
impl Representable for Inode {
    fn alignment() -> Alignment {
        Alignment::B8
    }
    fn onpage_size(&self) -> u16 {
        INODE_SIZE
    }
    unsafe fn write_value(&self, p: *mut u8) {
        LittleEndian::write_u64(std::slice::from_raw_parts_mut(p, 8), self.0)
    }
    unsafe fn read_value(p: *const u8) -> Self {
        Inode(LittleEndian::read_u64(std::slice::from_raw_parts(p, 8)))
    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.0.cmp(&x.0)
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()
    }
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 1896 [18.531056]

B:BD[18.582667] → [18.582667:582759]

impl Representable for Hash {
    fn alignment() -> Alignment {
        Alignment::B1
    }

[18.582667]

[18.582759]

direct_repr!(Inode);
direct_repr!(SerializedMerkle);
direct_repr!(SerializedHash);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1900 [18.531056]

B:BD[18.582760] → [18.582760:583197]

    fn onpage_size(&self) -> u16 {
        1 + (match *self {
            Hash::Blake3(_) => 32,
            Hash::None => 0,
        })
    }
    unsafe fn write_value(&self, p: *mut u8) {
        match *self {
            Hash::Blake3(q) => {
                *p = HashAlgorithm::Blake3 as u8;
                std::ptr::copy(q.as_ptr(), p.offset(1), 32)
            }
            Hash::None => *p = HashAlgorithm::None as u8,
        }

[18.582760]

[18.583197]

impl<A: Storable, B: Storable> Storable for Pair<A, B> {
    type PageReferences = core::iter::Chain<A::PageReferences, B::PageReferences>;
    fn page_references(&self) -> Self::PageReferences {
        self.a.page_references().chain(self.b.page_references())

Replacement in libpijul/src/pristine/sanakirja.rs at line 1905 [18.531056]

B:BD[18.583203] → [18.583203:583598]

    unsafe fn read_value(p: *const u8) -> Self {
        assert!(*p <= HashAlgorithm::Blake3 as u8);
        match std::mem::transmute(*p) {
            HashAlgorithm::Blake3 => {
                let mut h = [0; BLAKE3_BYTES];
                std::ptr::copy(p.offset(1), h.as_mut_ptr(), BLAKE3_BYTES);
                Hash::Blake3(h)
            }
            HashAlgorithm::None => Hash::None,

[18.583203]

[18.583598]

    fn compare<T: LoadPage>(&self, t: &T, b: &Self) -> core::cmp::Ordering {
        match self.a.compare(t, &b.a) {
            core::cmp::Ordering::Equal => self.b.compare(t, &b.b),
            ord => ord

Deletion in libpijul/src/pristine/sanakirja.rs at line 1910 [18.531056]

B:BD[18.583608] → [18.583608:583838]

    }
    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.cmp(&x)
    }
    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1913 [18.531056]

B:BD[18.583847] → [18.583847:583941]

impl Representable for Merkle {
    fn alignment() -> Alignment {
        Alignment::B1
    }

[18.583847]

[18.583941]

impl<A: Ord + UnsizedStorable, B: Ord + UnsizedStorable> UnsizedStorable for Pair<A, B> {
    const ALIGN: usize = std::mem::align_of::<(A, B)>();

Replacement in libpijul/src/pristine/sanakirja.rs at line 1916 [18.531056]

B:BD[18.583942] → [18.583942:583988]

    fn onpage_size(&self) -> u16 {
        33

[18.583942]

[18.583988]

    fn size(&self) -> usize {
        let a = self.a.size();
        let b_off = (a + (B::ALIGN - 1)) & !(B::ALIGN - 1);
        (b_off + self.b.size() + (Self::ALIGN - 1)) & !(Self::ALIGN - 1)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1921 [18.531056]

B:BD[18.583994] → [18.583994:584693]

    unsafe fn write_value(&self, p: *mut u8) {
        match *self {
            Merkle::Ed25519(q) => {
                *p = MerkleAlgorithm::Ed25519 as u8;
                assert_eq!(*p, 1);
                let q = q.compress();
                let q = q.as_bytes();
                std::ptr::copy(q.as_ptr(), p.offset(1), 32);
            }
        }
    }
    unsafe fn read_value(p: *const u8) -> Self {
        assert_eq!(*p, MerkleAlgorithm::Ed25519 as u8);
        let slice = std::slice::from_raw_parts(p.offset(1), 32);
        Merkle::Ed25519(
            curve25519_dalek::edwards::CompressedEdwardsY::from_slice(slice)
                .decompress()
                .unwrap(),
        )

[18.583994]

[18.584693]

    unsafe fn onpage_size(p: *const u8) -> usize {
        let a = A::onpage_size(p);
        let b_off = (a + (B::ALIGN - 1)) & !(B::ALIGN - 1);
        let b_size = B::onpage_size(p.add(b_off));
        (b_off + b_size + (Self::ALIGN - 1)) & !(Self::ALIGN - 1)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1927 [18.531056]

B:BD[18.584699] → [18.584699:584816]

    unsafe fn cmp_value<T>(&self, _: &T, x: Self) -> std::cmp::Ordering {
        self.to_bytes().cmp(&x.to_bytes())

[18.584699]

[18.584816]

    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
        &*(p as *const Self)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1930 [18.531056]

B:BD[18.584822] → [18.584822:584945]

    type PageOffsets = std::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {
        std::iter::empty()

[18.584822]

[18.584945]

    unsafe fn write_to_page(&self, p: *mut u8) {
        self.a.write_to_page(p);
        let off = (self.a.size() + (B::ALIGN - 1)) & !(B::ALIGN - 1);
        self.b.write_to_page(p.add(off));

Insertion in libpijul/src/pristine/sanakirja.rs at line 1936 [18.531056]
[18.584953]
```
direct_repr!(T3);
direct_repr!(T6);
```

Replacement in libpijul/src/pristine/path_id.rs at line 16 [18.584967]

B:BD[18.585429] → [18.585429:585584]

    pub fn as_file_id(&self) -> PathId {
        PathId {
            parent_inode: self.parent_inode,
            basename: self.basename.as_small_str(),

[18.585429]

[18.585584]

    pub fn inode(parent_inode: Inode) -> Self {
        OwnedPathId {
            parent_inode,
            basename: SmallString::new(),

Replacement in libpijul/src/pristine/path_id.rs at line 25 [18.584967]
B:BD[18.585663] → [18.585663:585725]
```
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]
```
[18.585663]
[18.585725]
```
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]
```
Replacement in libpijul/src/pristine/path_id.rs at line 27 [18.584967]
B:BD[18.585740] → [18.585740:585764]
```
pub struct PathId<'a> {
```
[18.585740]
[18.585764]
```
pub struct PathId {
```
Replacement in libpijul/src/pristine/path_id.rs at line 29 [18.584967]
B:BD[18.585793] → [18.585793:585825]
```
    pub basename: SmallStr<'a>,
```
[18.585793]
[18.585825]
```
    pub basename: SmallStr,
```
Replacement in libpijul/src/pristine/path_id.rs at line 32 [18.584967]
B:BD[18.585828] → [18.585828:585850]
```
impl<'a> PathId<'a> {
```
[18.585828]
[18.585850]
```
impl PathId {
```

Insertion in libpijul/src/pristine/path_id.rs at line 38 [18.584967]

[18.586065]

        }
    }
}
impl std::ops::Deref for OwnedPathId {
    type Target = PathId;
    fn deref(&self) -> &Self::Target {
        let len = 1 + self.basename.len as usize;
        unsafe {
            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, len))

Insertion in libpijul/src/pristine/path_id.rs at line 50 [18.584967]

[18.586081]

}
#[test]
fn pathid() {
    let o = OwnedPathId {
        parent_inode: Inode::ROOT,
        basename: SmallString::from_str("blablabla")
    };
    use std::ops::Deref;
    println!("{:?} {:?}", o.basename.len, o.deref());

Replacement in libpijul/src/pristine/mod.rs at line 24 [18.586748]

B:BD[18.587220] → [18.587220:587267]

#[cfg(feature = "dump")]
pub mod channel_dump;

[18.587220]

[18.587267]

// #[cfg(feature = "dump")]
// pub mod channel_dump;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct L64(pub u64);
impl From<usize> for L64 {
    fn from(u: usize) -> Self {
        L64((u as u64).to_le())
    }
}
impl From<u64> for L64 {
    fn from(u: u64) -> Self {
        L64(u.to_le())
    }
}
impl From<L64> for u64 {
    fn from(u: L64) -> Self {
        u64::from_le(u.0)
    }
}
impl From<L64> for usize {
    fn from(u: L64) -> Self {
        u64::from_le(u.0) as usize
    }
}
impl L64 {
    pub fn as_u64(&self) -> u64 {
        u64::from_le(self.0)
    }
    pub fn as_usize(&self) -> usize {
        u64::from_le(self.0) as usize
    }
}
impl std::fmt::Display for L64 {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        self.0.fmt(fmt)
    }
}
impl Ord for L64 {
    fn cmp(&self, x: &Self) -> std::cmp::Ordering {
        u64::from_le(self.0).cmp(&u64::from_le(x.0))
    }
}
impl PartialOrd for L64 {
    fn partial_cmp(&self, x: &Self) -> Option<std::cmp::Ordering> {
        Some(u64::from_le(self.0).cmp(&u64::from_le(x.0)))
    }
}
impl std::ops::Add<L64> for L64 {
    type Output = Self;
    fn add(self, x: L64) -> L64 {
        L64((u64::from_le(self.0) + u64::from_le(x.0)).to_le())
    }
}
impl std::ops::Add<usize> for L64 {
    type Output = Self;
    fn add(self, x: usize) -> L64 {
        L64((u64::from_le(self.0) + x as u64).to_le())
    }
}
impl std::ops::SubAssign<usize> for L64 {
    fn sub_assign(&mut self, x: usize) {
        self.0 = ((u64::from_le(self.0)) - x as u64).to_le()
    }
}
impl L64 {
    pub fn from_slice_le(s: &[u8]) -> Self {
        let mut u = 0u64;
        assert!(s.len() >= 8);
        unsafe {
            std::ptr::copy_nonoverlapping(s.as_ptr(), &mut u as *mut u64 as *mut u8, 8)
        }
        L64(u)
    }
    pub fn to_slice_le(&self, s: &mut [u8]) {
        assert!(s.len() >= 8);
        unsafe {
            std::ptr::copy_nonoverlapping(&self.0 as *const u64 as *const u8, s.as_mut_ptr(), 8)
        }
    }
}
#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
#[repr(C)]
pub struct T3([L64; 3]);
#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
#[repr(C)]
pub struct T6([L64; 6]);
#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
#[repr(C)]
pub struct Pair<A, B> {
    pub a: A,
    pub b: B,
}

Insertion in libpijul/src/pristine/mod.rs at line 135 [18.586748]
[18.587268]
[18.587268]

Replacement in libpijul/src/pristine/mod.rs at line 226 [18.586748]

B:BD[21.54475] → [21.54475:54528]

    get!(graph, Vertex<ChangeId>, Edge, GraphError);

[18.589224]

[21.54528]

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

Replacement in libpijul/src/pristine/mod.rs at line 229 [18.586748]

B:BD[21.54628] → [21.54628:54719]

    fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>>;

[21.54628]

[21.54719]

    fn get_external(&self, p: &ChangeId) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 233 [18.586748]

B:BD[21.54836] → [21.54836:54927]

    fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>>;

[21.54836]

[22.48878]

    fn get_internal(&self, p: &SerializedHash) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 244 [18.586748]
B:BD[22.49115] → [22.49115:49147]
```
    fn next_adj(
        &self,
```
[22.49115]
[22.49147]
```
    fn next_adj<'a>(
        &'a self,
```

Replacement in libpijul/src/pristine/mod.rs at line 248 [18.586748]

B:BD[22.49199] → [22.49199:49256]

    ) -> Option<Result<Edge, TxnErr<Self::GraphError>>>;

[22.49199]

[22.49256]

    ) -> Option<Result<&'a SerializedEdge, TxnErr<Self::GraphError>>>;

Replacement in libpijul/src/pristine/mod.rs at line 250 [18.586748]
B:BD[22.49257] → [22.49257:49291]
```
    fn find_block(
        &self,
```
[22.49257]
[22.49291]
```
    fn find_block<'a>(
        &'a self,
```

Replacement in libpijul/src/pristine/mod.rs at line 254 [18.586748]

B:BD[22.49351] → [22.49351:49416]

    ) -> Result<Vertex<ChangeId>, BlockError<Self::GraphError>>;

[22.49351]

[22.49416]

    ) -> Result<&'a Vertex<ChangeId>, BlockError<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 256 [18.586748]
B:BD[22.49417] → [22.49417:49455]
```
    fn find_block_end(
        &self,
```
[22.49417]
[22.49455]
```
    fn find_block_end<'a>(
        &'a self,
```

Replacement in libpijul/src/pristine/mod.rs at line 260 [18.586748]

B:BD[22.49515] → [22.49515:49580]

    ) -> Result<Vertex<ChangeId>, BlockError<Self::GraphError>>;

[22.49515]

[21.54927]

    ) -> Result<&'a Vertex<ChangeId>, BlockError<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 279 [18.586748]

B:BD[22.50054] → [22.50054:50131]

        c: ChangeId,
    ) -> Result<Option<u64>, TxnErr<Self::GraphError>>;

[22.50054]

[22.50131]

        c: &ChangeId,
    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 284 [18.586748]

B:BD[22.50209] → [22.50209:50296]

        c: u64,
    ) -> Result<Option<(ChangeId, Merkle)>, TxnErr<Self::GraphError>>;

[22.50209]

[22.50296]

        c: &L64,
    ) -> Result<Option<&Pair<ChangeId, SerializedMerkle>>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 293 [18.586748]

B:BD[22.50457] → [22.50457:50546]

        crate::pristine::Cursor<Self, &'txn Self, Self::ChangesetCursor, ChangeId, u64>,

[22.50457]

[22.50546]

        crate::pristine::Cursor<Self, &'txn Self, Self::ChangesetCursor, ChangeId, L64>,

Replacement in libpijul/src/pristine/mod.rs at line 299 [18.586748]

B:BD[22.50676] → [22.50676:50744]

    ) -> Result<Option<(ChangeId, u64)>, TxnErr<Self::GraphError>>;

[22.50676]

[18.589412]

    ) -> Result<Option<(&ChangeId, &L64)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 304 [18.586748]

B:BD[22.50834] → [22.50834:50902]

    ) -> Result<Option<(ChangeId, u64)>, TxnErr<Self::GraphError>>;

[22.50834]

[18.589600]

    ) -> Result<Option<(&ChangeId, &L64)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 310 [18.586748]
B:BD[22.51055] → [22.51055:51081]
```
        pos: Option<u64>,
```
[22.51055]
[22.51081]
```
        pos: Option<L64>,
```

Replacement in libpijul/src/pristine/mod.rs at line 312 [18.586748]

B:BD[22.51098] → [22.51098:51175]

        Cursor<Self, RT, Self::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.51098]

[22.51175]

        Cursor<Self, RT, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 318 [18.586748]
B:BD[22.51312] → [22.51312:51338]
```
        pos: Option<u64>,
```
[22.51312]
[22.51338]
```
        pos: Option<L64>,
```

Replacement in libpijul/src/pristine/mod.rs at line 320 [18.586748]

B:BD[22.51355] → [22.51355:51443]

        RevCursor<Self, &'txn Self, Self::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.51355]

[22.51443]

        RevCursor<Self, &'txn Self, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 326 [18.586748]

B:BD[22.51579] → [22.51579:51657]

    ) -> Result<Option<(u64, (ChangeId, Merkle))>, TxnErr<Self::GraphError>>;

[22.51579]

[22.51657]

    ) -> Result<Option<(&L64, &Pair<ChangeId, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 331 [18.586748]

B:BD[22.51753] → [22.51753:51831]

    ) -> Result<Option<(u64, (ChangeId, Merkle))>, TxnErr<Self::GraphError>>;

[22.51753]

[46.3214]

    ) -> Result<Option<(&L64, &Pair<ChangeId, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 337 [18.586748]

∅:D[51.1018] → [46.3289:3367]

B:BD[46.3289] → [46.3289:3367]

        hash: Merkle,
    ) -> Result<Option<u64>, TxnErr<Self::GraphError>>;

[51.1018]

[22.51831]

        hash: &SerializedMerkle,
    ) -> Result<Option<L64>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 344 [18.586748]
B:BD[22.51987] → [22.51987:52021]
```
    fn next_graph(
        &self,
```
[22.51987]
[22.52021]
```
    fn next_graph<'txn>(
        &'txn self,
```

Replacement in libpijul/src/pristine/mod.rs at line 348 [18.586748]

B:BD[22.52081] → [22.52081:52158]

    ) -> Option<Result<(Vertex<ChangeId>, Edge), TxnErr<Self::GraphError>>>;

[22.52081]

[22.52158]

    ) -> Option<Result<(&'txn Vertex<ChangeId>, &'txn SerializedEdge), TxnErr<Self::GraphError>>>;

Replacement in libpijul/src/pristine/mod.rs at line 374 [18.586748]
B:BD[21.55590] → [21.55590:55611]
```
        p: ChangeId,
```
[21.55590]
[21.55611]
```
        p: &ChangeId,
```
Replacement in libpijul/src/pristine/mod.rs at line 378 [18.586748]
B:BD[21.55743] → [21.55743:55764]
```
        p: ChangeId,
```
[21.55743]
[21.55764]
```
        p: &ChangeId,
```
Replacement in libpijul/src/pristine/mod.rs at line 382 [18.586748]
B:BD[21.55946] → [21.55946:55967]
```
        p: ChangeId,
```
[21.55946]
[21.55967]
```
        p: &ChangeId,
```
Replacement in libpijul/src/pristine/mod.rs at line 386 [18.586748]
B:BD[21.56100] → [21.56100:56131]
```
        p: Position<ChangeId>,
```
[21.56100]
[21.56131]
```
        p: &Position<ChangeId>,
```
Replacement in libpijul/src/pristine/mod.rs at line 393 [18.586748]
B:BD[21.56314] → [21.56314:56335]
```
        p: ChangeId,
```
[21.56314]
[21.56335]
```
        p: &ChangeId,
```
Replacement in libpijul/src/pristine/mod.rs at line 410 [18.586748]
B:BD[21.56969] → [21.56969:57017]
```
    iter!(tree, OwnedPathId, Inode, TreeError);
```
[21.56969]
[18.589721]
```
    iter!(tree, PathId, Inode, TreeError);
```
Replacement in libpijul/src/pristine/mod.rs at line 414 [18.586748]
B:BD[21.57069] → [21.57069:57120]
```
    iter!(revtree, Inode, OwnedPathId, TreeError);
```
[21.57069]
[18.589823]
```
    iter!(revtree, Inode, PathId, TreeError);
```

Replacement in libpijul/src/pristine/mod.rs at line 422 [18.586748]

B:BD[18.589972] → [21.57249:57316]

    cursor!(partials, SmallString, Position<ChangeId>, TreeError);

[18.589972]

[21.57316]

    cursor!(partials, SmallStr, Position<ChangeId>, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 444 [18.586748]

B:BD[21.57856] → [21.57856:57945]

        Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,

[21.57856]

[21.57945]

        Cursor<Self, &'txn Self, Self::PartialsCursor, SmallStr, Position<ChangeId>>,

Replacement in libpijul/src/pristine/mod.rs at line 457 [18.586748]
B:BD[21.58221] → [21.58221:58289]
```
    cursor!(channels, SmallString, (u64, u64, u64, u64, u64, u64));
```
[21.58221]
[18.591136]
```
    cursor!(channels, SmallStr, T6);
```
Replacement in libpijul/src/pristine/mod.rs at line 489 [18.586748]
B:BD[18.605688] → [18.605688:605740]
```
    cursor!(remotes, SmallString, (u64, u64, u64));
```
[18.605688]
[18.605740]
```
    cursor!(remotes, SmallStr, T3);
```

Replacement in libpijul/src/pristine/mod.rs at line 493 [18.586748]

B:BD[18.605809] → [18.605809:605897]

    cursor!(remote, u64, (Hash, Merkle));
    rev_cursor!(remote, u64, (Hash, Merkle));

[18.605809]

[18.605897]

    cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);
    rev_cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);

Replacement in libpijul/src/pristine/mod.rs at line 501 [18.586748]

B:BD[21.59009] → [21.59009:59084]

        Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,

[21.59009]

[21.59084]

        Cursor<Self, &'txn Self, Self::RemoteCursor, L64, Pair<SerializedHash, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 508 [18.586748]
B:BD[18.606168] → [18.606168:606192]
```
        k: Option<u64>,
```
[18.606168]
[21.59126]
```
        k: Option<L64>,
```

Replacement in libpijul/src/pristine/mod.rs at line 510 [18.586748]

B:BD[21.59143] → [21.59143:59221]

        RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,

[21.59143]

[21.59221]

        RevCursor<Self, &'txn Self, Self::RemoteCursor, L64, Pair<SerializedHash, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 522 [18.586748]

B:BD[21.59456] → [21.59456:59530]

    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;

[21.59456]

[27.36993]

    ) -> Result<Option<(u64, &Pair<SerializedHash, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 528 [18.586748]

B:BD[21.59618] → [21.59618:59692]

    ) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;

[21.59618]

[60.965]

    ) -> Result<Option<(u64, &Pair<SerializedHash, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 533 [18.586748]
B:BD[21.59768] → [21.59768:59788]
```
        hash: Hash,
```
[21.59768]
[21.59788]
```
        hash: &SerializedHash,
```
Replacement in libpijul/src/pristine/mod.rs at line 538 [18.586748]
B:BD[21.60045] → [21.60045:60067]
```
        hash: Merkle,
```
[21.59897]
[21.60067]
```
        hash: &SerializedMerkle,
```
Replacement in libpijul/src/pristine/mod.rs at line 596 [18.586748]
B:BD[21.60982] → [21.60982:61009]
```
    v: Position<ChangeId>,
```
[21.60982]
[21.61009]
```
    v: &Position<ChangeId>,
```
Replacement in libpijul/src/pristine/mod.rs at line 603 [18.586748]
B:BD[27.38198] → [27.38198:38241]
```
                inode = next.parent_inode;
```
[27.38198]
[27.38241]
```
                inode = &next.parent_inode;
```
Replacement in libpijul/src/pristine/mod.rs at line 626 [18.586748]
∅:D[21.61472] → [27.38781:38821]
B:BD[27.38781] → [27.38781:38821]
```
        Some(h) => txn.get_internal(h),
```
[21.61472]
[21.61473]
```
        Some(ref h) => Ok(txn.get_internal(&h.into())?.map(|x| *x)),
```

Replacement in libpijul/src/pristine/mod.rs at line 651 [18.586748]

B:BD[75.47] → [21.61953:62001]

        if let Some(p) = txn.get_internal(p)? {

[75.47]

[75.94]

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

Replacement in libpijul/src/pristine/mod.rs at line 669 [18.586748]

∅:D[22.52979] → [27.39967:39982]

B:BD[27.39967] → [27.39967:39982]

B:BD[27.39982] → [21.62439:62542]

    from: u64,
) -> Result<Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>>

[22.52979]

[21.62542]

    from: L64,
) -> Result<Cursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>, TxnErr<T::GraphError>>

Replacement in libpijul/src/pristine/mod.rs at line 683 [18.586748]
B:BD[21.62745] → [21.62745:62789]
```
        let (_, (_, m)) = e?;
        Ok(m)
```
[21.62745]
[21.62789]
```
        Ok((&(e?.1).b).into())
```
Deletion in libpijul/src/pristine/mod.rs at line 687 [18.586748]
∅:D[76.247] → [27.40357:40360]
∅:D[21.62835] → [27.40357:40360]
B:BD[27.40357] → [27.40357:40360]
B:BD[27.40360] → [21.62836:62917]
∅:D[21.62917] → [27.40434:40447]
B:BD[27.40434] → [27.40434:40447]
B:BD[27.40447] → [22.53153:53179]
∅:D[22.53179] → [27.40473:40488]
B:BD[27.40473] → [27.40473:40488]
B:BD[27.40488] → [21.62918:63018]
B:BD[21.63018] → [43.3022:3061]
B:BD[43.3061] → [68.510:566]
```
}
pub(crate) fn changeid_log_ref<T: ChannelTxnT, RT: std::ops::Deref<Target = T>>(
    txn: RT,
    channel: &T::Channel,
    from: u64,
) -> Result<Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>> {
    let c = txn.rev_changes(&channel);
    Ok(T::cursor_revchangeset_ref(txn, c, Some(from))?)
```
Replacement in libpijul/src/pristine/mod.rs at line 692 [18.586748]
∅:D[22.53265] → [27.40742:40765]
B:BD[27.40742] → [27.40742:40765]
```
    from: Option<u64>,
```
[22.53265]
[21.63197]
```
    from: Option<L64>,
```

Replacement in libpijul/src/pristine/mod.rs at line 694 [18.586748]

B:BD[21.63210] → [21.63210:63285]

    RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[21.63210]

[21.63285]

    RevCursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 711 [18.586748]

B:BD[21.63629] → [43.3145:3242]

        iter: T::cursor_revchangeset_ref(txn, txn.rev_changes(&channel), Some(from_timestamp))?,

[21.63629]

[27.41239]

        iter: T::cursor_revchangeset_ref(txn, txn.rev_changes(&channel), Some(from_timestamp.into()))?,

Replacement in libpijul/src/pristine/mod.rs at line 729 [18.586748]

B:BD[21.63962] → [43.3243:3336]

        iter: txn.rev_cursor_revchangeset(txn.rev_changes(&channel), Some(from_timestamp))?,

[21.63962]

[27.41610]

        iter: txn.rev_cursor_revchangeset(txn.rev_changes(&channel), Some(from_timestamp.into()))?,

Replacement in libpijul/src/pristine/mod.rs at line 748 [18.586748]
B:BD[22.53715] → [22.53715:53761]
```
        Some(Ok(dest)) => Ok(dest.dest == b),
```
[22.53715]
[22.53761]
```
        Some(Ok(dest)) => Ok(dest.dest() == b),
```
Replacement in libpijul/src/pristine/mod.rs at line 758 [18.586748]
B:BD[21.64425] → [21.64425:64450]
```
    a: Vertex<ChangeId>,
```
[21.64425]
[21.64450]
```
    a: &Vertex<ChangeId>,
```
Replacement in libpijul/src/pristine/mod.rs at line 766 [18.586748]
B:BD[21.64603] → [21.64603:64614]
```
        a,
```
[21.64603]
[21.64614]
```
        *a,
```

Replacement in libpijul/src/pristine/mod.rs at line 771 [18.586748]

B:BD[21.64717] → [21.64717:64831]

        if !e.flag.contains(EdgeFlags::PSEUDO)
            && (e.flag.contains(EdgeFlags::BLOCK) || a.is_empty())

[21.64717]

[21.64831]

        if !e.flag().contains(EdgeFlags::PSEUDO)
            && (e.flag().contains(EdgeFlags::BLOCK) || a.is_empty())

Replacement in libpijul/src/pristine/mod.rs at line 784 [18.586748]

B:BD[21.65018] → [21.65018:65085]

    if let Some(h) = txn.get_internal(*h)? {
        return Ok(h);

[21.65018]

[27.43003]

    if let Some(h_) = txn.get_internal(&h.into())? {
        debug!("make_changeid, found = {:?} {:?}", h, h_);
        return Ok(*h_);

Replacement in libpijul/src/pristine/mod.rs at line 792 [18.586748]

∅:D[21.65135] → [27.43145:43218]

B:BD[27.43145] → [27.43145:43218]

        Hash::Blake3(ref s) => ChangeId(LittleEndian::read_u64(&s[..])),

[21.65135]

[27.43218]

        Hash::Blake3(ref s) => ChangeId(L64(LittleEndian::read_u64(&s[..]))),

Replacement in libpijul/src/pristine/mod.rs at line 794 [18.586748]

B:BD[27.43225] → [21.65136:65179]

∅:D[21.65179] → [27.43267:43315]

B:BD[27.43267] → [27.43267:43315]

    while txn.get_external(p)?.is_some() {
        p = ChangeId(rand::thread_rng().gen());

[27.43225]

[18.608586]

    while let Some(ext) = txn.get_external(&p)? {
        debug!("ext = {:?}", ext);
        p = ChangeId(L64(rand::thread_rng().gen()));

Replacement in libpijul/src/pristine/mod.rs at line 811 [18.586748]
B:BD[27.43626] → [21.65251:65301]
```
    for t in txn.iter_tree(root, None).unwrap() {
```
[27.43626]
[21.65301]
```
    for t in txn.iter_tree(&root, None).unwrap() {
```
Replacement in libpijul/src/pristine/mod.rs at line 823 [18.586748]
B:BD[27.43904] → [21.65392:65442]
```
    for t in txn.iter_tree(root, None).unwrap() {
```
[27.43904]
[21.65442]
```
    for t in txn.iter_tree(&root, None).unwrap() {
```

Replacement in libpijul/src/pristine/mod.rs at line 850 [18.586748]

B:BD[27.44748] → [21.65669:65729]

    for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {

[27.44748]

[21.65729]

    for t in txn.iter_revtree(&Inode::ROOT, None).unwrap() {

Replacement in libpijul/src/pristine/mod.rs at line 858 [18.586748]

B:BD[21.65822] → [21.65822:65882]

    for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {

[21.65822]

[21.65882]

    for t in txn.iter_revtree(&Inode::ROOT, None).unwrap() {

Replacement in libpijul/src/pristine/mod.rs at line 898 [18.586748]
B:BD[27.45798] → [27.45798:45835]
```
            debug_vertex(&mut f, k)?
```
[27.45798]
[18.612277]
```
            debug_vertex(&mut f, *k)?
```
Replacement in libpijul/src/pristine/mod.rs at line 900 [18.586748]
B:BD[18.612287] → [27.45836:45884]
```
        debug_edge(txn, channel, &mut f, k, v)?
```
[18.612287]
[27.45884]
```
        debug_edge(txn, channel, &mut f, *k, *v)?
```

Replacement in libpijul/src/pristine/mod.rs at line 930 [18.586748]

B:BD[21.66516] → [22.54205:54272]

            stack.push(txn.find_block(&channel, e.dest).unwrap());

[21.66516]

[18.614068]

            stack.push(*txn.find_block(&channel, e.dest()).unwrap());

Replacement in libpijul/src/pristine/mod.rs at line 945 [18.586748]
∅:D[22.54395] → [21.66600:66633]
B:BD[21.66600] → [21.66600:66633]
```
        let (k, v) = x.unwrap();
```
[22.54395]
[27.47087]
```
        let (&k, &v) = x.unwrap();
```

Replacement in libpijul/src/pristine/mod.rs at line 958 [18.586748]

B:BD[27.47449] → [27.47449:47598]

        if v.flag.contains(EdgeFlags::PARENT)
            && !v.flag.contains(EdgeFlags::FOLDER)
            && !v.flag.contains(EdgeFlags::DELETED)

[27.47449]

[27.47598]

        if v.flag().contains(EdgeFlags::PARENT)
            && !v.flag().contains(EdgeFlags::FOLDER)
            && !v.flag().contains(EdgeFlags::DELETED)

Replacement in libpijul/src/pristine/mod.rs at line 962 [18.586748]

B:BD[27.47608] → [27.47608:47660]

            if v.flag.contains(EdgeFlags::PSEUDO) {

[27.47608]

[27.47660]

            if v.flag().contains(EdgeFlags::PSEUDO) {

Replacement in libpijul/src/pristine/mod.rs at line 969 [18.586748]

B:BD[18.615054] → [37.4471:4517]

B:BD[37.4517] → [77.420:487]

∅:D[77.487] → [37.4517:4569]

B:BD[37.4517] → [37.4517:4569]

        if v.flag.contains(EdgeFlags::PARENT)
            && (v.flag.contains(EdgeFlags::BLOCK) || k.is_empty())
            && !v.flag.contains(EdgeFlags::DELETED)

[18.615054]

[37.4569]

        if v.flag().contains(EdgeFlags::PARENT)
            && (v.flag().contains(EdgeFlags::BLOCK) || k.is_empty())
            && !v.flag().contains(EdgeFlags::DELETED)

Replacement in libpijul/src/pristine/mod.rs at line 1005 [18.586748]

∅:D[21.67261] → [27.48773:48881]

B:BD[27.48773] → [27.48773:48881]

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

[21.67261]

[27.48881]

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

Replacement in libpijul/src/pristine/mod.rs at line 1010 [18.586748]

B:BD[18.616217] → [22.54396:54471]

                stack.push(txn.find_block_end(&channel, e.dest).unwrap());

[18.616217]

                stack.push(*txn.find_block_end(&channel, e.dest()).unwrap());

Replacement in libpijul/src/pristine/mod.rs at line 1034 [18.586748]

∅:D[63.7741] → [78.507:566]

∅:D[21.67436] → [78.507:566]

B:BD[27.49532] → [78.507:566]

∅:D[78.566] → [27.49584:49642]

B:BD[27.49584] → [27.49584:49642]

B:BD[27.49642] → [78.567:631]

B:BD[78.631] → [22.54472:54538]

            if e.flag.contains(EdgeFlags::PARENT) ^ down {
                debug_edge(txn, &channel, &mut f, v, e)?;
                let v = if e.flag.contains(EdgeFlags::PARENT) {
                    txn.find_block_end(&channel, e.dest).unwrap()

[21.67436]

[78.698]

            if e.flag().contains(EdgeFlags::PARENT) ^ down {
                debug_edge(txn, &channel, &mut f, v, *e)?;
                let v = if e.flag().contains(EdgeFlags::PARENT) {
                    txn.find_block_end(&channel, e.dest()).unwrap()

Replacement in libpijul/src/pristine/mod.rs at line 1039 [18.586748]

B:BD[78.723] → [22.54539:54601]

                    txn.find_block(&channel, e.dest).unwrap()

[78.723]

[78.786]

                    txn.find_block(&channel, e.dest()).unwrap()

Replacement in libpijul/src/pristine/mod.rs at line 1041 [18.586748]
∅:D[78.805] → [27.49714:49745]
B:BD[27.49714] → [27.49714:49745]
```
                stack.push(v);
```
[78.805]
[18.617089]
```
                stack.push(*v);
```
Replacement in libpijul/src/pristine/mod.rs at line 1067 [18.586748]
B:BD[18.617598] → [18.617598:617611]
```
    v: Edge,
```
[18.617598]
[18.617611]
```
    v: SerializedEdge,
```
Replacement in libpijul/src/pristine/mod.rs at line 1069 [18.586748]
B:BD[18.617645] → [18.617645:617702]
```
    let style = if v.flag.contains(EdgeFlags::DELETED) {
```
[18.617645]
[18.617702]
```
    let style = if v.flag().contains(EdgeFlags::DELETED) {
```
Replacement in libpijul/src/pristine/mod.rs at line 1071 [18.586748]
B:BD[18.617727] → [18.617727:617778]
```
    } else if v.flag.contains(EdgeFlags::PSEUDO) {
```
[18.617727]
[18.617778]
```
    } else if v.flag().contains(EdgeFlags::PSEUDO) {
```

Replacement in libpijul/src/pristine/mod.rs at line 1076 [18.586748]

B:BD[18.617834] → [18.617834:617938]

    let color = if v.flag.contains(EdgeFlags::PARENT) {
        if v.flag.contains(EdgeFlags::FOLDER) {

[18.617834]

[18.617938]

    let color = if v.flag().contains(EdgeFlags::PARENT) {
        if v.flag().contains(EdgeFlags::FOLDER) {

Replacement in libpijul/src/pristine/mod.rs at line 1082 [18.586748]
B:BD[18.618004] → [18.618004:618055]
```
    } else if v.flag.contains(EdgeFlags::FOLDER) {
```
[18.618004]
[18.618055]
```
    } else if v.flag().contains(EdgeFlags::FOLDER) {
```

Replacement in libpijul/src/pristine/mod.rs at line 1088 [18.586748]

B:BD[18.618118] → [18.618118:618210]

    if v.flag.contains(EdgeFlags::PARENT) {
        let dest = if v.dest.change.is_root() {

[18.618118]

[18.618210]

    if v.flag().contains(EdgeFlags::PARENT) {
        let dest = if v.dest().change.is_root() {

Replacement in libpijul/src/pristine/mod.rs at line 1091 [18.586748]

B:BD[18.618235] → [22.54602:54673]

        } else if let Ok(dest) = txn.find_block_end(channel, v.dest) {

[18.618235]

[22.54673]

        } else if let Ok(&dest) = txn.find_block_end(channel, v.dest()) {

Replacement in libpijul/src/pristine/mod.rs at line 1105 [18.586748]
B:BD[18.618600] → [18.618600:618651]
```
            if v.flag.contains(EdgeFlags::BLOCK) {
```
[18.618600]
[18.618651]
```
            if v.flag().contains(EdgeFlags::BLOCK) {
```

Replacement in libpijul/src/pristine/mod.rs at line 1110 [18.586748]

B:BD[18.618726] → [18.618726:618818]

            v.introduced_by.to_base32(),
            if v.flag.contains(EdgeFlags::BLOCK) {

[18.618726]

[18.618818]

            v.introduced_by().to_base32(),
            if v.flag().contains(EdgeFlags::BLOCK) {

Replacement in libpijul/src/pristine/mod.rs at line 1119 [18.586748]

B:BD[18.618942] → [22.54719:54783]

    } else if let Ok(dest) = txn.find_block(&channel, v.dest) {

[18.618942]

[18.619006]

    } else if let Ok(dest) = txn.find_block(&channel, v.dest()) {

Replacement in libpijul/src/pristine/mod.rs at line 1129 [18.586748]
B:BD[18.619286] → [18.619286:619337]
```
            if v.flag.contains(EdgeFlags::BLOCK) {
```
[18.619286]
[18.619337]
```
            if v.flag().contains(EdgeFlags::BLOCK) {
```

Replacement in libpijul/src/pristine/mod.rs at line 1134 [18.586748]

B:BD[18.619412] → [18.619412:619504]

            v.introduced_by.to_base32(),
            if v.flag.contains(EdgeFlags::BLOCK) {

[18.619412]

[18.619504]

            v.introduced_by().to_base32(),
            if v.flag().contains(EdgeFlags::BLOCK) {

Replacement in libpijul/src/pristine/mod.rs at line 1150 [18.586748]

B:BD[18.619831] → [18.619831:619947]

            v.dest.change.to_base32(),
            v.dest.pos.0,
            if v.flag.contains(EdgeFlags::BLOCK) {

[18.619831]

[18.619947]

            v.dest().change.to_base32(),
            v.dest().pos.0,
            if v.flag().contains(EdgeFlags::BLOCK) {

Replacement in libpijul/src/pristine/mod.rs at line 1157 [18.586748]

B:BD[18.620022] → [18.620022:620114]

            v.introduced_by.to_base32(),
            if v.flag.contains(EdgeFlags::BLOCK) {

[18.620022]

[18.620114]

            v.introduced_by().to_base32(),
            if v.flag().contains(EdgeFlags::BLOCK) {

Replacement in libpijul/src/pristine/mod.rs at line 1171 [18.586748]

B:BD[18.620373] → [21.67511:67588]

pub struct Cursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

[18.620373]

[22.54784]

pub struct Cursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K:?Sized, V:?Sized> {

Replacement in libpijul/src/pristine/mod.rs at line 1174 [18.586748]

B:BD[22.54825] → [22.54825:54878]

    pub marker: std::marker::PhantomData<(T, K, V)>,

[22.54825]

[18.620579]

    pub t: std::marker::PhantomData<T>,
    pub k: std::marker::PhantomData<K>,
    pub v: std::marker::PhantomData<V>,

Replacement in libpijul/src/pristine/mod.rs at line 1179 [18.586748]

B:BD[18.620582] → [21.67589:67669]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K, V> {

[18.620582]

[22.54879]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K:?Sized, V:?Sized> {

Replacement in libpijul/src/pristine/mod.rs at line 1182 [18.586748]

B:BD[22.54920] → [22.54920:54973]

    pub marker: std::marker::PhantomData<(T, K, V)>,

[22.54920]

[18.620791]

    pub t: std::marker::PhantomData<T>,
    pub k: std::marker::PhantomData<K>,
    pub v: std::marker::PhantomData<V>,

Replacement in libpijul/src/pristine/mod.rs at line 1187 [18.586748]

B:BD[21.67745] → [21.67745:67817]

initialized_cursor!(changeset, ChangeId, u64, ChannelTxnT, GraphError);

[18.620794]

[21.67817]

initialized_cursor!(changeset, ChangeId, L64, ChannelTxnT, GraphError);

Replacement in libpijul/src/pristine/mod.rs at line 1190 [18.586748]
B:BD[21.67856] → [21.67856:67889]
```
    u64,
    (ChangeId, Merkle),
```
[21.67856]
[21.67889]
```
    L64,
    Pair<ChangeId, SerializedMerkle>,
```
Replacement in libpijul/src/pristine/mod.rs at line 1197 [18.586748]
B:BD[21.67967] → [21.67967:68000]
```
    u64,
    (ChangeId, Merkle),
```
[21.67967]
[21.68000]
```
    L64,
    Pair<ChangeId, SerializedMerkle>,
```

Replacement in libpijul/src/pristine/mod.rs at line 1202 [18.586748]

B:BD[21.68035] → [21.68035:68174]

initialized_cursor!(tree, OwnedPathId, Inode, TreeTxnT, TreeError);
initialized_cursor!(revtree, Inode, OwnedPathId, TreeTxnT, TreeError);

[21.68035]

[21.68174]

initialized_cursor!(tree, PathId, Inode, TreeTxnT, TreeError);
initialized_cursor!(revtree, Inode, PathId, TreeTxnT, TreeError);

Replacement in libpijul/src/pristine/mod.rs at line 1207 [18.586748]
B:BD[21.68276] → [21.68276:68293]
```
    SmallString,
```
[21.68276]
[21.68293]
```
    SmallStr,
```

Replacement in libpijul/src/pristine/mod.rs at line 1226 [18.586748]

∅:D[21.68570] → [18.621360:621464]

B:BD[18.621360] → [18.621360:621464]

initialized_cursor!(remote, u64, (Hash, Merkle));
initialized_rev_cursor!(remote, u64, (Hash, Merkle));

[21.68570]

[21.68571]

initialized_cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);
initialized_rev_cursor!(remote, L64, Pair<SerializedHash, SerializedMerkle>);

Replacement in libpijul/src/pristine/mod.rs at line 1240 [18.586748]

B:BD[21.68847] → [21.68847:68900]

    type Item = Result<Edge, TxnErr<T::GraphError>>;

[21.68847]

[18.621990]

    type Item = Result<&'txn SerializedEdge, TxnErr<T::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1249 [18.586748]

∅:D[22.55124] → [18.622809:622887]

B:BD[18.622809] → [18.622809:622887]

    iter: Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.55124]

[18.622887]

    iter: Cursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 1256 [18.586748]

∅:D[22.55160] → [18.623037:623118]

B:BD[18.623037] → [18.623037:623118]

    iter: RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>,

[22.55160]

[18.623118]

    iter: RevCursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

Replacement in libpijul/src/pristine/mod.rs at line 1269 [18.586748]

B:BD[21.70035] → [21.70035:70110]

            let (_, (changeid, _)) = match x {
                Ok(x) => x,

[21.70035]

[21.70110]

            let changeid = match x {
                Ok(x) => (x.1).a,

Replacement in libpijul/src/pristine/mod.rs at line 1273 [18.586748]

B:BD[21.70172] → [21.70172:70251]

            let iter = match self.txn.iter_rev_touched_files(changeid, None) {

[21.70172]

[21.70251]

            let iter = match self.txn.iter_rev_touched_files(&changeid, None) {

Replacement in libpijul/src/pristine/mod.rs at line 1282 [18.586748]
∅:D[21.70522] → [18.623453:623487]
B:BD[18.623453] → [18.623453:623487]
```
                if p > changeid {
```
[21.70522]
[18.623487]
```
                if *p > changeid {
```
Replacement in libpijul/src/pristine/mod.rs at line 1284 [18.586748]
B:BD[18.623514] → [18.623514:623555]
```
                } else if p < changeid {
```
[18.623514]
[18.623555]
```
                } else if *p < changeid {
```

Replacement in libpijul/src/pristine/mod.rs at line 1287 [18.586748]

B:BD[18.623603] → [43.3394:3493]

∅:D[43.3493] → [21.70612:70696]

∅:D[22.55254] → [21.70612:70696]

B:BD[21.70612] → [21.70612:70696]

                match is_ancestor_of(self.txn, self.txn.graph(&self.channel), self.key, touched) {
                    Ok(true) => return self.txn.get_external(changeid).transpose(),

[18.623603]

[21.70696]

                match is_ancestor_of(self.txn, self.txn.graph(&self.channel), self.key, *touched) {
                    Ok(true) => return self.txn.get_external(&changeid).transpose().map(|x| x.map(|x| x.into())),

Replacement in libpijul/src/pristine/mod.rs at line 1309 [18.586748]
B:BD[21.71135] → [21.71135:71187]
```
                Ok((_, (changeid, _))) => changeid,
```
[21.71135]
[21.71187]
```
                Ok((_, p)) => p.a,
```

Replacement in libpijul/src/pristine/mod.rs at line 1311 [18.586748]

B:BD[21.71202] → [21.71202:71281]

            let iter = match self.txn.iter_rev_touched_files(changeid, None) {

[21.71202]

[21.71281]

            let iter = match self.txn.iter_rev_touched_files(&changeid, None) {

Replacement in libpijul/src/pristine/mod.rs at line 1320 [18.586748]
∅:D[21.71552] → [18.624112:624146]
B:BD[18.624112] → [18.624112:624146]
```
                if p > changeid {
```
[21.71552]
[18.624146]
```
                if *p > changeid {
```
Replacement in libpijul/src/pristine/mod.rs at line 1322 [18.586748]
B:BD[18.624173] → [18.624173:624214]
```
                } else if p < changeid {
```
[18.624173]
[18.624214]
```
                } else if *p < changeid {
```

Replacement in libpijul/src/pristine/mod.rs at line 1325 [18.586748]

B:BD[18.624262] → [43.3494:3593]

∅:D[43.3593] → [21.71642:71726]

∅:D[22.55348] → [21.71642:71726]

B:BD[21.71642] → [21.71642:71726]

                match is_ancestor_of(self.txn, self.txn.graph(&self.channel), self.key, touched) {
                    Ok(true) => return self.txn.get_external(changeid).transpose(),

[18.624262]

[21.71726]

                match is_ancestor_of(self.txn, self.txn.graph(&self.channel), self.key, *touched) {
                    Ok(true) => return self.txn.get_external(&changeid).transpose().map(|x| x.map(From::from)),

Replacement in libpijul/src/pristine/mod.rs at line 1361 [18.586748]

B:BD[18.625167] → [22.55349:55420]

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

[18.625167]

[27.50029]

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

Replacement in libpijul/src/pristine/mod.rs at line 1365 [18.586748]
B:BD[18.625304] → [18.625304:625328]
```
                parent,
```
[18.625304]
[18.625328]
```
                *parent,
```
Replacement in libpijul/src/pristine/mod.rs at line 1370 [18.586748]
∅:D[21.72032] → [18.625474:625508]
B:BD[18.625474] → [18.625474:625508]
```
                if pp.dest == a {
```
[21.72032]
[21.72033]
```
                if pp.dest() == a {
```
Replacement in libpijul/src/pristine/mod.rs at line 1373 [18.586748]
B:BD[18.625559] → [18.625559:625595]
```
                stack.push(pp.dest)
```
[18.625559]
[18.625595]
```
                stack.push(pp.dest())
```

Replacement in libpijul/src/pristine/mod.rs at line 1414 [18.586748]

B:BD[21.72742] → [21.72742:72846]

    put_del!(internal, Hash, ChangeId, GraphError);
    put_del!(external, ChangeId, Hash, GraphError);

[21.72742]

[18.626843]

    put_del!(internal, SerializedHash, ChangeId, GraphError);
    put_del!(external, ChangeId, SerializedHash, GraphError);

Replacement in libpijul/src/pristine/mod.rs at line 1421 [18.586748]

B:BD[18.629212] → [18.629212:629258]

        k: Vertex<ChangeId>,
        v: Edge,

[18.629212]

[21.72847]

        k: &Vertex<ChangeId>,
        v: &SerializedEdge,

Replacement in libpijul/src/pristine/mod.rs at line 1429 [18.586748]

B:BD[18.629492] → [18.629492:629546]

        k: Vertex<ChangeId>,
        v: Option<Edge>,

[18.629492]

[21.72897]

        k: &Vertex<ChangeId>,
        v: Option<&SerializedEdge>,

Replacement in libpijul/src/pristine/mod.rs at line 1438 [18.586748]
B:BD[22.55613] → [22.55613:55644]
```
        key: Vertex<ChangeId>,
```
[22.55613]
[22.55644]
```
        key: &Vertex<ChangeId>,
```
Replacement in libpijul/src/pristine/mod.rs at line 1440 [18.586748]
B:BD[22.55673] → [22.55673:55702]
```
        buf: &mut Vec<Edge>,
```
[22.55673]
[22.55702]
```
        buf: &mut Vec<SerializedEdge>,
```
Replacement in libpijul/src/pristine/mod.rs at line 1550 [18.586748]
B:BD[27.50155] → [27.50155:50207]
```
    inode: Inode,
    position: Position<ChangeId>,
```
[27.50155]
[21.75029]
```
    inode: &Inode,
    position: &Position<ChangeId>,
```

Replacement in libpijul/src/pristine/mod.rs at line 1560 [18.586748]

B:BD[60.1594] → [60.1594:1646]

    inode: Inode,
    position: Position<ChangeId>,

[60.1594]

[21.75122]

    inode: &Inode,
    position: &Position<ChangeId>,

Replacement in libpijul/src/pristine/mod.rs at line 1573 [18.586748]
B:BD[60.1908] → [60.1908:1947]
```
    file_id: PathId,
    inode: Inode,
```
[60.1908]
[21.75215]
```
    file_id: &PathId,
    inode: &Inode,
```
Replacement in libpijul/src/pristine/mod.rs at line 1583 [18.586748]
B:BD[60.2116] → [60.2116:2155]
```
    file_id: PathId,
    inode: Inode,
```
[60.2116]
[21.75306]
```
    file_id: &PathId,
    inode: &Inode,
```

Replacement in libpijul/src/pristine/mod.rs at line 1611 [18.586748]

∅:D[21.75959] → [27.52626:52658]

B:BD[27.52626] → [27.52626:52658]

B:BD[27.52658] → [74.357:375]

∅:D[74.375] → [27.52682:52831]

B:BD[27.52682] → [27.52682:52831]

        k0,
        Some(Edge {
            flag,
            dest: Position {
                change: k1.change,
                pos: k1.start,
            },
            introduced_by,
        }),

[21.75959]

[27.52831]

        &k0,
        Some(&SerializedEdge::new(flag, k1.change, k1.start, introduced_by)),

Replacement in libpijul/src/pristine/mod.rs at line 1616 [18.586748]

∅:D[21.75975] → [27.52894:53117]

B:BD[27.52894] → [27.52894:53117]

        k1,
        Some(Edge {
            flag: flag | EdgeFlags::PARENT,
            dest: Position {
                change: k0.change,
                pos: k0.end,
            },
            introduced_by,
        }),

[21.75975]

[27.53117]

        &k1,
        Some(&SerializedEdge::new(flag | EdgeFlags::PARENT, k0.change, k0.end, introduced_by)),

Replacement in libpijul/src/pristine/mod.rs at line 1619 [18.586748]

B:BD[27.53125] → [27.53125:53162]

    assert!((a && b) || (!a && !b));

[27.53125]

[27.53162]

    if (a && !b) || (!a && b) {
        panic!("Failed: {:?} {:?} for {:?} {:?} {:?} {:?}", a, b, flag, k0, k1, introduced_by)
    }

Replacement in libpijul/src/pristine/mod.rs at line 1643 [18.586748]

∅:D[21.76114] → [27.53770:53797]

B:BD[27.53770] → [27.53770:53797]

B:BD[27.53797] → [74.376:394]

∅:D[74.394] → [27.53821:53969]

B:BD[27.53821] → [27.53821:53969]

        k0,
        Edge {
            flag,
            dest: Position {
                change: k1.change,
                pos: k1.start,
            },
            introduced_by,
        },

[21.76114]

[27.53969]

        &k0,
        &SerializedEdge::new(flag, k1.change, k1.start, introduced_by)

Replacement in libpijul/src/pristine/mod.rs at line 1648 [18.586748]

∅:D[21.76130] → [27.54032:54249]

B:BD[27.54032] → [27.54032:54249]

        k1,
        Edge {
            flag: flag ^ EdgeFlags::PARENT,
            dest: Position {
                change: k0.change,
                pos: k0.end,
            },
            introduced_by,
        },

[21.76130]

[27.54249]

        &k1,
        &SerializedEdge::new(flag | EdgeFlags::PARENT, k0.change, k0.end, introduced_by),

Replacement in libpijul/src/pristine/mod.rs at line 1659 [18.586748]
B:BD[27.54371] → [27.54371:54411]
```
    internal: ChangeId,
    hash: Hash,
```
[27.54371]
[27.54411]
```
    internal: &ChangeId,
    hash: &Hash,
```

Replacement in libpijul/src/pristine/mod.rs at line 1664 [18.586748]

∅:D[26.12151] → [27.54465:54543]

∅:D[23.19236] → [27.54465:54543]

B:BD[27.54465] → [27.54465:54543]

    txn.put_external(internal, hash)?;
    txn.put_internal(hash, internal)?;

[26.12151]

[27.54543]

    let shash = hash.into();
    txn.put_external(internal, &shash)?;
    txn.put_internal(&shash, internal)?;

Replacement in libpijul/src/pristine/mod.rs at line 1669 [18.586748]

B:BD[26.12187] → [21.76285:76346]

        let dep_internal = txn.get_internal(*dep)?.unwrap();

[26.12187]

[26.12188]

        let dep_internal = *txn.get_internal(&dep.into())?.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1671 [18.586748]

∅:D[26.12252] → [27.54818:54913]

B:BD[27.54818] → [27.54818:54913]

        txn.put_revdep(dep_internal, internal)?;
        txn.put_dep(internal, dep_internal)?;

[26.12252]

[27.54913]

        txn.put_revdep(&dep_internal, internal)?;
        txn.put_dep(internal, &dep_internal)?;

Replacement in libpijul/src/pristine/mod.rs at line 1692 [18.586748]

B:BD[21.76400] → [21.76400:76453]

            txn.get_internal(c)?.unwrap_or(internal)

[21.76400]

[21.76453]

            txn.get_internal(&c.into())?.unwrap_or(internal)

Replacement in libpijul/src/pristine/mod.rs at line 1697 [18.586748]
B:BD[27.55188] → [21.76503:76523]
```
            change,
```
[27.55188]
[27.55337]
```
            change: *change,
```

Replacement in libpijul/src/pristine/mod.rs at line 1701 [18.586748]

∅:D[26.12808] → [27.55467:55569]

B:BD[27.55467] → [27.55467:55569]

        txn.put_touched_files(inode, internal)?;
        txn.put_rev_touched_files(internal, inode)?;

[26.12808]

[26.12809]

        txn.put_touched_files(&inode, internal)?;
        txn.put_rev_touched_files(internal, &inode)?;

Replacement in libpijul/src/pristine/mod.rs at line 1705 [18.586748]
B:BD[26.12877] → [26.12877:12911]
```
                change: internal,
```
[26.12877]
[26.12911]
```
                change: *internal,
```

Replacement in libpijul/src/pristine/mod.rs at line 1708 [18.586748]

B:BD[26.12947] → [26.12947:13057]

            txn.put_touched_files(inode, internal)?;
            txn.put_rev_touched_files(internal, inode)?;

[26.12947]

[26.13057]

            txn.put_touched_files(&inode, internal)?;
            txn.put_rev_touched_files(internal, &inode)?;

Replacement in libpijul/src/pristine/mod.rs at line 1719 [18.586748]

B:BD[48.753] → [48.753:813]

B:BD[48.813] → [43.3594:3674]

∅:D[43.3674] → [46.3634:3664]

B:BD[46.3634] → [46.3634:3664]

) -> Result<Option<(u64, Merkle)>, TxnErr<T::GraphError>> {
    for x in T::cursor_revchangeset_ref(txn, txn.rev_changes(&c), Some(pos))? {
        let (n, (_, m)) = x?;

[48.753]

[46.3664]

) -> Result<Option<(u64, SerializedMerkle)>, TxnErr<T::GraphError>> {
    for x in T::cursor_revchangeset_ref(txn, txn.rev_changes(&c), Some(pos.into()))? {
        let (&n, m) = x?;
        let n: u64 = n.into();

Replacement in libpijul/src/pristine/mod.rs at line 1724 [18.586748]
B:BD[46.3686] → [48.814:851]
```
            return Ok(Some((n, m)));
```
[46.3686]
[46.3722]
```
            return Ok(Some((n, m.b.clone())));
```

Replacement in libpijul/src/pristine/mod.rs at line 1733 [18.586748]

B:BD[48.916] → [48.916:976]

) -> Result<Option<(u64, Merkle)>, TxnErr<T::GraphError>> {

[48.916]

[46.3867]

) -> Result<Option<(u64, SerializedMerkle)>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 1738 [18.586748]

B:BD[46.3974] → [46.3974:4037]

        let (b, (_, state)) = e?;
        Ok(Some((b, state)))

[46.3974]

[46.4037]

        let (&b,  state) = e?;
        let b: u64 = b.into();
        Ok(Some((b, state.b.clone())))

Replacement in libpijul/src/pristine/mod.rs at line 1751 [18.586748]

B:BD[48.1074] → [48.1074:1131]

) -> Result<(u64, u64, Merkle), TxnErr<T::GraphError>> {

[48.1074]

[46.4265]

) -> Result<(u64, u64, SerializedMerkle), TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 1756 [18.586748]
B:BD[46.4376] → [48.1132:1175]
```
        return Ok((0, 0, Merkle::zero()));
```
[46.4376]
[46.4418]
```
        return Ok((0, 0, Merkle::zero().into()));
```

Replacement in libpijul/src/pristine/mod.rs at line 1758 [18.586748]

B:BD[46.4425] → [51.1019:1089]

∅:D[51.1089] → [48.1176:1211]

B:BD[46.4483] → [48.1176:1211]

    if let Some(aa) = txn.channel_has_state(txn.states(c0), state)? {
        return Ok((aa, b, state));

[46.4425]

[46.4517]

    if let Some(aa) = txn.channel_has_state(txn.states(c0), &state)? {
        return Ok((aa.into(), b, state));

Replacement in libpijul/src/pristine/mod.rs at line 1766 [18.586748]

B:BD[46.4673] → [51.1090:1165]

∅:D[51.1165] → [46.4736:4758]

B:BD[46.4736] → [46.4736:4758]

        if let Some(aa_) = txn.channel_has_state(txn.states(c0), state)? {
            aa = aa_;

[46.4673]

[46.4758]

        if let Some(aa_) = txn.channel_has_state(txn.states(c0), &state)? {
            aa = aa_.into();

Replacement in libpijul/src/pristine/mod.rs at line 1783 [18.586748]
∅:D[21.76690] → [79.717:749]
B:BD[79.717] → [79.717:749]
```
        let mut inode_ = inode;
```
[21.76690]
[79.749]
```
        let mut inode_ = *inode;
```

Replacement in libpijul/src/pristine/mod.rs at line 1785 [18.586748]

B:BD[79.783] → [21.76691:76764]

            if let Some(next) = txn.get_revtree(inode_, None).unwrap() {

[79.783]

[79.847]

            if let Some(next) = txn.get_revtree(&inode_, None).unwrap() {

Replacement in libpijul/src/pristine/mod.rs at line 1791 [18.586748]

B:BD[79.1006] → [21.76765:76835]

        if !is_alive(txn, &channel, vertex.inode_vertex()).unwrap() {

[79.1006]

[21.76835]

        if !is_alive(txn, &channel, &vertex.inode_vertex()).unwrap() {

Replacement in libpijul/src/pristine/mod.rs at line 1808 [18.586748]
B:BD[79.1708] → [21.76986:77035]
```
    for x in txn.iter_tree(id0, None).unwrap() {
```
[79.1708]
[21.77035]
```
    for x in txn.iter_tree(&id0, None).unwrap() {
```
Replacement in libpijul/src/pristine/mod.rs at line 1810 [18.586748]
∅:D[21.77073] → [79.1758:1818]
B:BD[79.1758] → [79.1758:1818]
```
        if let Some(inode_) = h.insert(id.clone(), inode) {
```
[21.77073]
[79.1818]
```
        if let Some(inode_) = h.insert(id.to_owned(), inode) {
```

Insertion in libpijul/src/pristine/merkle.rs at line 8 [18.638683]

[18.638966]

}
impl Default for Merkle {
    fn default() -> Self {
        Merkle::zero()
    }

Insertion in libpijul/src/pristine/merkle.rs at line 92 [18.638683]

[18.641228]


#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct SerializedMerkle(pub [u8; 33]);
impl PartialEq<Merkle> for SerializedMerkle {
    fn eq(&self, m: &Merkle) -> bool {
        match m {
            Merkle::Ed25519(q) => {
                (self.0)[0] == MerkleAlgorithm::Ed25519 as u8
                    && {
                        let q = q.compress();
                        q.as_bytes() == &(self.0)[1..]
                    }
            }
        }
    }
}
impl PartialEq<SerializedMerkle> for Merkle {
    fn eq(&self, m: &SerializedMerkle) -> bool {
        m.eq(self)
    }
}
impl<'a> From<&'a Merkle> for SerializedMerkle {
    fn from(m: &'a Merkle) -> Self {
        let mut mm = [0; 33];
        match m {
            Merkle::Ed25519(q) => {
                mm[0] = MerkleAlgorithm::Ed25519 as u8;
                let q = q.compress();
                let q = q.as_bytes();
                (&mut mm[1..]).copy_from_slice(q);
                SerializedMerkle(mm)
            }
        }
    }
}
impl From<Merkle> for SerializedMerkle {
    fn from(m: Merkle) -> Self {
        let mut mm = [0; 33];
        match m {
            Merkle::Ed25519(q) => {
                mm[0] = MerkleAlgorithm::Ed25519 as u8;
                let q = q.compress();
                let q = q.as_bytes();
                (&mut mm[1..]).copy_from_slice(q);
                SerializedMerkle(mm)
            }
        }
    }
}
impl<'a> From<&'a SerializedMerkle> for Merkle {
    fn from(m: &'a SerializedMerkle) -> Self {
        assert_eq!((m.0)[0], MerkleAlgorithm::Ed25519 as u8);
        Merkle::Ed25519(
            curve25519_dalek::edwards::CompressedEdwardsY::from_slice(&(m.0)[1..])
                .decompress()
                .unwrap(),
        )
    }
}
impl From<SerializedMerkle> for Merkle {
    fn from(m: SerializedMerkle) -> Self {
        assert_eq!((m.0)[0], MerkleAlgorithm::Ed25519 as u8);
        Merkle::Ed25519(
            curve25519_dalek::edwards::CompressedEdwardsY::from_slice(&(m.0)[1..])
                .decompress()
                .unwrap(),
        )
    }
}

Insertion in libpijul/src/pristine/inode.rs at line 1 [18.643628]
[18.643628]
[18.643684]
```
use super::L64;
```
Replacement in libpijul/src/pristine/inode.rs at line 5 [18.643628]
B:BD[18.643870] → [18.643870:643917]
```
pub struct Inode(pub(in crate::pristine) u64);
```
[18.643870]
[18.643917]
```
pub struct Inode(pub(in crate::pristine) super::L64);
```
Deletion in libpijul/src/pristine/inode.rs at line 9 [18.643628]
B:BD[18.644022] → [18.644022:644072]
```
        use byteorder::{ByteOrder, LittleEndian};
```
Replacement in libpijul/src/pristine/inode.rs at line 10 [18.643628]
B:BD[18.644100] → [18.644100:644149]
```
        LittleEndian::write_u64(&mut b, self.0);
```
[18.644100]
[18.644149]
```
        self.0.to_slice_le(&mut b);
```
Replacement in libpijul/src/pristine/inode.rs at line 16 [18.643628]
B:BD[18.644244] → [18.644244:644282]
```
    pub const ROOT: Inode = Inode(0);
```
[18.644244]
[18.644282]
```
    pub const ROOT: Inode = Inode(L64(0u64));
```
Replacement in libpijul/src/pristine/inode.rs at line 21 [18.643628]
B:BD[18.644390] → [18.644390:644420]
```
        Inode(rand::random())
```
[18.644390]
[18.644420]
```
        Inode(L64(rand::random()))
```
Replacement in libpijul/src/pristine/hash.rs at line 46 [18.644439]
B:BD[18.645691] → [18.645691:645737]
```
        write!(fmt, "{:?}", self.to_base32())
```
[18.645691]
[18.645737]
```
        write!(fmt, "{}", self.to_base32())
```

Insertion in libpijul/src/pristine/hash.rs at line 154 [18.644439]

[18.648945]

}
#[derive(Clone, Copy)]
pub struct SerializedHash {
    pub(crate) t: u8,
    h: H
}
#[derive(Clone, Copy)]
pub(crate) union H {
    none: (),
    blake3: [u8; 32],
}
pub(crate) const HASH_NONE: SerializedHash = SerializedHash {
    t: HashAlgorithm::None as u8,
    h: H { none: () },
};
use std::cmp::Ordering;
impl PartialOrd for SerializedHash {
    fn partial_cmp(&self, b: &Self) -> Option<Ordering> {
        Some(self.t.cmp(&b.t))
    }
}
impl Ord for SerializedHash {
    fn cmp(&self, b: &Self) -> Ordering {
        match self.t.cmp(&b.t) {
            Ordering::Equal => {
                if self.t == HashAlgorithm::Blake3 as u8 {
                    unsafe { self.h.blake3.cmp(&b.h.blake3) }
                } else {
                    Ordering::Equal
                }
            }
            o => o
        }
    }
}
impl PartialEq for SerializedHash {
    fn eq(&self, b: &Self) -> bool {
        if self.t == HashAlgorithm::Blake3 as u8 && self.t == b.t {
            unsafe { self.h.blake3 == b.h.blake3 }
        } else if self.t == b.t {
            true
        } else {
            false
        }
    }
}
impl Eq for SerializedHash {}
impl std::fmt::Debug for SerializedHash {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        Hash::from(self).fmt(fmt)
    }
}
impl<'a> From<&'a SerializedHash> for Hash {
    fn from(s: &'a SerializedHash) -> Hash {
        if s.t == HashAlgorithm::Blake3 as u8 {
            Hash::Blake3(unsafe { s.h.blake3.clone() })
        } else if s.t == HashAlgorithm::None as u8 {
            Hash::None
        } else {
            panic!("Unknown hash algorithm {:?}", s.t)
        }
    }
}
impl From<SerializedHash> for Hash {
    fn from(s: SerializedHash) -> Hash {
        (&s).into()
    }

Insertion in libpijul/src/pristine/hash.rs at line 232 [18.644439]

[18.648947]


impl From<Hash> for SerializedHash {
    fn from(s: Hash) -> SerializedHash {
        (&s).into()
    }
}
impl<'a> From<&'a Hash> for SerializedHash {
    fn from(s: &'a Hash) -> Self {
        match s {
            Hash::Blake3(s) => SerializedHash {
                t: HashAlgorithm::Blake3 as u8,
                h: H { blake3: s.clone() },
            },
            Hash::None => SerializedHash {
                t: 0,
                h: H { none: () },
            }
        }
    }
}

Insertion in libpijul/src/pristine/edge.rs at line 3 [18.648958]
[18.649061]
[18.649061]
```
use super::L64;
```

Insertion in libpijul/src/pristine/edge.rs at line 79 [18.648958]

[18.650031]

}
/// The target half of an edge in the repository graph.
#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct SerializedEdge([super::L64; 3]);
impl std::fmt::Debug for SerializedEdge {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        let pos = self.dest();
        use super::Base32;
        write!(fmt, "E({:?}, {}[{}], {})", self.flag(), pos.change.to_base32(), (pos.pos.0).0, self.introduced_by().to_base32())
    }
}
impl std::ops::SubAssign<EdgeFlags> for SerializedEdge {
    fn sub_assign(&mut self, e: EdgeFlags) {
        let ref mut f = (self.0)[0];
        f.0 = ((u64::from_le(f.0)) & !((e.bits() as u64) << 56)).to_le()
    }
}
impl SerializedEdge {
    pub fn flag(&self) -> EdgeFlags {
        let f = u64::from_le((self.0)[0].0);
        EdgeFlags::from_bits((f >> 56) as u8).unwrap()
    }
    pub fn dest(&self) -> Position<ChangeId> {
        let pos = u64::from_le((self.0[0]).0);
        Position {
            change: ChangeId((self.0)[1]),
            pos: ChangePosition(L64((pos & 0xffffffffffffff).to_le()))
        }
    }
    pub fn introduced_by(&self) -> ChangeId {
        ChangeId((self.0)[2])
    }
}
impl From<SerializedEdge> for Edge {
    fn from(s: SerializedEdge) -> Edge {
        Edge {
            flag: s.flag(),
            dest: s.dest(),
            introduced_by: s.introduced_by(),
        }
    }
}
impl From<Edge> for SerializedEdge {
    fn from(s: Edge) -> SerializedEdge {
        let pos = u64::from_le((s.dest.pos.0).0);
        assert!(pos < 1 << 56);
        SerializedEdge([
            (((s.flag.bits() as u64) << 56) | pos).into(),
            s.dest.change.0,
            s.introduced_by.0
        ])
    }
}
impl<'a> From<&'a SerializedEdge> for Edge {
    fn from(s: &'a SerializedEdge) -> Edge {
        Edge {
            flag: s.flag(),
            dest: s.dest(),
            introduced_by: s.introduced_by(),
        }
    }
}
impl SerializedEdge {
    pub fn empty(dest: Position<ChangeId>, intro: ChangeId) -> Self {
        SerializedEdge([dest.pos.0, dest.change.0, intro.0])
    }
    pub fn new(flag: EdgeFlags, change: ChangeId, pos: ChangePosition, intro: ChangeId) -> Self {
        let pos = u64::from_le((pos.0).0);
        assert!(pos < 1 <<56);
        SerializedEdge([(pos | ((flag.bits() as u64) << 56)).into(), change.0, intro.0])
    }

Replacement in libpijul/src/pristine/change_id.rs at line 1 [18.666427]
B:BD[18.666483] → [18.666483:666544]
```
use super::Base32;
use byteorder::{ByteOrder, LittleEndian};
```
[18.666427]
[18.666544]
```
use super::{L64, Base32};
```
Replacement in libpijul/src/pristine/change_id.rs at line 5 [18.666427]
B:BD[18.666645] → [18.666645:666675]
```
pub struct ChangeId(pub u64);
```
[18.666645]
[18.666675]
```
pub struct ChangeId(pub super::L64);
```
Replacement in libpijul/src/pristine/change_id.rs at line 14 [18.666427]
B:BD[18.666862] → [22.57572:57616]
```
    pub const ROOT: ChangeId = ChangeId(0);
```
[18.666862]
[18.666913]
```
    pub const ROOT: ChangeId = ChangeId(L64(0));
```
Replacement in libpijul/src/pristine/change_id.rs at line 23 [18.666427]
B:BD[18.667088] → [18.667088:667137]
```
        LittleEndian::write_u64(&mut b, self.0);
```
[18.667088]
[18.667137]
```
        self.0.to_slice_le(&mut b);
```
Replacement in libpijul/src/pristine/change_id.rs at line 40 [18.666427]
∅:D[70.565] → [18.667427:667484]
B:BD[18.667427] → [18.667427:667484]
```
            Some(ChangeId(LittleEndian::read_u64(&dec)))
```
[70.565]
[18.667484]
```
            Some(ChangeId(L64::from_slice_le(&dec)))
```

Replacement in libpijul/src/output/output.rs at line 102 [18.671807]

B:BD[63.9401] → [43.4463:4532]

                txn.get_changeset(txn.changes(&channel), u.0.change)

[63.9401]

[18.675254]

                txn.get_changeset(txn.changes(&channel), &u.0.change)

Replacement in libpijul/src/output/output.rs at line 105 [18.671807]

B:BD[68.767] → [68.767:845]

                        &txn.get_changeset(txn.changes(&channel), v.0.change)

[68.767]

[68.845]

                        &txn.get_changeset(txn.changes(&channel), &v.0.change)

Replacement in libpijul/src/output/output.rs at line 127 [18.671807]

B:BD[21.82312] → [21.82312:82474]

                    if let Some(inode) = txn.get_revinodes(output_item.pos, None)? {
                        Some((inode, txn.get_inodes(inode, None)?.unwrap()))

[21.82312]

[21.82474]

                    if let Some(inode) = txn.get_revinodes(&output_item.pos, None)? {
                        Some((*inode, *txn.get_inodes(inode, None)?.unwrap()))

Replacement in libpijul/src/output/output.rs at line 263 [18.671807]

B:BD[18.680050] → [18.680050:680136]

    let file_id_ = file_id.as_file_id();
    debug!("move_or_create {:?}", file_id_);

[18.680050]

[23.21213]

    debug!("move_or_create {:?}", file_id);

Replacement in libpijul/src/output/output.rs at line 272 [18.671807]

B:BD[18.680552] → [21.83145:83225]

                let parent = txn.get_revtree(inode, None)?.unwrap().to_owned();

[18.680552]

[18.680631]

                let parent = txn.get_revtree(&inode, None)?.unwrap().to_owned();

Replacement in libpijul/src/output/output.rs at line 274 [18.671807]

B:BD[18.680701] → [21.83226:83295]

                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

[18.680701]

[18.680852]

                del_tree_with_rev(txn, &parent, &inode)?;

Replacement in libpijul/src/output/output.rs at line 292 [18.671807]

B:BD[18.681455] → [21.83296:83365]

B:BD[21.83365] → [66.371:448]

                if let Some(inode) = txn.get_tree(file_id_, None)? {
                    crate::fs::rec_delete(txn, file_id.clone(), inode, true)

[18.681455]

[23.21529]

                if let Some(&inode) = txn.get_tree(&file_id, None)? {
                    crate::fs::rec_delete(txn, &file_id, inode, true)

Replacement in libpijul/src/output/output.rs at line 296 [18.671807]

B:BD[18.681620] → [21.83366:83491]

                put_inodes_with_rev(txn, inode, output_item.pos)?;
                put_tree_with_rev(txn, file_id_, inode)?;

[18.681620]

[18.681836]

                put_inodes_with_rev(txn, &inode, &output_item.pos)?;
                put_tree_with_rev(txn, &file_id, &inode)?;

Replacement in libpijul/src/output/output.rs at line 300 [18.671807]

B:BD[18.681867] → [18.681867:681944]

B:BD[18.681944] → [21.83492:83557]

B:BD[21.83557] → [66.449:522]

            debug!("no current name, inserting {:?} {:?}", file_id_, inode);
            if let Some(inode) = txn.get_tree(file_id_, None)? {
                crate::fs::rec_delete(txn, file_id.clone(), inode, true)

[18.681867]

[23.21878]

            debug!("no current name, inserting {:?} {:?}", file_id, inode);
            if let Some(&inode) = txn.get_tree(&file_id, None)? {
                crate::fs::rec_delete(txn, &file_id, inode, true)

Replacement in libpijul/src/output/output.rs at line 305 [18.671807]

B:BD[18.682097] → [21.83558:83675]

            put_inodes_with_rev(txn, inode, output_item.pos)?;
            put_tree_with_rev(txn, file_id_, inode)?;

[18.682097]

[18.682297]

            put_inodes_with_rev(txn, &inode, &output_item.pos)?;
            put_tree_with_rev(txn, &file_id, &inode)?;

Replacement in libpijul/src/output/output.rs at line 310 [18.671807]

B:BD[18.682397] → [21.83676:83737]

B:BD[21.83737] → [43.4765:4834]

        if let Some(inode) = txn.get_tree(file_id_, None)? {
            crate::fs::rec_delete(txn, file_id.clone(), inode, true)

[18.682397]

[43.4834]

        if let Some(&inode) = txn.get_tree(&file_id, None)? {
            crate::fs::rec_delete(txn, &file_id, inode, true)

Replacement in libpijul/src/output/output.rs at line 317 [18.671807]
B:BD[18.682645] → [18.682645:682690]
```
            inode, output_item.pos, file_id_
```
[18.682645]
[18.682690]
```
            inode, output_item.pos, file_id
```

Replacement in libpijul/src/output/output.rs at line 319 [18.671807]

B:BD[18.682701] → [21.83783:83892]

        put_inodes_with_rev(txn, inode, output_item.pos)?;
        put_tree_with_rev(txn, file_id_, inode)?;

[18.682701]

[80.239]

        put_inodes_with_rev(txn, &inode, &output_item.pos)?;
        put_tree_with_rev(txn, &file_id, &inode)?;

Replacement in libpijul/src/output/output.rs at line 326 [18.671807]

B:BD[80.416] → [21.83893:83949]

            txn.put_tree(path_id.as_file_id(), inode)?;

[80.416]

[80.523]

            txn.put_tree(&path_id, &inode)?;

Replacement in libpijul/src/output/output.rs at line 347 [18.671807]

B:BD[18.683557] → [43.4957:5032]

        let dest = txn.find_block(txn.graph(channel), edge.dest).unwrap();

[18.683557]

[18.683622]

        let dest = *txn.find_block(txn.graph(channel), edge.dest()).unwrap();

Replacement in libpijul/src/output/output.rs at line 352 [18.671807]
∅:D[22.58489] → [21.84312:84335]
B:BD[21.84312] → [21.84312:84335]
```
            edge.flag,
```
[22.58489]
[21.84335]
```
            edge.flag(),
```
Replacement in libpijul/src/output/output.rs at line 355 [18.671807]
B:BD[21.84373] → [21.84373:84405]
```
            edge.introduced_by,
```
[21.84373]
[21.84405]
```
            edge.introduced_by(),
```
Replacement in libpijul/src/output/output.rs at line 373 [18.671807]
∅:D[21.84657] → [18.684293:684323]
B:BD[18.684293] → [18.684293:684323]
```
                OwnedPathId {
```
[21.84657]
[18.684323]
```
                &OwnedPathId {
```

Replacement in libpijul/src/output/output.rs at line 375 [18.671807]

B:BD[18.684364] → [18.684364:684421]

                    basename: SmallString::from_str(""),

[18.684364]

[18.684421]

                    basename: SmallString::new(),

Replacement in libpijul/src/output/output.rs at line 386 [18.671807]

B:BD[18.684700] → [21.84715:84789]

                    if let Some(vertex) = txn.get_inodes(inode_, None)? {

[18.684700]

[18.684773]

                    if let Some(vertex) = txn.get_inodes(&inode_, None)? {

Replacement in libpijul/src/output/output.rs at line 388 [18.671807]

B:BD[18.684832] → [21.84790:84869]

                            && !is_alive(txn, channel, vertex.inode_vertex())?

[18.684832]

[18.684909]

                            && !is_alive(txn, channel, &vertex.inode_vertex())?

Replacement in libpijul/src/output/output.rs at line 394 [18.671807]

B:BD[18.685037] → [21.84870:84958]

                    dead.insert(id.to_owned(), (inode_, inode_filename(txn, inode_)?));

[18.685037]

[18.685124]

                    dead.insert(id.to_owned(), (*inode_, inode_filename(txn, *inode_)?));

Replacement in libpijul/src/output/output.rs at line 396 [18.671807]

B:BD[18.685142] → [18.685142:685235]

                if inode_ != inode {
                    next_inodes.push((inode_, is_dead))

[18.685142]

[18.685235]

                if *inode_ != inode {
                    next_inodes.push((*inode_, is_dead))

Replacement in libpijul/src/output/output.rs at line 413 [18.671807]

B:BD[18.685693] → [21.85108:85232]

        del_tree_with_rev(txn, fileid.as_file_id(), *inode)?;
        if let Some(vertex) = txn.get_inodes(*inode, None)? {

[18.685693]

[60.2704]

        del_tree_with_rev(txn, &fileid, inode)?;
        for i in txn.iter_inodes().unwrap() {
            debug!("inodes = {:?}", i);
        }
        if let Some(&vertex) = txn.get_inodes(inode, None)? {

Replacement in libpijul/src/output/output.rs at line 421 [18.671807]

B:BD[60.2768] → [21.85233:85288]

            del_inodes_with_rev(txn, *inode, vertex)?;

[60.2768]

[10.0]

            del_inodes_with_rev(txn, inode, &vertex)?;

Replacement in libpijul/src/output/mod.rs at line 121 [18.686190]

B:BD[21.86385] → [22.58490:58558]

        let name_vertex = txn.find_block(channel, e.dest).unwrap();

[21.86385]

[18.687480]

        let name_vertex = txn.find_block(channel, e.dest()).unwrap();

Replacement in libpijul/src/output/mod.rs at line 124 [18.686190]

B:BD[23.24856] → [21.86455:86543]

            .get_contents(|h| txn.get_external(h).unwrap(), name_vertex, &mut name_buf)

[23.24856]

[21.86543]

            .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name_vertex, &mut name_buf)

Replacement in libpijul/src/output/mod.rs at line 143 [18.686190]
∅:D[21.86622] → [27.56429:56454]
B:BD[27.56429] → [27.56429:56454]
```
            name_vertex,
```
[21.86622]
[27.56454]
```
            *name_vertex,
```
Replacement in libpijul/src/output/mod.rs at line 155 [18.686190]
∅:D[21.86750] → [18.688445:688474]
B:BD[18.688445] → [18.688445:688474]
```
                name_vertex,
```
[21.86750]
[18.688474]
```
                *name_vertex,
```

Replacement in libpijul/src/output/mod.rs at line 160 [18.686190]

B:BD[21.86796] → [21.86796:86853]

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

[21.86796]

[21.86853]

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

Replacement in libpijul/src/output/mod.rs at line 167 [18.686190]

B:BD[18.688970] → [21.86984:87069]

            debug_root(txn, channel, e.dest.inode_vertex(), &mut f, false).unwrap();

[18.688970]

[18.689072]

            debug_root(txn, channel, e.dest().inode_vertex(), &mut f, false).unwrap();

Replacement in libpijul/src/output/mod.rs at line 174 [18.686190]
B:BD[18.689426] → [18.689426:689451]
```
            name_vertex,
```
[18.689426]
[18.689451]
```
            *name_vertex,
```

Replacement in libpijul/src/output/mod.rs at line 179 [18.686190]

B:BD[18.689576] → [18.689576:689609]

B:BD[18.689609] → [21.87070:87135]

                pos: child.dest,
                is_zombie: is_zombie(txn, channel, child.dest)?,

[18.689576]

[18.689709]

                pos: child.dest(),
                is_zombie: is_zombie(txn, channel, child.dest())?,

Replacement in libpijul/src/output/archive.rs at line 170 [18.690044]

B:BD[18.693132] → [43.5063:5132]

                txn.get_changeset(txn.changes(&channel), u.0.change)

[18.693132]

[18.693202]

                txn.get_changeset(txn.changes(&channel), &u.0.change)

Replacement in libpijul/src/output/archive.rs at line 173 [18.690044]

B:BD[68.933] → [68.933:1011]

                        &txn.get_changeset(txn.changes(&channel), v.0.change)

[68.933]

[68.1011]

                        &txn.get_changeset(txn.changes(&channel), &v.0.change)

Replacement in libpijul/src/output/archive.rs at line 210 [18.690044]

B:BD[81.40] → [81.40:122]

                    crate::fs::get_latest_touch(txn, &channel, output_item.pos)?;

[81.40]

[81.122]

                    crate::fs::get_latest_touch(txn, &channel, &output_item.pos)?;

Replacement in libpijul/src/output/archive.rs at line 212 [18.690044]

B:BD[81.159] → [81.159:311]

                    let ext = txn.get_external(latest_touch)?.unwrap();
                    let c = changes.get_header(&ext).map_err(ArchiveError::P)?;

[81.159]

[81.311]

                    let ext = txn.get_external(&latest_touch)?.unwrap();
                    let c = changes.get_header(&ext.into()).map_err(ArchiveError::P)?;

Replacement in libpijul/src/missing_context.rs at line 39 [18.696460]

B:BD[18.697186] → [21.88844:88921]

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

[18.697186]

[18.697262]

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

Replacement in libpijul/src/missing_context.rs at line 169 [18.696460]

B:BD[18.703817] → [22.58891:59073]

    let source = txn.find_block_end(&channel, internal_pos(txn, &e.from, change_id)?)?;
    let target = txn.find_block(&channel, internal_pos(txn, &e.to.start_pos(), change_id)?)?;

[18.703817]

[21.89690]

    let source = *txn.find_block_end(&channel, internal_pos(txn, &e.from, change_id)?)?;
    let target = *txn.find_block(&channel, internal_pos(txn, &e.to.start_pos(), change_id)?)?;

Replacement in libpijul/src/missing_context.rs at line 179 [18.696460]
B:BD[9.607] → [9.607:655]
```
    } else if is_alive(txn, channel, source)? {
```
[9.607]
[9.655]
```
    } else if is_alive(txn, channel, &source)? {
```
Replacement in libpijul/src/missing_context.rs at line 196 [18.696460]
∅:D[21.89963] → [63.11602:11668]
B:BD[63.11602] → [63.11602:11668]
```
        if v.dest.change.is_root() || v.introduced_by.is_root() {
```
[21.89963]
[18.704390]
```
        if v.dest().change.is_root() || v.introduced_by().is_root() {
```
Replacement in libpijul/src/missing_context.rs at line 199 [18.696460]
B:BD[18.704422] → [63.11669:11711]
```
        if v.introduced_by == change_id {
```
[18.704422]
[63.11711]
```
        if v.introduced_by() == change_id {
```

Replacement in libpijul/src/missing_context.rs at line 205 [18.696460]

B:BD[63.11822] → [22.59074:59136]

        unknown.insert(txn.find_block_end(channel, v.dest)?);

[63.11822]

[18.704732]

        unknown.insert(*txn.find_block_end(channel, v.dest())?);

Replacement in libpijul/src/missing_context.rs at line 226 [18.696460]
∅:D[21.90411] → [63.12569:12635]
B:BD[63.12569] → [63.12569:12635]
```
        if v.dest.change.is_root() || v.introduced_by.is_root() {
```
[21.90411]
[63.12635]
```
        if v.dest().change.is_root() || v.introduced_by().is_root() {
```

Replacement in libpijul/src/missing_context.rs at line 229 [18.696460]

B:BD[63.12667] → [21.90412:90508]

        if v.introduced_by == change_id || known(txn.get_external(v.introduced_by)?.unwrap()) {

[63.12667]

[63.12762]

        if v.introduced_by() == change_id || known(txn.get_external(&v.introduced_by())?.unwrap().into()) {

Replacement in libpijul/src/missing_context.rs at line 258 [18.696460]

B:BD[27.58025] → [22.59137:59201]

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

[27.58025]

[18.706347]

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

Replacement in libpijul/src/missing_context.rs at line 278 [18.696460]

B:BD[18.706882] → [18.706882:706977]

    unknown: Vec<Edge>,
    parents: HashSet<Edge>,
    pseudo: Vec<(Vertex<ChangeId>, Edge)>,

[18.706882]

[82.106]

    unknown: Vec<SerializedEdge>,
    parents: HashSet<SerializedEdge>,
    pseudo: Vec<(Vertex<ChangeId>, SerializedEdge)>,

Replacement in libpijul/src/missing_context.rs at line 359 [18.696460]
∅:D[27.58322] → [18.708450:708519]
B:BD[18.708450] → [18.708450:708519]
```
        if v.introduced_by == change_id || v.dest.change.is_root() {
```
[27.58322]
[18.708519]
```
        if v.introduced_by() == change_id || v.dest().change.is_root() {
```

Replacement in libpijul/src/missing_context.rs at line 362 [18.696460]

B:BD[18.708551] → [18.708551:708636]

        if v.introduced_by.is_root() {
            ws.pseudo.push((dest_vertex, v));

[18.708551]

[18.708636]

        if v.introduced_by().is_root() {
            ws.pseudo.push((dest_vertex, *v));

Replacement in libpijul/src/missing_context.rs at line 375 [18.696460]

B:BD[21.91109] → [21.91109:91161]

            if e.introduced_by == v.introduced_by {

[21.91109]

[21.91161]

            if e.introduced_by() == v.introduced_by() {

Replacement in libpijul/src/missing_context.rs at line 381 [18.696460]

B:BD[21.91282] → [21.91282:91351]

            let intro = txn.get_external(v.introduced_by)?.unwrap();

[21.91282]

[18.709229]

            let intro = txn.get_external(&v.introduced_by())?.unwrap().into();

Replacement in libpijul/src/missing_context.rs at line 383 [18.696460]
B:BD[18.709260] → [18.709260:709296]
```
                ws.unknown.push(v);
```
[18.709260]
[18.709296]
```
                ws.unknown.push(*v);
```

Replacement in libpijul/src/missing_context.rs at line 407 [18.696460]

B:BD[18.710088] → [22.59202:59255]

∅:D[22.59255] → [63.14504:14561]

B:BD[27.58613] → [63.14504:14561]

        let p = txn.find_block(channel, edge.dest)?;
        assert!(!edge.flag.contains(EdgeFlags::FOLDER));

[18.710088]

[63.14561]

        let p = *txn.find_block(channel, edge.dest())?;
        assert!(!edge.flag().contains(EdgeFlags::FOLDER));

Replacement in libpijul/src/missing_context.rs at line 412 [18.696460]

B:BD[63.14730] → [22.59256:59321]

        while let Ok(v) = txn.find_block(channel, u.end_pos()) {

[63.14730]

[63.14796]

        while let Ok(&v) = txn.find_block(channel, u.end_pos()) {

Replacement in libpijul/src/missing_context.rs at line 421 [18.696460]
B:BD[18.711106] → [21.91751:91791]
```
        if is_alive(txn, channel, p)? {
```
[18.711106]
[63.15084]
```
        if is_alive(txn, channel, &p)? {
```

Replacement in libpijul/src/missing_context.rs at line 442 [18.696460]

B:BD[18.712042] → [21.91922:92012]

∅:D[82.341] → [18.712091:712143]

∅:D[27.58942] → [18.712091:712143]

∅:D[21.92012] → [18.712091:712143]

B:BD[18.712091] → [18.712091:712143]

B:BD[18.712143] → [22.59322:59384]

∅:D[22.59384] → [21.92013:92062]

B:BD[27.59006] → [21.92013:92062]

        if !is_alive(txn, channel, dest_vertex)? && !ws.repaired.contains(&dest_vertex) {
            if e.flag.contains(EdgeFlags::PARENT) {
                let p = txn.find_block_end(channel, e.dest)?;
                if !is_alive(txn, channel, p)? {

[18.712042]

[27.59054]

        if !is_alive(txn, channel, &dest_vertex)? && !ws.repaired.contains(&dest_vertex) {
            if e.flag().contains(EdgeFlags::PARENT) {
                let p = *txn.find_block_end(channel, e.dest())?;
                if !is_alive(txn, channel, &p)? {

Replacement in libpijul/src/missing_context.rs at line 447 [18.696460]

B:BD[27.59118] → [63.15333:15382]

B:BD[63.15382] → [21.92063:92159]

                    e.flag -= EdgeFlags::PARENT;
                    del_graph_with_rev(txn, channel, e.flag, p, dest_vertex, e.introduced_by)?;

[27.59118]

[18.712510]

                    e -= EdgeFlags::PARENT;
                    del_graph_with_rev(txn, channel, e.flag(), p, dest_vertex, e.introduced_by())?;

Replacement in libpijul/src/missing_context.rs at line 451 [18.696460]

B:BD[18.712549] → [22.59385:59443]

∅:D[22.59443] → [21.92160:92209]

B:BD[27.59247] → [21.92160:92209]

                let p = txn.find_block(channel, e.dest)?;
                if !is_alive(txn, channel, p)? {

[18.712549]

[27.59295]

                let p = *txn.find_block(channel, e.dest())?;
                if !is_alive(txn, channel, &p)? {

Replacement in libpijul/src/missing_context.rs at line 454 [18.696460]

B:BD[27.59363] → [21.92210:92306]

                    del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)?;

[27.59363]

[18.712749]

                    del_graph_with_rev(txn, channel, e.flag(), dest_vertex, p, e.introduced_by())?;

Replacement in libpijul/src/missing_context.rs at line 480 [18.696460]

B:BD[18.713358] → [22.59444:59508]

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

[18.713358]

[27.59660]

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

Replacement in libpijul/src/missing_context.rs at line 490 [18.696460]

∅:D[21.92478] → [18.713599:713672]

B:BD[18.713599] → [18.713599:713672]

            if v.introduced_by == change_id || v.dest.change.is_root() {

[21.92478]

[18.713672]

            if v.introduced_by() == change_id || v.dest().change.is_root() {

Replacement in libpijul/src/missing_context.rs at line 493 [18.696460]

B:BD[18.713712] → [18.713712:713805]

            if v.introduced_by.is_root() {
                ws.pseudo.push((dest_vertex, v));

[18.713712]

[18.713805]

            if v.introduced_by().is_root() {
                ws.pseudo.push((dest_vertex, *v));

Replacement in libpijul/src/missing_context.rs at line 497 [18.696460]
B:BD[18.713845] → [18.713845:713897]
```
            if v.flag.contains(EdgeFlags::PARENT) {
```
[18.713845]
[18.713897]
```
            if v.flag().contains(EdgeFlags::PARENT) {
```

Replacement in libpijul/src/missing_context.rs at line 499 [18.696460]

B:BD[18.713956] → [21.92479:92552]

                let intro = txn.get_external(v.introduced_by)?.unwrap();

[18.713956]

[18.714028]

                let intro = txn.get_external(&v.introduced_by())?.unwrap().into();

Replacement in libpijul/src/missing_context.rs at line 502 [18.696460]
∅:D[27.59819] → [18.714063:714122]
B:BD[18.714063] → [18.714063:714122]
```
                    unknown_parents.push((dest_vertex, v))
```
[27.59819]
[18.714122]
```
                    unknown_parents.push((dest_vertex, *v))
```
Replacement in libpijul/src/missing_context.rs at line 523 [18.696460]
B:BD[18.714567] → [18.714567:714609]
```
    unknown: &[(Vertex<ChangeId>, Edge)],
```
[18.714567]
[21.92612]
```
    unknown: &[(Vertex<ChangeId>, SerializedEdge)],
```

Replacement in libpijul/src/missing_context.rs at line 526 [18.696460]

B:BD[18.714691] → [22.59509:59566]

∅:D[22.59566] → [18.714748:714817]

∅:D[27.59878] → [18.714748:714817]

B:BD[18.714748] → [18.714748:714817]

        let p = txn.find_block_end(channel, edge.dest)?;
        ws.unknown_parents.push((dest_vertex, p, inode, edge.flag));

[18.714691]

[18.715147]

        let p = *txn.find_block_end(channel, edge.dest())?;
        ws.unknown_parents.push((dest_vertex, p, inode, edge.flag()));

Replacement in libpijul/src/missing_context.rs at line 531 [18.696460]

B:BD[18.715461] → [22.59567:59638]

        while let Ok(u) = txn.find_block_end(channel, v.start_pos()) {

[18.715461]

[18.715532]

        while let Ok(&u) = txn.find_block_end(channel, v.start_pos()) {

Replacement in libpijul/src/missing_context.rs at line 556 [18.696460]

∅:D[21.92728] → [18.716150:716251]

B:BD[18.716150] → [18.716150:716251]

            if !parent.flag.contains(EdgeFlags::PSEUDO) {
                ws.parents.insert(parent);

[21.92728]

[18.716251]

            if !parent.flag().contains(EdgeFlags::PSEUDO) {
                ws.parents.insert(*parent);

Replacement in libpijul/src/missing_context.rs at line 562 [18.696460]

B:BD[18.716367] → [22.59639:59712]

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

[18.716367]

[18.716440]

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

Replacement in libpijul/src/missing_context.rs at line 564 [18.696460]

B:BD[18.716506] → [18.716506:716563]

            if parent.flag.contains(EdgeFlags::FOLDER) {

[18.716506]

[18.716563]

            if parent.flag().contains(EdgeFlags::FOLDER) {

Replacement in libpijul/src/lib.rs at line 114 [18.717381]
B:BD[18.720722] → [18.720722:720759]
```
        hash: crate::pristine::Hash,
```
[18.720722]
[18.720759]
```
        hash: &crate::pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 124 [18.717381]
B:BD[18.721090] → [18.721090:721127]
```
        hash: crate::pristine::Hash,
```
[18.721090]
[18.721127]
```
        hash: &crate::pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 134 [18.717381]
B:BD[18.721441] → [18.721441:721471]
```
        hash: pristine::Hash,
```
[18.721441]
[21.93292]
```
        hash: &pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 143 [18.717381]
B:BD[18.721745] → [18.721745:721775]
```
        hash: pristine::Hash,
```
[18.721745]
[21.93390]
```
        hash: &pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 152 [18.717381]
B:BD[18.722037] → [18.722037:722067]
```
        hash: pristine::Hash,
```
[18.722037]
[21.93467]
```
        hash: &pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 161 [18.717381]
B:BD[18.722318] → [18.722318:722348]
```
        hash: pristine::Hash,
```
[18.722318]
[18.722348]
```
        hash: &pristine::Hash,
```
Replacement in libpijul/src/lib.rs at line 172 [18.717381]
B:BD[18.722748] → [18.722748:722778]
```
        hash: pristine::Hash,
```
[18.722748]
[18.722778]
```
        hash: &pristine::Hash,
```

Replacement in libpijul/src/lib.rs at line 255 [18.717381]

∅:D[23.28705] → [69.380:468]

B:BD[18.725076] → [69.380:468]

        apply::apply_local_change(self, channel, &change, hash, &recorded.updatables)?;

[23.28705]

[18.725172]

        apply::apply_local_change(self, channel, &change, &hash, &recorded.updatables)?;

Replacement in libpijul/src/lib.rs at line 318 [18.717381]
B:BD[18.727232] → [18.727232:727233]
[18.727232]
[18.727233]
```
    /*
```
Replacement in libpijul/src/lib.rs at line 336 [18.717381]
B:BD[18.727756] → [18.727756:727757]
[18.727756]
[83.2901]
```
    */
```
Replacement in libpijul/src/lib.rs at line 341 [18.717381]
B:BD[18.727919] → [18.727919:727952]
```
        state: pristine::Merkle,
```
[18.727919]
[18.727952]
```
        state: &pristine::Merkle,
```
Replacement in libpijul/src/lib.rs at line 368 [18.717381]
B:BD[18.728644] → [18.728644:728677]
```
        state: pristine::Merkle,
```
[18.728644]
[18.728677]
```
        state: &pristine::Merkle,
```
Replacement in libpijul/src/lib.rs at line 377 [18.717381]
B:BD[21.95647] → [21.95647:95681]
∅:D[27.60532] → [18.728959:728987]
∅:D[21.95681] → [18.728959:728987]
B:BD[18.728959] → [18.728959:728987]
```
            let (_, (h, m)) = x?;
            if m == state {
```
[21.95647]
[18.728987]
```
            let (_, p) = x?;
            let m: Merkle = (&p.b).into();
            if &m == state {
```
Replacement in libpijul/src/lib.rs at line 383 [18.717381]
B:BD[18.729061] → [18.729061:729094]
```
                unrecord.push(h)
```
[18.729061]
[18.729094]
```
                unrecord.push(p.a.into())
```

Replacement in libpijul/src/lib.rs at line 388 [18.717381]

B:BD[18.729182] → [18.729182:729224]

B:BD[18.729224] → [21.95682:95738]

            for h in unrecord.drain(..) {
                let h = self.get_external(h)?.unwrap();

[18.729182]

[18.729279]

            for h in unrecord.iter() {
                let h = self.get_external(h)?.unwrap().into();

Replacement in libpijul/src/lib.rs at line 393 [18.717381]

B:BD[18.729385] → [18.729385:729448]

                self.apply_change_rec(changes, channel, *app)?

[18.729385]

[18.729448]

                self.apply_change_rec(changes, channel, app)?

Replacement in libpijul/src/lib.rs at line 397 [18.717381]

B:BD[18.729545] → [23.29936:29999]

            Err(output::ArchiveError::StateNotFound { state })

[18.729545]

[18.729602]

            Err(output::ArchiveError::StateNotFound { state: *state })

Replacement in libpijul/src/lib.rs at line 418 [18.717381]
B:BD[18.730078] → [18.730078:730108]
```
        hash: pristine::Hash,
```
[18.730078]
[21.96006]
```
        hash: &pristine::Hash,
```

Replacement in libpijul/src/lib.rs at line 420 [18.717381]

B:BD[21.96055] → [21.96055:96148]

        if let Some(cid) = pristine::GraphTxnT::get_internal(self, hash).map_err(|e| e.0)? {

[21.96055]

[43.5370]

        if let Some(cid) = pristine::GraphTxnT::get_internal(self, &hash.into()).map_err(|e| e.0)? {

Insertion in libpijul/src/lib.rs at line 423 [18.717381]
[21.96251]
[21.96251]
```
                .map(|x| x.map(|x| u64::from_le(x.0)))
```
Replacement in libpijul/src/lib.rs at line 432 [18.717381]
∅:D[22.59979] → [27.60694:60743]
B:BD[27.60694] → [27.60694:60743]
```
        a: pristine::Vertex<pristine::ChangeId>,
```
[22.59979]
[21.96300]
```
        a: &pristine::Vertex<pristine::ChangeId>,
```

Replacement in libpijul/src/lib.rs at line 448 [18.717381]

B:BD[18.730514] → [21.96682:96763]

            iter: pristine::changeid_log(self, channel, from).map_err(|e| e.0)?,

[18.730514]

[21.96763]

            iter: pristine::changeid_log(self, channel, pristine::L64(from.to_le()))
                .map_err(|e| e.0)?,

Replacement in libpijul/src/lib.rs at line 478 [18.717381]

B:BD[18.730788] → [21.97174:97259]

            iter: pristine::changeid_rev_log(self, channel, from).map_err(|e| e.0)?,

[18.730788]

[21.97259]

            iter: pristine::changeid_rev_log(self, channel, from.map(|x| pristine::L64(x.to_le())))
                .map_err(|e| e.0)?,

Replacement in libpijul/src/lib.rs at line 486 [18.717381]
∅:D[22.60363] → [27.61799:61826]
B:BD[27.61799] → [27.61799:61826]
```
        from: Option<u64>,
```
[22.60363]
[21.97271]
```
        from: Option<pristine::L64>,
```

Replacement in libpijul/src/lib.rs at line 492 [18.717381]

B:BD[21.97397] → [21.97397:97466]

            u64,
            (pristine::ChangeId, pristine::Merkle),

[21.97397]

[21.97466]

            pristine::L64,
            pristine::Pair<pristine::ChangeId, pristine::SerializedMerkle>,

Replacement in libpijul/src/lib.rs at line 505 [18.717381]

B:BD[21.97658] → [21.97658:97693]

B:BD[21.97693] → [43.5515:5585]

        if let Some((h, m)) = self
            .get_revchangeset(self.rev_changes(&channel.borrow()), n)

[21.97658]

[21.97762]

        if let Some(p) = self
            .get_revchangeset(
                self.rev_changes(&channel.borrow()),
                &pristine::L64(n.to_le()),
            )

Replacement in libpijul/src/lib.rs at line 512 [18.717381]

B:BD[21.97803] → [21.97803:97878]

            Ok(Some((self.get_external(h).map_err(|e| e.0)?.unwrap(), m)))

[21.97803]

[21.97878]

            Ok(Some((
                self.get_external(&p.a.into())
                    .map_err(|e| e.0)?
                    .unwrap()
                    .into(),
                (&p.b).into(),
            )))

Replacement in libpijul/src/lib.rs at line 527 [18.717381]
B:BD[18.731234] → [18.731234:731261]
```
        h: pristine::Hash,
```
[18.731234]
[21.97927]
```
        h: &pristine::Hash,
```

Replacement in libpijul/src/lib.rs at line 529 [18.717381]

B:BD[21.97976] → [21.97976:98064]

        if let Some(h) = pristine::GraphTxnT::get_internal(self, h).map_err(|e| e.0)? {

[21.97976]

[43.5586]

        if let Some(h) = pristine::GraphTxnT::get_internal(self, &h.into()).map_err(|e| e.0)? {

Insertion in libpijul/src/lib.rs at line 532 [18.717381]
[21.98099]
[18.731399]
```
                .map(|x| x.map(|x| u64::from_le(x.0)))
```

Replacement in libpijul/src/lib.rs at line 538 [18.717381]

B:BD[18.731450] → [21.98122:98310]

    fn touched_files(&self, h: pristine::Hash) -> Result<Option<Touched<Self>>, Self::DepsError> {
        if let Some(id) = pristine::GraphTxnT::get_internal(self, h).map_err(|e| e.0)? {

[18.731450]

[21.98310]

    fn touched_files(&self, h: &pristine::Hash) -> Result<Option<Touched<Self>>, Self::DepsError> {
        if let Some(id) = pristine::GraphTxnT::get_internal(self, &h.into()).map_err(|e| e.0)? {

Replacement in libpijul/src/lib.rs at line 543 [18.717381]
∅:D[21.98420] → [18.731705:731725]
B:BD[18.731705] → [18.731705:731725]
```
                id,
```
[21.98420]
[21.98421]
```
                id: *id,
```

Replacement in libpijul/src/lib.rs at line 554 [18.717381]

B:BD[18.731927] → [18.731927:731981]

        position: pristine::Position<pristine::Hash>,

[18.731927]

[21.98460]

        position: &pristine::Position<pristine::Hash>,

Replacement in libpijul/src/lib.rs at line 557 [18.717381]

B:BD[18.732074] → [21.98542:98630]

            change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),

[18.732074]

[18.732139]

            change: *pristine::GraphTxnT::get_internal(self, &position.change.into())?.unwrap(),

Replacement in libpijul/src/lib.rs at line 570 [18.717381]

B:BD[18.732546] → [21.98713:98801]

            change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),

[18.732546]

[18.732611]

            change: *pristine::GraphTxnT::get_internal(self, &position.change.into())?.unwrap(),

Replacement in libpijul/src/lib.rs at line 640 [18.717381]

B:BD[18.734365] → [18.734365:734426]

        u64,
        (pristine::ChangeId, pristine::Merkle),

[18.734365]

[18.734426]

        pristine::L64,
        pristine::Pair<pristine::ChangeId, pristine::SerializedMerkle>,

Replacement in libpijul/src/lib.rs at line 646 [18.717381]

B:BD[21.99689] → [21.99689:99771]

    type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;

[21.99689]

[18.734553]

    type Item = Result<(u64, (&'txn pristine::SerializedHash, &'txn pristine::SerializedMerkle)), T::GraphError>;

Replacement in libpijul/src/lib.rs at line 649 [18.717381]

B:BD[21.99805] → [21.99805:99903]

            Some(Ok((n, (c, m)))) => {
                let ext = match self.txn.get_external(c) {

[21.99805]

[21.99903]

            Some(Ok((n, p))) => {
                let ext = match self.txn.get_external(&p.a) {

Replacement in libpijul/src/lib.rs at line 653 [18.717381]

B:BD[21.100014] → [21.100014:100080]

                    Ok(None) => panic!("Unknown change {:?}", c),

[21.100014]

[21.100080]

                    Ok(None) => panic!("Unknown change {:?}", p),

Replacement in libpijul/src/lib.rs at line 655 [18.717381]

B:BD[21.100099] → [21.100099:100139]

                Some(Ok((n, (ext, m))))

[21.100099]

[21.100139]

                Some(Ok((u64::from_le(n.0), (ext, &p.b))))

Replacement in libpijul/src/lib.rs at line 669 [18.717381]

B:BD[18.734876] → [18.734876:734937]

        u64,
        (pristine::ChangeId, pristine::Merkle),

[18.734876]

[18.734937]

        pristine::L64,
        pristine::Pair<pristine::ChangeId, pristine::SerializedMerkle>,

Replacement in libpijul/src/lib.rs at line 675 [18.717381]

B:BD[21.100355] → [21.100355:100437]

    type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;

[21.100355]

[18.735067]

    type Item = Result<(u64, (&'txn pristine::SerializedHash, &'txn pristine::SerializedMerkle)), T::GraphError>;

Replacement in libpijul/src/lib.rs at line 678 [18.717381]

B:BD[21.100471] → [21.100471:100599]

            Some(Ok((n, (c, m)))) => match self.txn.get_external(c) {
                Ok(Some(ext)) => Some(Ok((n, (ext, m)))),

[21.100471]

[21.100599]

            Some(Ok((n, p))) => match self.txn.get_external(&p.a.into()) {
                Ok(Some(ext)) => Some(Ok((u64::from_le(n.0), (ext, &p.b)))),

Replacement in libpijul/src/lib.rs at line 681 [18.717381]

B:BD[21.100641] → [21.100641:100703]

                Ok(None) => panic!("Unknown change {:?}", c),

[21.100641]

[21.100703]

                Ok(None) => panic!("Unknown change {:?}", p),

Replacement in libpijul/src/lib.rs at line 713 [18.717381]
∅:D[21.101266] → [18.735725:735756]
B:BD[18.735725] → [18.735725:735756]
```
            if cid > self.id {
```
[21.101266]
[18.735756]
```
            if *cid > self.id {
```

Replacement in libpijul/src/lib.rs at line 715 [18.717381]

B:BD[18.735785] → [18.735785:735824]

B:BD[18.735824] → [21.101267:101339]

            } else if cid == self.id {
                let change = match self.txn.get_external(file.change) {

[18.735785]

[21.101339]

            } else if *cid == self.id {
                let change = match self.txn.get_external(&file.change) {

Replacement in libpijul/src/lib.rs at line 721 [18.717381]
∅:D[21.101508] → [18.735947:735975]
B:BD[18.735947] → [18.735947:735975]
```
                    change,
```
[21.101508]
[18.735975]
```
                    change: change.into(),
```

Replacement in libpijul/src/fs.rs at line 66 [18.737429]

B:BD[18.738741] → [21.102390:102455]

        already_taken = txn.get_revtree(inode, None)?.is_some();

[18.738741]

[18.738805]

        already_taken = txn.get_revtree(&inode, None)?.is_some();

Replacement in libpijul/src/fs.rs at line 77 [18.737429]

B:BD[18.739078] → [18.739078:739183]

B:BD[18.739183] → [21.102594:102646]

    let pathid = OwnedPathId {
        parent_inode: inode,
        basename: SmallString::new(),
    };
    for x in txn.iter_tree(pathid.clone(), None)? {

[18.739078]

[21.102646]

    for x in txn.iter_tree(&OwnedPathId::inode(inode), None)? {

Replacement in libpijul/src/fs.rs at line 79 [18.737429]
∅:D[21.102673] → [18.739241:739267]
B:BD[18.739241] → [18.739241:739267]
```
        if pid < pathid {
```
[21.102673]
[18.739267]
```
        if pid.parent_inode < inode {
```
Replacement in libpijul/src/fs.rs at line 81 [18.737429]
B:BD[18.739289] → [18.739289:739322]
```
        } else if pid > pathid {
```
[18.739289]
[18.739322]
```
        } else if pid.parent_inode > inode {
```

Replacement in libpijul/src/fs.rs at line 94 [18.737429]

B:BD[18.739651] → [18.739651:739766]

    let mut fileid = OwnedPathId {
        parent_inode: Inode::ROOT,
        basename: SmallString::new(),
    };

[18.739651]

[18.739766]

    let mut fileid = OwnedPathId::inode(Inode::ROOT);

Replacement in libpijul/src/fs.rs at line 100 [18.737429]

B:BD[18.739962] → [21.102858:102914]

        for x in txn.iter_tree(fileid.clone(), None)? {

[18.739962]

[21.102914]

        for x in txn.iter_tree(&fileid, None)? {

Replacement in libpijul/src/fs.rs at line 106 [18.737429]
B:BD[18.740145] → [84.3251:3279]
```
                id > fileid
```
[18.740145]
[18.740177]
```
                id > &fileid
```
Replacement in libpijul/src/fs.rs at line 108 [18.737429]
B:BD[18.740192] → [18.740192:740221]
```
            if id > fileid {
```
[18.740192]
[18.740221]
```
            if id > &fileid {
```
Replacement in libpijul/src/fs.rs at line 110 [18.737429]
B:BD[18.740244] → [18.740244:740280]
```
            } else if id < fileid {
```
[18.740244]
[18.740280]
```
            } else if id < &fileid {
```
Replacement in libpijul/src/fs.rs at line 114 [18.737429]
B:BD[18.740429] → [84.3280:3321]
```
            fileid.parent_inode = inode;
```
[18.740429]
[84.3321]
```
            fileid.parent_inode = *inode;
```
Replacement in libpijul/src/fs.rs at line 155 [18.737429]
B:BD[18.741768] → [21.103574:103622]
```
        match txn.get_revtree(current, None)? {
```
[18.741768]
[18.741815]
```
        match txn.get_revtree(&current, None)? {
```

Replacement in libpijul/src/fs.rs at line 157 [18.737429]

B:BD[18.741840] → [18.741840:741885]

                components.push(v.basename);

[18.741840]

[69.469]

                components.push(v.basename.to_owned());

Replacement in libpijul/src/fs.rs at line 194 [18.737429]

B:BD[85.15] → [21.103758:103829]

    if let Some(inode) = txn.get_tree(parent_id.as_file_id(), None)? {

[85.15]

[18.743052]

    if let Some(&inode) = txn.get_tree(&parent_id, None)? {

Replacement in libpijul/src/fs.rs at line 201 [18.737429]

B:BD[18.743256] → [21.103830:104033]

                del_tree_with_rev(txn, parent_id.as_file_id(), inode)?;
                if let Some(vertex) = txn.get_inodes(inode, None)? {
                    del_inodes_with_rev(txn, inode, vertex)?;

[18.743256]

[18.743619]

                del_tree_with_rev(txn, &parent_id, &inode)?;
                if let Some(&vertex) = txn.get_inodes(&inode, None)? {
                    del_inodes_with_rev(txn, &inode, &vertex)?;

Replacement in libpijul/src/fs.rs at line 205 [18.737429]

B:BD[18.743637] → [21.104034:104106]

                put_tree_with_rev(txn, parent_id.as_file_id(), child)?;

[18.743637]

[18.743764]

                put_tree_with_rev(txn, &parent_id, &child)?;

Replacement in libpijul/src/fs.rs at line 217 [18.737429]

B:BD[18.744222] → [21.104152:104222]

        put_tree_with_rev(txn, parent_id.as_file_id(), child_inode)?;

[18.744222]

[18.744345]

        put_tree_with_rev(txn, &parent_id, &child_inode)?;

Replacement in libpijul/src/fs.rs at line 224 [18.737429]

B:BD[18.744509] → [21.104223:104284]

            txn.put_tree(dir_id.as_file_id(), child_inode)?;

[18.744509]

[18.744570]

            txn.put_tree(&dir_id, &child_inode)?;

Replacement in libpijul/src/fs.rs at line 272 [18.737429]

B:BD[21.104619] → [21.104619:104688]

    let fileref = txn.get_revtree(inode, None)?.unwrap().to_owned();

[21.104619]

[18.746213]

    let fileref = txn.get_revtree(&inode, None)?.unwrap().to_owned();

Replacement in libpijul/src/fs.rs at line 274 [18.737429]
B:BD[18.746252] → [21.104689:104747]
```
    del_tree_with_rev(txn, fileref.as_file_id(), inode)?;
```
[18.746252]
[18.746499]
```
    del_tree_with_rev(txn, &fileref, &inode)?;
```
Replacement in libpijul/src/fs.rs at line 278 [18.737429]
B:BD[18.746600] → [18.746600:746627]
```
            (OwnedPathId {
```
[18.746600]
[18.746627]
```
            &OwnedPathId {
```
Replacement in libpijul/src/fs.rs at line 281 [18.737429]
B:BD[18.746710] → [18.746710:746752]
```
            })
            .as_file_id(),
```
[18.746710]
[18.746752]
```
            },
```
Replacement in libpijul/src/fs.rs at line 291 [18.737429]
B:BD[18.746978] → [18.746978:747003]
```
    parent: OwnedPathId,
```
[18.746978]
[18.747003]
```
    parent: &PathId,
```
Replacement in libpijul/src/fs.rs at line 301 [18.737429]
B:BD[18.747248] → [21.104845:104898]
```
    for x in txn.iter_tree(file_id.clone(), None)? {
```
[18.747248]
[21.104898]
```
    for x in txn.iter_tree(&file_id, None)? {
```
Insertion in libpijul/src/fs.rs at line 303 [18.737429]
[21.104927]
[18.747309]
```
        assert!(k.parent_inode >= file_id.parent_inode);
```

Deletion in libpijul/src/fs.rs at line 306 [18.737429]

B:BD[18.747379] → [18.747379:747459]

        } else if k.parent_inode < file_id.parent_inode {
            continue;

Replacement in libpijul/src/fs.rs at line 310 [18.737429]
B:BD[18.747528] → [18.747528:747566]
```
            children.push((k, inode))
```
[18.747528]
[18.747566]
```
            children.push((k.to_owned(), *inode))
```

Replacement in libpijul/src/fs.rs at line 315 [18.737429]

B:BD[18.747710] → [66.654:706]

        rec_delete(txn, k, inode_, delete_inodes)?;

[18.747710]

[18.747762]

        rec_delete(txn, &k, inode_, delete_inodes)?;

Replacement in libpijul/src/fs.rs at line 322 [18.737429]

B:BD[86.67] → [21.104928:105014]

        assert!(inode.is_root() || txn.del_tree(file_id.as_file_id(), Some(inode))?);

[86.67]

[18.748177]

        assert!(inode.is_root() || txn.del_tree(&file_id, Some(&inode))?);

Replacement in libpijul/src/fs.rs at line 324 [18.737429]

B:BD[18.748183] → [21.105015:105096]

    if !inode.is_root() && del_tree_with_rev(txn, parent.as_file_id(), inode)? {

[18.748183]

[66.707]

    if !inode.is_root() && del_tree_with_rev(txn, &parent, &inode)? {

Replacement in libpijul/src/fs.rs at line 326 [18.737429]

B:BD[66.734] → [66.734:857]

            if let Some(vertex) = txn.get_inodes(inode, None)? {
                del_inodes_with_rev(txn, inode, vertex)?;

[66.734]

[66.857]

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

Replacement in libpijul/src/fs.rs at line 333 [18.737429]
B:BD[18.748631] → [18.748631:748664]
```
            parent.as_file_id(),
```
[18.748631]
[18.748664]
```
            parent,
```

Replacement in libpijul/src/fs.rs at line 350 [18.737429]

B:BD[87.469] → [21.105312:105370]

        txn.get_revtree(inode, None)?.unwrap().to_owned()

[87.469]

[87.526]

        txn.get_revtree(&inode, None)?.unwrap().to_owned()

Replacement in libpijul/src/fs.rs at line 353 [18.737429]
B:BD[18.749037] → [66.872:916]
```
    rec_delete(txn, parent, inode, false)?;
```
[18.749037]
[18.749081]
```
    rec_delete(txn, &parent, inode, false)?;
```

Replacement in libpijul/src/fs.rs at line 363 [18.737429]

∅:D[21.105423] → [18.749379:749461]

B:BD[18.749379] → [18.749379:749461]

    iter: crate::pristine::Cursor<T, &'txn T, T::TreeCursor, OwnedPathId, Inode>,

[21.105423]

[18.749461]

    iter: crate::pristine::Cursor<T, &'txn T, T::TreeCursor, PathId, Inode>,

Replacement in libpijul/src/fs.rs at line 375 [18.737429]

B:BD[21.105732] → [21.105732:105794]

                            return Some(Ok((k.basename, v)));

[21.105732]

[21.105794]

                            return Some(Ok((k.basename.to_owned(), *v)));

Replacement in libpijul/src/fs.rs at line 396 [18.737429]
B:BD[21.106208] → [21.106208:106238]
```
                OwnedPathId {
```
[21.106208]
[21.106238]
```
                &OwnedPathId {
```

Replacement in libpijul/src/fs.rs at line 425 [18.737429]

B:BD[88.44] → [21.106602:106670]

                let iter = match self.txn.iter_tree(fileid, None) {

[88.44]

[21.106670]

                let iter = match self.txn.iter_tree(&fileid, None) {

Replacement in libpijul/src/fs.rs at line 442 [18.737429]

B:BD[18.751575] → [18.751575:751626]

                        self.stack.push((v, name))

[18.751575]

[18.751626]

                        self.stack.push((*v, name))

Replacement in libpijul/src/fs.rs at line 483 [18.737429]

B:BD[21.107465] → [22.60879:60964]

                    let dest = match self.txn.find_block(self.channel, child.dest) {

[21.107465]

[21.107551]

                    let dest = match self.txn.find_block(self.channel, child.dest()) {

Replacement in libpijul/src/fs.rs at line 491 [18.737429]
B:BD[21.107836] → [21.107836:107866]
```
                        dest,
```
[21.107836]
[26.14405]
```
                        *dest,
```

Replacement in libpijul/src/fs.rs at line 502 [18.737429]

B:BD[21.108163] → [21.108163:108225]

                    if self.visited.insert(grandchild.dest) {

[21.108163]

[21.108225]

                    if self.visited.insert(grandchild.dest()) {

Replacement in libpijul/src/fs.rs at line 506 [18.737429]

B:BD[21.108350] → [21.108350:108410]

                            grandchild.dest.inode_vertex(),

[21.108350]

[21.108410]

                            grandchild.dest().inode_vertex(),

Replacement in libpijul/src/fs.rs at line 514 [18.737429]

B:BD[21.108741] → [21.108741:108795]

                    return Some(Ok(grandchild.dest));

[21.108741]

[26.14553]

                    return Some(Ok(grandchild.dest()));

Replacement in libpijul/src/fs.rs at line 570 [18.737429]

B:BD[21.109614] → [22.61335:61410]

        let dest = self.txn.find_block(self.channel, child.dest).unwrap();

[21.109614]

[21.109690]

        let dest = self.txn.find_block(self.channel, child.dest()).unwrap();

Replacement in libpijul/src/fs.rs at line 573 [18.737429]

B:BD[21.109779] → [21.109779:109860]

            .get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)

[21.109779]

[21.109860]

            .get_contents(|p| self.txn.get_external(&p).unwrap().map(|x| x.into()), *dest, &mut buf)

Replacement in libpijul/src/fs.rs at line 583 [18.737429]
B:BD[21.110176] → [21.110176:110194]
```
            dest,
```
[21.110176]
[21.110194]
```
            *dest,
```

Replacement in libpijul/src/fs.rs at line 595 [18.737429]

B:BD[81.495] → [81.495:562]

            grandchild.dest,
            grandchild.introduced_by,

[81.495]

[81.562]

            grandchild.dest(),
            grandchild.introduced_by(),

Replacement in libpijul/src/fs.rs at line 653 [18.737429]

B:BD[21.111342] → [22.61790:61875]

            let dest = self.txn.find_block_end(&self.channel, parent.dest).unwrap();

[21.111342]

[18.755231]

            let dest = self.txn.find_block_end(&self.channel, parent.dest()).unwrap();

Replacement in libpijul/src/fs.rs at line 656 [18.737429]

B:BD[18.755328] → [21.111343:111428]

                .get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)

[18.755328]

[18.755404]

                .get_contents(|p| self.txn.get_external(&p).unwrap().map(|x| x.into()), *dest, &mut buf)

Replacement in libpijul/src/fs.rs at line 665 [18.737429]
B:BD[27.63317] → [27.63317:63339]
```
                dest,
```
[27.63317]
[27.63339]
```
                *dest,
```

Replacement in libpijul/src/fs.rs at line 670 [18.737429]

B:BD[21.111529] → [21.111529:111628]

                    Some(Ok(grandparent)) => return Some(Ok((grandparent.dest, perms, basename))),

[21.111529]

[21.111628]

                    Some(Ok(grandparent)) => return Some(Ok((grandparent.dest(), perms, basename))),

Replacement in libpijul/src/fs.rs at line 745 [18.737429]

B:BD[22.62309] → [22.62309:62394]

                let parent_dest = txn.find_block_end(&graph, parent?.dest).unwrap();

[22.62309]

[22.62394]

                let parent_dest = txn.find_block_end(&graph, parent?.dest()).unwrap();

Replacement in libpijul/src/fs.rs at line 747 [18.737429]

B:BD[22.62429] → [22.62429:62516]

                    iter_adjacent(txn, &graph, parent_dest, f, f | EdgeFlags::PSEUDO)?

[22.62429]

[22.62516]

                    iter_adjacent(txn, &graph, *parent_dest, f, f | EdgeFlags::PSEUDO)?

Replacement in libpijul/src/fs.rs at line 749 [18.737429]

B:BD[22.62534] → [22.62534:62593]

                    stack.push((grandparent?.dest, false))

[22.62534]

[21.112513]

                    stack.push((grandparent?.dest(), false))

Replacement in libpijul/src/fs.rs at line 783 [18.737429]

B:BD[21.113421] → [43.5913:5997]

            let name_dest = txn.find_block(txn.graph(channel), name.dest).unwrap();

[21.113421]

[18.759767]

            let name_dest = txn.find_block(txn.graph(channel), name.dest()).unwrap();

Replacement in libpijul/src/fs.rs at line 787 [18.737429]

B:BD[23.32131] → [21.113503:113593]

                .get_contents(|h| txn.get_external(h).unwrap(), name_dest, &mut name_buf)

[23.32131]

[21.113593]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name_dest, &mut name_buf)

Replacement in libpijul/src/fs.rs at line 792 [18.737429]

B:BD[18.760027] → [43.5998:6074]

                    .get_changeset(txn.changes(&channel), name.dest.change)

[18.760027]

[18.760104]

                    .get_changeset(txn.changes(&channel), &name.dest().change)

Replacement in libpijul/src/fs.rs at line 806 [18.737429]

B:BD[18.760549] → [43.6075:6157]

            current = iter_adjacent(txn, txn.graph(channel), next, flag0, flag1)?

[18.760549]

[18.760636]

            current = iter_adjacent(txn, txn.graph(channel), *next, flag0, flag1)?

Replacement in libpijul/src/fs.rs at line 809 [18.737429]
∅:D[21.113750] → [18.760686:760708]
B:BD[18.760686] → [18.760686:760708]
```
                .dest
```
[21.113750]
[18.760708]
```
                .dest()
```
Replacement in libpijul/src/fs.rs at line 834 [18.737429]
∅:D[43.6237] → [18.761532:761584]
∅:D[22.63068] → [18.761532:761584]
∅:D[27.64178] → [18.761532:761584]
∅:D[21.114035] → [18.761532:761584]
B:BD[18.761532] → [18.761532:761584]
```
        assert_eq!(inode_vertex, v.inode_vertex());
```
[43.6237]
[43.6238]
```
        assert_eq!(*inode_vertex, v.inode_vertex());
```
Replacement in libpijul/src/fs.rs at line 837 [18.737429]
∅:D[27.64261] → [18.761665:761721]
∅:D[21.114156] → [18.761665:761721]
B:BD[18.761665] → [18.761665:761721]
```
            if !name.flag.contains(EdgeFlags::PARENT) {
```
[21.114156]
[18.761721]
```
            if !name.flag().contains(EdgeFlags::PARENT) {
```

Replacement in libpijul/src/fs.rs at line 842 [18.737429]

B:BD[18.761841] → [43.6333:6406]

                .get_changeset(txn.changes(&channel), name.dest.change)?

[18.761841]

[18.761914]

                .get_changeset(txn.changes(&channel), &name.dest().change)?

Replacement in libpijul/src/fs.rs at line 845 [18.737429]

B:BD[18.761942] → [43.6407:6495]

            let name_dest = txn.find_block_end(txn.graph(channel), name.dest).unwrap();

[18.761942]

[18.762020]

            let name_dest = txn.find_block_end(txn.graph(channel), name.dest()).unwrap();

Replacement in libpijul/src/fs.rs at line 848 [18.737429]

B:BD[21.114351] → [43.6496:6584]

            for e in iter_adjacent(txn, txn.graph(channel), name_dest, flag0, flag1)? {

[21.114351]

[21.114435]

            for e in iter_adjacent(txn, txn.graph(channel), *name_dest, flag0, flag1)? {

Replacement in libpijul/src/fs.rs at line 850 [18.737429]

B:BD[21.114463] → [21.114463:114539]

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

[21.114463]

[21.114539]

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

Replacement in libpijul/src/fs.rs at line 857 [18.737429]

B:BD[18.762352] → [18.762352:762413]

                if !next.flag.contains(EdgeFlags::DELETED) {

[18.762352]

[18.762413]

                if !next.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/fs.rs at line 869 [18.737429]

B:BD[18.762767] → [18.762767:762827]

                next_v = Some((name_dest, age, next.dest));

[18.762767]

[18.762827]

                next_v = Some((name_dest, age, next.dest()));

Replacement in libpijul/src/fs.rs at line 877 [18.737429]

B:BD[21.114694] → [21.114694:114779]

                .get_contents(|h| txn.get_external(h).unwrap(), name, &mut name_buf)

[21.114694]

[21.114779]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name, &mut name_buf)

Replacement in libpijul/src/fs.rs at line 891 [18.737429]
B:BD[81.768] → [81.768:797]
```
    pos: Position<ChangeId>,
```
[81.768]
[81.797]
```
    pos: &Position<ChangeId>,
```
Replacement in libpijul/src/fs.rs at line 893 [18.737429]
B:BD[81.851] → [81.851:882]
```
    let mut latest_change = 0;
```
[81.851]
[81.882]
```
    let mut latest_change = L64(0);
```

Replacement in libpijul/src/fs.rs at line 907 [18.737429]

B:BD[81.1406] → [43.6585:6674]

                    if let Some(t) = txn.get_changeset(txn.changes(&channel), change)? {

[81.1406]

[81.1494]

                    if let Some(&t) = txn.get_changeset(txn.changes(&channel), &change)? {

Replacement in libpijul/src/fs.rs at line 910 [18.737429]

B:BD[81.1589] → [81.1589:1630]

                            id = change;

[81.1589]

[81.1630]

                            id = *change;

Replacement in libpijul/src/fs.rs at line 919 [18.737429]

B:BD[81.1838] → [81.1838:2001]

            let (n, (int, _)) = l?;
            if txn.get_touched_files(pos, Some(int))?.is_some() {
                id = int;
                latest_change = n;

[81.1838]

[81.2001]

            let (n, p) = l?;
            if txn.get_touched_files(pos, Some(&p.a))?.is_some() {
                id = p.a;
                latest_change = *n;

Replacement in libpijul/src/fs.rs at line 928 [18.737429]
B:BD[81.2084] → [81.2084:2112]
```
    Ok((latest_change, id))
```
[81.2084]
[18.763287]
```
    Ok((latest_change.into(), id))
```

Replacement in libpijul/src/find_alive.rs at line 9 [18.763306]

∅:D[23.32412] → [18.763686:763834]

∅:D[21.114985] → [18.763686:763834]

B:BD[18.763686] → [18.763686:763834]

    let mut stack = vec![Edge {
        dest: vertex0.start_pos(),
        introduced_by: ChangeId::ROOT,
        flag: EdgeFlags::empty(),
    }];

[21.114985]

[18.763834]

    let mut stack = vec![SerializedEdge::empty(vertex0.start_pos(), ChangeId::ROOT)];

Replacement in libpijul/src/find_alive.rs at line 13 [18.763306]
B:BD[18.764007] → [18.764007:764046]
```
        if !visited.insert(elt.dest) {
```
[18.764007]
[18.764046]
```
        if !visited.insert(elt.dest()) {
```

Replacement in libpijul/src/find_alive.rs at line 16 [18.763306]

B:BD[18.764078] → [22.63412:63470]

        let vertex = txn.find_block(&channel, elt.dest)?;

[18.764078]

[18.764136]

        let vertex = txn.find_block(&channel, elt.dest())?;

Replacement in libpijul/src/find_alive.rs at line 19 [18.763306]

B:BD[18.764231] → [21.114986:115042]

        for v in iter_adj_all(txn, &channel, vertex)? {

[18.764231]

[21.115042]

        for v in iter_adj_all(txn, &channel, *vertex)? {

Replacement in libpijul/src/find_alive.rs at line 21 [18.763306]
∅:D[63.15586] → [18.764387:764439]
∅:D[27.64607] → [18.764387:764439]
∅:D[21.115066] → [18.764387:764439]
B:BD[18.764387] → [18.764387:764439]
```
            if v.flag.contains(EdgeFlags::FOLDER) {
```
[21.115066]
[18.764439]
```
            if v.flag().contains(EdgeFlags::FOLDER) {
```

Replacement in libpijul/src/find_alive.rs at line 25 [18.763306]

B:BD[18.764581] → [18.764581:764633]

B:BD[18.764633] → [27.64608:64721]

∅:D[27.64721] → [18.764689:764789]

B:BD[18.764689] → [18.764689:764789]

            if v.flag.contains(EdgeFlags::PARENT) {
                if v.flag.contains(EdgeFlags::BLOCK)
                    && !v.flag.contains(EdgeFlags::DELETED)
                    && vertex != vertex0
                    && !v.flag.contains(EdgeFlags::PSEUDO)

[18.764581]

[18.764789]

            if v.flag().contains(EdgeFlags::PARENT) {
                if v.flag().contains(EdgeFlags::BLOCK)
                    && !v.flag().contains(EdgeFlags::DELETED)
                    && *vertex != vertex0
                    && !v.flag().contains(EdgeFlags::PSEUDO)

Replacement in libpijul/src/find_alive.rs at line 31 [18.763306]

B:BD[18.764807] → [18.764807:764849]

                    alive.insert(vertex);

[18.764807]

[18.764849]

                    alive.insert(*vertex);

Replacement in libpijul/src/find_alive.rs at line 38 [18.763306]
B:BD[18.765077] → [18.765077:765103]
```
            stack.push(v)
```
[18.765010]
[18.765103]
```
            stack.push(*v)
```

Replacement in libpijul/src/find_alive.rs at line 52 [18.763306]

B:BD[18.765454] → [18.765454:765600]

    let mut stack = vec![Edge {
        dest: vertex0.end_pos(),
        introduced_by: ChangeId::ROOT,
        flag: EdgeFlags::empty(),
    }];

[18.765422]

[18.765600]

    let mut stack = vec![SerializedEdge::empty(vertex0.end_pos(), ChangeId::ROOT)];

Replacement in libpijul/src/find_alive.rs at line 55 [18.763306]
B:BD[18.765737] → [18.765737:765769]
```
        if elt.dest.is_root() {
```
[18.765737]
[18.765769]
```
        if elt.dest().is_root() {
```
Replacement in libpijul/src/find_alive.rs at line 58 [18.763306]
B:BD[18.765801] → [18.765801:765840]
```
        if !visited.insert(elt.dest) {
```
[18.765801]
[18.765840]
```
        if !visited.insert(elt.dest()) {
```

Replacement in libpijul/src/find_alive.rs at line 61 [18.763306]

B:BD[18.765872] → [22.63471:63533]

        let vertex = txn.find_block_end(&channel, elt.dest)?;

[18.765872]

[18.765934]

        let vertex = *txn.find_block_end(&channel, elt.dest())?;

Replacement in libpijul/src/find_alive.rs at line 69 [18.763306]

B:BD[18.766283] → [63.15839:15924]

            if !v.flag.is_parent() {
                is_file |= !v.flag.is_folder();

[18.766283]

[18.766374]

            if !v.flag().is_parent() {
                is_file |= !v.flag().is_folder();

Replacement in libpijul/src/find_alive.rs at line 73 [18.763306]

B:BD[18.766414] → [63.15925:15993]

            if v.flag & EdgeFlags::pseudof() == EdgeFlags::PSEUDO {

[18.766414]

[63.15993]

            if v.flag() & EdgeFlags::pseudof() == EdgeFlags::PSEUDO {

Replacement in libpijul/src/find_alive.rs at line 76 [18.763306]

B:BD[63.16033] → [63.16033:16111]

            if !v.flag.is_deleted() {
                if v.flag.is_folder() {

[63.16033]

[21.115290]

            if !v.flag().is_deleted() {
                if v.flag().is_folder() {

Replacement in libpijul/src/find_alive.rs at line 80 [18.763306]

B:BD[21.115360] → [21.115360:115442]

                        is_file |= !e.flag.intersects(EdgeFlags::parent_folder())

[21.115360]

[21.115442]

                        is_file |= !e.flag().intersects(EdgeFlags::parent_folder())

Replacement in libpijul/src/find_alive.rs at line 89 [18.763306]

B:BD[18.767445] → [63.16311:16362]

                    if v.introduced_by != change {

[18.767445]

[63.16362]

                    if v.introduced_by() != change {

Replacement in libpijul/src/find_alive.rs at line 95 [18.763306]
B:BD[18.767543] → [63.16467:16503]
```
            if v.flag.is_folder() {
```
[18.767543]
[63.16503]
```
            if v.flag().is_folder() {
```
Replacement in libpijul/src/find_alive.rs at line 102 [18.763306]
B:BD[18.768674] → [18.768674:768704]
```
                stack.push(v)
```
[18.768674]
[18.768704]
```
                stack.push(*v)
```

Replacement in libpijul/src/diff/vertex_buffer.rs at line 98 [18.768903]

B:BD[18.772005] → [18.772005:772101]

                ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos) as u64)

[18.772005]

[18.772101]

                ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos))

Replacement in libpijul/src/diff/vertex_buffer.rs at line 102 [18.768903]

B:BD[18.772205] → [18.772205:772305]

                ChangePosition(self.pos_a[i].vertex.start.0 + (end_pos - self.pos_a[i].pos) as u64)

[18.772205]

[18.772305]

                ChangePosition(self.pos_a[i].vertex.start.0 + (end_pos - self.pos_a[i].pos))

Replacement in libpijul/src/diff/vertex_buffer.rs at line 109 [18.768903]

B:BD[18.772512] → [18.772512:772612]

            v.pos = ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos) as u64)

[18.772512]

[18.772612]

            v.pos = ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos))

Replacement in libpijul/src/diff/replace.rs at line 71 [18.779907]

∅:D[89.206] → [18.781961:782055]

B:BD[18.781961] → [18.781961:782055]

            start: ChangePosition(start as u64),
            end: ChangePosition(end as u64),

[89.206]

[18.782055]

            start: ChangePosition(start.into()),
            end: ChangePosition(end.into()),

Replacement in libpijul/src/diff/replace.rs at line 136 [18.779907]

B:BD[18.784689] → [18.784689:784753]

                    pos: ChangePosition(pos.0 + offset as u64),

[18.784689]

[18.784753]

                    pos: ChangePosition(pos.0 + offset),

Replacement in libpijul/src/diff/replace.rs at line 253 [18.779907]

B:BD[18.789512] → [18.789512:789589]

                e.push(ChangePosition((contents_len + b_len_bytes) as u64));

[18.789512]

[18.789589]

                e.push(ChangePosition((contents_len + b_len_bytes).into()));

Replacement in libpijul/src/diff/replace.rs at line 295 [18.779907]

B:BD[18.791147] → [18.791147:791208]

        .insert(conflict, ChangePosition(len_bytes as u64));

[18.791147]

[18.791208]

        .insert(conflict, ChangePosition(len_bytes.into()));

Replacement in libpijul/src/diff/mod.rs at line 164 [18.793247]
∅:D[27.65652] → [18.798296:798352]
∅:D[21.116349] → [18.798296:798352]
B:BD[18.798296] → [18.798296:798352]
```
                if e.flag.contains(EdgeFlags::PSEUDO) {
```
[21.116349]
[18.798352]
```
                if e.flag().contains(EdgeFlags::PSEUDO) {
```

Replacement in libpijul/src/diff/mod.rs at line 167 [18.793247]

B:BD[18.798400] → [18.798400:798456]

                if e.flag.contains(EdgeFlags::FOLDER) {

[18.798400]

[18.798456]

                if e.flag().contains(EdgeFlags::FOLDER) {

Replacement in libpijul/src/diff/mod.rs at line 174 [18.793247]

B:BD[18.798787] → [18.798787:798904]

                if e.flag.contains(EdgeFlags::PARENT) {
                    if e.flag.contains(EdgeFlags::DELETED) {

[18.798787]

[18.798904]

                if e.flag().contains(EdgeFlags::PARENT) {
                    if e.flag().contains(EdgeFlags::DELETED) {

Replacement in libpijul/src/diff/mod.rs at line 177 [18.793247]

B:BD[18.798951] → [18.798951:799133]

                            previous: e.flag - EdgeFlags::PARENT,
                            flag: e.flag - EdgeFlags::PARENT,
                            from: e.dest.to_option(),

[18.798951]

[18.799133]

                            previous: e.flag() - EdgeFlags::PARENT,
                            flag: e.flag() - EdgeFlags::PARENT,
                            from: e.dest().to_option(),

Replacement in libpijul/src/diff/mod.rs at line 181 [18.793247]

B:BD[18.799187] → [18.799187:799253]

                            introduced_by: Some(e.introduced_by),

[18.799187]

[18.799253]

                            introduced_by: Some(e.introduced_by()),

Replacement in libpijul/src/diff/mod.rs at line 184 [18.793247]

B:BD[18.799309] → [18.799309:799376]

                        let previous = e.flag - EdgeFlags::PARENT;

[18.799309]

[18.799376]

                        let previous = e.flag() - EdgeFlags::PARENT;

Replacement in libpijul/src/diff/mod.rs at line 188 [18.793247]

B:BD[18.799524] → [18.799524:799578]

                            from: e.dest.to_option(),

[18.799524]

[18.799578]

                            from: e.dest().to_option(),

Replacement in libpijul/src/diff/mod.rs at line 190 [18.793247]

B:BD[18.799632] → [18.799632:799698]

                            introduced_by: Some(e.introduced_by),

[18.799632]

[18.799698]

                            introduced_by: Some(e.introduced_by()),

Replacement in libpijul/src/diff/mod.rs at line 216 [18.793247]

B:BD[18.800587] → [18.800587:800691]

                start: ChangePosition(pos as u64),
                end: ChangePosition(pos_end as u64),

[18.800587]

[18.800691]

                start: ChangePosition(pos.into()),
                end: ChangePosition(pos_end.into()),

Replacement in libpijul/src/diff/delete.rs at line 168 [18.805350]

B:BD[21.117083] → [21.117083:117170]

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

[21.117083]

[21.117170]

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

Replacement in libpijul/src/diff/delete.rs at line 171 [18.805350]
B:BD[21.117202] → [21.117202:117253]
```
        let previous = e.flag - EdgeFlags::PARENT;
```
[21.117202]
[78.1831]
```
        let previous = e.flag() - EdgeFlags::PARENT;
```

Replacement in libpijul/src/diff/delete.rs at line 174 [18.805350]

B:BD[78.1912] → [21.117254:117304]

            && !e.flag.contains(EdgeFlags::BLOCK)

[78.1912]

[78.1962]

            && !e.flag().contains(EdgeFlags::BLOCK)

Replacement in libpijul/src/diff/delete.rs at line 182 [18.805350]
B:BD[18.811053] → [21.117305:117340]
```
                e.dest.to_option()
```
[18.811053]
[18.811088]
```
                e.dest().to_option()
```

Replacement in libpijul/src/diff/delete.rs at line 187 [18.805350]

B:BD[18.811281] → [21.117341:117391]

            introduced_by: Some(e.introduced_by),

[18.811281]

[90.47]

            introduced_by: Some(e.introduced_by()),

Replacement in libpijul/src/diff/delete.rs at line 228 [18.805350]

B:BD[18.813182] → [18.813182:813248]

        let pos = ChangePosition(self.rec.contents.len() as u64);

[18.813182]

[18.813248]

        let pos = ChangePosition(self.rec.contents.len().into());

Replacement in libpijul/src/diff/delete.rs at line 340 [18.805350]

∅:D[21.117669] → [18.816587:816674]

B:BD[18.816587] → [18.816587:816674]

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

[21.117669]

[18.816674]

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

Replacement in libpijul/src/diff/delete.rs at line 343 [18.805350]
B:BD[18.816706] → [18.816706:816757]
```
        let previous = e.flag - EdgeFlags::PARENT;
```
[18.816706]
[18.816757]
```
        let previous = e.flag() - EdgeFlags::PARENT;
```
Replacement in libpijul/src/diff/delete.rs at line 348 [18.805350]
B:BD[18.816927] → [18.816927:816962]
```
                e.dest.to_option()
```
[18.816927]
[18.816962]
```
                e.dest().to_option()
```
Replacement in libpijul/src/diff/delete.rs at line 353 [18.805350]
B:BD[18.817081] → [18.817081:817131]
```
            introduced_by: Some(e.introduced_by),
```
[18.817081]
[18.817131]
```
            introduced_by: Some(e.introduced_by()),
```

Replacement in libpijul/src/changestore/mod.rs at line 90 [18.817216]

B:BD[18.820182] → [18.820182:820263]

    pub(crate) fn deletes_pos(&self, pos: Position<Option<Hash>>) -> Vec<Hash> {

[18.820182]

[18.820263]

    pub fn deletes_pos(&self, pos: Position<Option<Hash>>) -> Vec<Hash> {

Replacement in libpijul/src/changestore/memory.rs at line 46 [18.820702]
∅:D[23.34791] → [18.821629:821688]
B:BD[18.821629] → [18.821629:821688]
```
        buf.resize((key.end.0 - key.start.0) as usize, 0);
```
[23.34791]
[18.821688]
```
        buf.resize(key.end.us() - key.start.us(), 0);
```

Replacement in libpijul/src/changestore/memory.rs at line 52 [18.820702]

B:BD[18.821876] → [18.821876:821956]

        let start = key.start.0 as usize;
        let end = key.end.0 as usize;

[18.821876]

[18.821956]

        let start = key.start.us();
        let end = key.end.us();

Replacement in libpijul/src/changestore/memory.rs at line 64 [18.820702]

B:BD[18.822237] → [18.822237:822300]

            buf.resize((key.end.0 - key.start.0) as usize, 0);

[18.822237]

[18.822300]

            buf.resize(key.end.us() - key.start.us(), 0);

Replacement in libpijul/src/changestore/memory.rs at line 70 [18.820702]

B:BD[18.822489] → [18.822489:822577]

            let start = key.start.0 as usize;
            let end = key.end.0 as usize;

[18.822489]

[18.822577]

            let start = key.start.us();
            let end = key.end.us();

Replacement in libpijul/src/changestore/filesystem.rs at line 159 [18.824013]
∅:D[23.35792] → [18.828651:828710]
B:BD[18.828651] → [18.828651:828710]
```
        buf.resize((key.end.0 - key.start.0) as usize, 0);
```
[23.35792]
[18.828710]
```
        buf.resize(key.end.us() - key.start.us(), 0);
```
Replacement in libpijul/src/changestore/filesystem.rs at line 166 [18.824013]
B:BD[18.828943] → [18.828943:828995]
```
        let n = p.read_contents(key.start.0, buf)?;
```
[18.828943]
[18.828995]
```
        let n = p.read_contents(key.start.into(), buf)?;
```

Replacement in libpijul/src/changestore/filesystem.rs at line 175 [18.824013]

B:BD[18.829200] → [18.829200:829263]

            buf.resize((key.end.0 - key.start.0) as usize, 0);

[18.829200]

[18.829263]

            buf.resize(key.end.us() - key.start.us(), 0);

Replacement in libpijul/src/changestore/filesystem.rs at line 181 [18.824013]

B:BD[18.829483] → [18.829483:829539]

            let n = p.read_contents(key.start.0, buf)?;

[18.829483]

[18.829539]

            let n = p.read_contents(key.start.into(), buf)?;

Insertion in libpijul/src/change.rs at line 169 [18.831311]
[18.834952]
[18.834952]
```
// Beware of change the version, tags also use that.
```

Replacement in libpijul/src/change.rs at line 246 [18.831311]

B:BD[91.446] → [21.118178:118290]

        let a = txn.get_internal(*a).unwrap().unwrap();
        let b = txn.get_internal(*b).unwrap().unwrap();

[91.446]

[43.6986]

        let a = txn.get_internal(&a.into()).unwrap().unwrap();
        let b = txn.get_internal(&b.into()).unwrap().unwrap();

Replacement in libpijul/src/change.rs at line 254 [18.831311]

B:BD[91.757] → [21.118387:118499]

        let a = txn.get_internal(*a).unwrap().unwrap();
        let b = txn.get_internal(*b).unwrap().unwrap();

[91.757]

[43.7112]

        let a = txn.get_internal(&a.into()).unwrap().unwrap();
        let b = txn.get_internal(&b.into()).unwrap().unwrap();

Replacement in libpijul/src/change.rs at line 269 [18.831311]

B:BD[18.837994] → [21.118823:118949]

∅:D[21.118949] → [18.838097:838121]

B:BD[18.838097] → [18.838097:838121]

    for x in changeid_log(txn, &channel, 0)? {
        let (_, (ch, _)) = x?;
        let h = txn.get_external(ch)?.unwrap();
        deps.insert(h);

[18.837994]

[18.838121]

    for x in changeid_log(txn, &channel, L64(0))? {
        let (_, p) = x?;
        let h = txn.get_external(&p.a)?.unwrap();
        deps.insert(h.into());

Replacement in libpijul/src/change.rs at line 286 [18.831311]

B:BD[18.838485] → [21.119138:119189]

            change: txn.get_internal(p)?.unwrap(),

[18.838485]

[18.838535]

            change: *txn.get_internal(&p.into())?.unwrap(),

Replacement in libpijul/src/change.rs at line 293 [18.831311]
∅:D[22.64208] → [21.119214:119266]
B:BD[27.66514] → [21.119214:119266]
```
    for edge in iter_adj_all(txn, channel, from)? {
```
[22.64208]
[21.119266]
```
    for edge in iter_adj_all(txn, channel, *from)? {
```

Replacement in libpijul/src/change.rs at line 295 [18.831311]

B:BD[21.119292] → [21.119292:119359]

        if let Some(ext) = txn.get_external(edge.introduced_by)? {

[21.119292]

[18.838826]

        if let Some(ext) = txn.get_external(&edge.introduced_by())? {
            let ext: Hash = ext.into();

Replacement in libpijul/src/change.rs at line 299 [18.831311]

B:BD[18.838885] → [18.838885:838937]

                zombie_deps.insert(ext.to_owned());

[18.838885]

[18.838937]

                zombie_deps.insert(ext);

Replacement in libpijul/src/change.rs at line 302 [18.831311]

B:BD[18.838961] → [21.119360:119425]

        if let Some(ext) = txn.get_external(edge.dest.change)? {

[18.838961]

[18.839025]

        if let Some(ext) = txn.get_external(&edge.dest().change)? {
            let ext: Hash = ext.into();

Replacement in libpijul/src/change.rs at line 306 [18.831311]

B:BD[18.839084] → [18.839084:839136]

                zombie_deps.insert(ext.to_owned());

[18.839084]

[18.839136]

                zombie_deps.insert(ext);

Replacement in libpijul/src/change.rs at line 321 [18.831311]

B:BD[18.839381] → [21.119543:119594]

            change: txn.get_internal(p)?.unwrap(),

[18.839381]

[18.839431]

            change: *txn.get_internal(&p.into())?.unwrap(),

Replacement in libpijul/src/change.rs at line 329 [18.831311]

B:BD[18.839576] → [21.119619:119673]

        for edge in iter_adj_all(txn, channel, to)? {

[18.839576]

[21.119673]

        for edge in iter_adj_all(txn, channel, *to)? {

Replacement in libpijul/src/change.rs at line 331 [18.831311]

B:BD[21.119703] → [21.119703:119774]

            if let Some(ext) = txn.get_external(edge.introduced_by)? {

[21.119703]

[18.839737]

            if let Some(ext) = txn.get_external(&edge.introduced_by())? {
                let ext = ext.into();

Replacement in libpijul/src/change.rs at line 335 [18.831311]

B:BD[18.839804] → [18.839804:839860]

                    zombie_deps.insert(ext.to_owned());

[18.839804]

[18.839860]

                    zombie_deps.insert(ext);

Replacement in libpijul/src/change.rs at line 338 [18.831311]

B:BD[18.839892] → [21.119775:119844]

            if let Some(ext) = txn.get_external(edge.dest.change)? {

[18.839892]

[18.839960]

            if let Some(ext) = txn.get_external(&edge.dest().change)? {
                let ext = ext.into();

Replacement in libpijul/src/change.rs at line 342 [18.831311]

B:BD[18.840027] → [18.840027:840083]

                    zombie_deps.insert(ext.to_owned());

[18.840027]

[18.840083]

                    zombie_deps.insert(ext);

Replacement in libpijul/src/change.rs at line 367 [18.831311]
B:BD[18.840655] → [21.120059:120108]
```
        let id = txn.get_internal(*h)?.unwrap();
```
[18.840655]
[18.840703]
```
        let id = txn.get_internal(&h.into())?.unwrap();
```
Insertion in libpijul/src/change.rs at line 370 [18.831311]
[43.7313]
[18.840811]
```
        let time = u64::from_le(time.0);
```
Insertion in libpijul/src/change.rs at line 408 [18.831311]
[18.842075]
[18.842075]
```
            let time = u64::from_le(time.0);
```

Replacement in libpijul/src/change.rs at line 417 [18.831311]

B:BD[18.842269] → [21.120451:120509]

        .map(|id| txn.get_external(id).unwrap().unwrap())

[18.842269]

[21.120509]

        .map(|id| txn.get_external(id).unwrap().unwrap().into())

Replacement in libpijul/src/change.rs at line 966 [18.831311]

B:BD[18.860639] → [21.120675:120761]

                        change: up.change.and_then(|a| txn.get_external(a).unwrap()),

[18.860639]

[18.860716]

                        change: up.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 973 [18.831311]

B:BD[18.860923] → [21.120762:120850]

                        change: down.change.and_then(|a| txn.get_external(a).unwrap()),

[18.860923]

[18.861002]

                        change: down.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 981 [18.831311]

B:BD[18.861217] → [21.120851:120936]

                    change: inode.change.and_then(|a| txn.get_external(a).unwrap()),

[18.861217]

[18.861293]

                    change: inode.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 992 [18.831311]

B:BD[18.861673] → [21.121037:121134]

                            change: edge.from.change.and_then(|a| txn.get_external(a).unwrap()),

[18.861673]

[18.861761]

                            change: edge.from.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 996 [18.831311]

B:BD[18.861873] → [21.121135:121230]

                            change: edge.to.change.and_then(|a| txn.get_external(a).unwrap()),

[18.861873]

[18.861959]

                            change: edge.to.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 1000 [18.831311]

B:BD[18.862082] → [18.862082:862150]

                        introduced_by: edge.introduced_by.map(|a| {

[18.862082]

[21.121231]

                        introduced_by: edge.introduced_by.as_ref().map(|a| {

Replacement in libpijul/src/change.rs at line 1002 [18.831311]
∅:D[21.121307] → [18.862217:862251]
B:BD[18.862217] → [18.862217:862251]
```
                                a
```
[21.121307]
[18.862251]
```
                                a.into()
```

Replacement in libpijul/src/change.rs at line 1010 [18.831311]

B:BD[18.862500] → [21.121308:121393]

                    change: inode.change.and_then(|a| txn.get_external(a).unwrap()),

[18.862500]

[18.862576]

                    change: inode.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 1197 [18.831311]
B:BD[18.868693] → [18.868693:868717]
```
const LEVEL: usize = 1;
```
[18.868693]
[18.868717]
```
const LEVEL: usize = 10;
```

Replacement in libpijul/src/change.rs at line 1201 [18.831311]

B:BD[18.868798] → [23.37143:37218]

fn compress<W: Write>(input: &[u8], mut w: W) -> Result<(), ChangeError> {

[18.868798]

[18.868875]

fn compress(input: &[u8], w: &mut Vec<u8>) -> Result<(), ChangeError> {

Deletion in libpijul/src/change.rs at line 1353 [18.831311]
B:BD[18.874502] → [18.874502:874503]

Replacement in libpijul/src/change/text_changes.rs at line 326 [23.37976]

B:BD[23.49025] → [23.49025:49113]

                        &change_contents[add.start.0 as usize + 2..add.end.0 as usize],

[23.49025]

[23.49113]

                        &change_contents[add.start.us() + 2..add.end.us()],

Replacement in libpijul/src/change/text_changes.rs at line 330 [23.37976]

B:BD[23.49245] → [23.49245:49335]

                        &change_contents[add.start.0 as usize..add.start.0 as usize + 2],

[23.49245]

[23.49335]

                        &change_contents[add.start.us()..add.start.us() + 2],

Replacement in libpijul/src/change/text_changes.rs at line 401 [23.37976]

B:BD[23.51916] → [23.51916:52000]

                        &change_contents[n.start.0 as usize + 2..n.end.0 as usize],

[23.51916]

[23.52000]

                        &change_contents[n.start.us() + 2..n.end.us()],

Replacement in libpijul/src/change/text_changes.rs at line 405 [23.37976]

B:BD[23.52132] → [23.52132:52218]

                        &change_contents[n.start.0 as usize..n.start.0 as usize + 2],

[23.52132]

[23.52218]

                        &change_contents[n.start.us()..n.start.us() + 2],

Replacement in libpijul/src/change/text_changes.rs at line 429 [23.37976]

B:BD[23.53131] → [23.53131:53215]

                    let c = &change_contents[n.start.0 as usize..n.end.0 as usize];

[23.53131]

[92.2882]

                    let c = &change_contents[n.start.us()..n.end.us()];

Replacement in libpijul/src/change/text_changes.rs at line 561 [23.37976]

B:BD[23.58944] → [23.58944:59013]

            add_name.start = ChangePosition(contents_.len() as u64);

[23.58944]

[23.59013]

            add_name.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 581 [23.37976]

B:BD[23.59747] → [23.59747:59814]

            add_name.end = ChangePosition(contents_.len() as u64);

[23.59747]

[23.59814]

            add_name.end = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 587 [23.37976]

B:BD[23.60014] → [23.60014:60075]

                pos: ChangePosition(contents_.len() as u64),

[23.60014]

[23.60075]

                pos: ChangePosition(contents_.len().into()),

Replacement in libpijul/src/change/text_changes.rs at line 591 [23.37976]

B:BD[23.60123] → [23.60123:60261]

            add_inode.start = ChangePosition(contents_.len() as u64);
            add_inode.end = ChangePosition(contents_.len() as u64);

[23.60123]

[23.60261]

            add_inode.start = ChangePosition(contents_.len().into());
            add_inode.end = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 699 [23.37976]

B:BD[23.64162] → [23.64162:64226]

            add.start = ChangePosition(contents_.len() as u64);

[23.64162]

[23.64226]

            add.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 711 [23.37976]

B:BD[23.64686] → [23.64686:64748]

            add.end = ChangePosition(contents_.len() as u64);

[23.64686]

[23.64748]

            add.end = ChangePosition(contents_.len().into());

Insertion in libpijul/src/change/text_changes.rs at line 794 [23.37976]

[23.67925]

                            // The `-1` here comes from the extra 0
                            // padding bytes pushed onto `contents_`.

Replacement in libpijul/src/change/text_changes.rs at line 798 [23.37976]

B:BD[23.68022] → [23.68022:68103]

                                pos: ChangePosition(contents_.len() as u64 - 1),

[23.68022]

[23.68103]

                                pos: ChangePosition((contents_.len() - 1).into()),

Replacement in libpijul/src/change/text_changes.rs at line 803 [23.37976]

∅:D[63.17201] → [23.68233:68311]

B:BD[23.68233] → [23.68233:68311]

                            v.start = ChangePosition(contents_.len() as u64);

[63.17201]

[23.68311]

                            v.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 814 [23.37976]

B:BD[17.216] → [17.216:378]

                                if  contents_[c.end.0 as usize - 1] == b'\n' {
                                    assert_eq!(c.end.0 as usize, contents_.len());

[17.216]

[17.378]

                                if  contents_[c.end.us() - 1] == b'\n' {
                                    assert_eq!(c.end.us(), contents_.len());

Replacement in libpijul/src/change/text_changes.rs at line 918 [23.37976]

B:BD[23.73590] → [23.73590:73677]

                                change.start = ChangePosition(contents_.len() as u64);

[23.73590]

[23.73677]

                                change.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 925 [23.37976]

B:BD[93.232] → [93.232:313]

                                && contents_[change.end.0 as usize - 1] == b'\n'

[93.232]

[93.313]

                                && contents_[change.end.us() - 1] == b'\n'

Replacement in libpijul/src/change/text_changes.rs at line 927 [23.37976]

∅:D[93.343] → [23.74017:74101]

B:BD[23.74017] → [23.74017:74101]

                                assert_eq!(change.end.0 as usize, contents_.len());

[93.343]

[23.74101]

                                assert_eq!(change.end.us(), contents_.len());

Replacement in libpijul/src/change/text_changes.rs at line 956 [23.37976]

B:BD[23.75408] → [23.75408:75493]

                                repl.start = ChangePosition(contents_.len() as u64);

[23.75408]

[23.75493]

                                repl.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 962 [23.37976]

B:BD[23.75755] → [93.344:444]

                            if repl.end > repl.start && contents_[repl.end.0 as usize - 1] == b'\n'

[23.75755]

[93.444]

                            if repl.end > repl.start && contents_[repl.end.us() - 1] == b'\n'

Replacement in libpijul/src/change/text_changes.rs at line 964 [23.37976]

∅:D[93.474] → [23.75832:75914]

B:BD[23.75832] → [23.75832:75914]

                                assert_eq!(repl.end.0 as usize, contents_.len());

[93.474]

[23.75914]

                                assert_eq!(repl.end.us(), contents_.len());

Replacement in libpijul/src/change/text_changes.rs at line 999 [23.37976]

B:BD[23.77590] → [23.77590:77677]

                                change.start = ChangePosition(contents_.len() as u64);

[23.77590]

[23.77677]

                                change.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 1014 [23.37976]

B:BD[23.78601] → [23.78601:78688]

                                change.start = ChangePosition(contents_.len() as u64);

[23.78601]

[23.78688]

                                change.start = ChangePosition(contents_.len().into());

Replacement in libpijul/src/change/text_changes.rs at line 1016 [23.37976]

B:BD[23.78733] → [23.78733:78831]

                                    ChangePosition(contents_.len() as u64 + new_end - new_start);

[23.78733]

[23.78831]

                                    ChangePosition((contents_.len() as u64 + new_end - new_start).into());

Replacement in libpijul/src/change/text_changes.rs at line 1057 [23.37976]

B:BD[23.80329] → [23.80329:80395]

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

[23.80329]

[23.80395]

        start: ChangePosition(L64(0)),
        end: ChangePosition(L64(0)),

Replacement in libpijul/src/change/text_changes.rs at line 1064 [23.37976]
B:BD[23.80559] → [23.80559:80595]
```
            pos: ChangePosition(0),
```
[23.80559]
[23.80595]
```
            pos: ChangePosition(L64(0)),
```
Replacement in libpijul/src/change/text_changes.rs at line 1074 [23.37976]
B:BD[23.80772] → [23.80772:80808]
```
            pos: ChangePosition(0),
```
[23.80772]
[23.80808]
```
            pos: ChangePosition(L64(0)),
```
Replacement in libpijul/src/change/text_changes.rs at line 1103 [23.37976]
B:BD[23.81717] → [23.81717:81749]
```
            ChangePosition(pos)
```
[23.81717]
[23.81749]
```
            ChangePosition(L64(pos.to_le()))
```
Replacement in libpijul/src/change/text_changes.rs at line 1135 [23.37976]
∅:D[94.1878] → [23.82453:82487]
B:BD[23.82453] → [23.82453:82487]
```
        pos: ChangePosition(pos),
```
[94.1878]
[94.1879]
```
        pos: ChangePosition(L64(pos.to_le())),
```
Replacement in libpijul/src/change/text_changes.rs at line 1161 [23.37976]
∅:D[94.2079] → [23.83605:83652]
B:BD[23.83605] → [23.83605:83652]
```
                    pos: ChangePosition(pos0),
```
[94.2079]
[23.83652]
```
                    pos: ChangePosition(L64(pos0.to_le())),
```

Replacement in libpijul/src/change/text_changes.rs at line 1165 [23.37976]

∅:D[94.2139] → [23.83758:83856]

B:BD[23.83758] → [23.83758:83856]

                    start: ChangePosition(start1),
                    end: ChangePosition(end1),

[94.2139]

[23.83856]

                    start: ChangePosition(L64(start1.to_le())),
                    end: ChangePosition(L64(end1.to_le())),

Replacement in libpijul/src/change/text_changes.rs at line 1190 [23.37976]
B:BD[23.84540] → [23.84540:84597]
```
    change.end = ChangePosition(contents_.len() as u64);
```
[23.84540]
[23.84597]
```
    change.end = ChangePosition(contents_.len().into());
```

Insertion in libpijul/src/change/text_changes.rs at line 1207 [23.37976]

[92.3825]

impl WriteChangeLine for &mut std::io::Stderr {}
impl WriteChangeLine for &mut std::io::Stdout {}

Replacement in libpijul/src/change/text_changes.rs at line 1238 [23.37976]

B:BD[23.85462] → [23.85462:85538]

            let c = &change_contents[n.start.0 as usize..n.end.0 as usize];

[23.85462]

[23.85538]

            let c = &change_contents[n.start.us()..n.end.us()];

Replacement in libpijul/src/apply.rs at line 85 [18.944089]
B:BD[18.944833] → [18.944833:944849]
```
    hash: Hash,
```
[18.944833]
[18.944849]
```
    hash: &Hash,
```
Replacement in libpijul/src/apply.rs at line 93 [18.944089]
B:BD[18.945090] → [18.945090:945136]
```
    for &hash in change.dependencies.iter() {
```
[18.945090]
[18.945136]
```
    for hash in change.dependencies.iter() {
```

Replacement in libpijul/src/apply.rs at line 97 [18.944089]

B:BD[18.945203] → [21.124470:124523]

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

[18.945203]

[43.7447]

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

Replacement in libpijul/src/apply.rs at line 102 [18.944089]

B:BD[18.945379] → [23.94779:94853]

        return Err((LocalApplyError::DependencyMissing { hash }).into());

[18.945379]

[18.945443]

        return Err((LocalApplyError::DependencyMissing { hash: *hash }).into());

Replacement in libpijul/src/apply.rs at line 105 [18.944089]

B:BD[18.945450] → [21.124599:124661]

    let internal = if let Some(p) = txn.get_internal(hash)? {

[18.945450]

[18.945511]

    let internal = if let Some(&p) = txn.get_internal(&hash.into())? {

Replacement in libpijul/src/apply.rs at line 109 [18.944089]

B:BD[21.124723] → [21.124723:124779]

        register_change(txn, internal, hash, &change)?;

[21.124723]

[18.945648]

        register_change(txn, &internal, hash, &change)?;

Replacement in libpijul/src/apply.rs at line 127 [18.944089]
B:BD[18.946043] → [18.946043:946059]
```
    hash: Hash,
```
[18.946043]
[18.946059]
```
    hash: &Hash,
```

Replacement in libpijul/src/apply.rs at line 135 [18.944089]

B:BD[18.946265] → [18.946265:946321]

    let mut dep_stack = vec![(hash, true, !deps_only)];

[18.946265]

[95.64]

    let mut dep_stack = vec![(*hash, true, !deps_only)];

Insertion in libpijul/src/apply.rs at line 139 [18.944089]
[23.95219]
[18.946440]
```
        let shash: SerializedHash = (&hash).into();
```

Replacement in libpijul/src/apply.rs at line 144 [18.944089]

B:BD[95.182] → [21.124836:124899]

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

[95.182]

[95.244]

            if let Some(change_id) = txn.get_internal(&shash)? {

Replacement in libpijul/src/apply.rs at line 161 [18.944089]

B:BD[18.946763] → [21.124972:125043]

            let applied = if let Some(int) = txn.get_internal(hash)? {

[18.946763]

[43.7593]

            let applied = if let Some(int) = txn.get_internal(&shash)? {

Replacement in libpijul/src/apply.rs at line 167 [18.944089]

B:BD[18.946990] → [21.125118:125192]

                let internal = if let Some(p) = txn.get_internal(hash)? {

[18.946990]

[18.947063]

                let internal = if let Some(&p) = txn.get_internal(&shash)? {

Replacement in libpijul/src/apply.rs at line 171 [18.944089]

B:BD[21.125266] → [21.125266:125334]

                    register_change(txn, internal, hash, &change)?;

[21.125266]

[18.947248]

                    register_change(txn, &internal, &hash, &change)?;

Replacement in libpijul/src/apply.rs at line 188 [18.944089]
B:BD[18.947922] → [18.947922:947938]
```
    hash: Hash,
```
[18.947922]
[21.125335]
```
    hash: &Hash,
```
Replacement in libpijul/src/apply.rs at line 198 [18.944089]
B:BD[18.948241] → [18.948241:948257]
```
    hash: Hash,
```
[18.948241]
[18.948257]
```
    hash: &Hash,
```
Insertion in libpijul/src/apply.rs at line 221 [18.944089]
[43.7707]
[21.125568]
```
    debug!("apply_change_to_channel {:?} {:?}", change_id, hash);
```
Replacement in libpijul/src/apply.rs at line 309 [18.944089]
B:BD[18.952561] → [18.952561:952577]
```
    hash: Hash,
```
[18.952561]
[18.952577]
```
    hash: &Hash,
```

Replacement in libpijul/src/apply.rs at line 314 [18.944089]

B:BD[18.952806] → [21.126985:127042]

    let internal: ChangeId = make_changeid(txn, &hash)?;

[18.952806]

[96.0]

    let internal: ChangeId = make_changeid(txn, hash)?;
    debug!("make_changeid {:?} {:?}", hash, internal);

Replacement in libpijul/src/apply.rs at line 317 [18.944089]

B:BD[96.1] → [96.1:47]

    for &hash in change.dependencies.iter() {

[96.1]

[96.47]

    for hash in change.dependencies.iter() {

Replacement in libpijul/src/apply.rs at line 321 [18.944089]

B:BD[96.114] → [21.127043:127096]

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

[96.114]

[43.7807]

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

Replacement in libpijul/src/apply.rs at line 326 [18.944089]

B:BD[96.290] → [23.96242:96316]

        return Err((LocalApplyError::DependencyMissing { hash }).into());

[96.290]

[96.354]

        return Err((LocalApplyError::DependencyMissing { hash: *hash }).into());

Replacement in libpijul/src/apply.rs at line 329 [18.944089]

B:BD[96.361] → [21.127172:127224]

    register_change(txn, internal, hash, &change)?;

[96.361]

[97.227]

    register_change(txn, &internal, hash, &change)?;

Replacement in libpijul/src/apply.rs at line 347 [18.944089]
B:BD[18.953551] → [18.953551:953567]
```
    hash: Hash,
```
[18.953551]
[18.953567]
```
    hash: &Hash,
```

Replacement in libpijul/src/apply.rs at line 374 [18.944089]

B:BD[18.954317] → [43.8056:8133]

                .get_graph(txn.graph(channel), vertex.inode_vertex(), None)?

[18.954317]

[18.954389]

                .get_graph(txn.graph(channel), &vertex.inode_vertex(), None)?

Replacement in libpijul/src/apply.rs at line 378 [18.944089]

B:BD[18.954497] → [21.127763:127821]

                put_inodes_with_rev(txn, inode, vertex)?;

[18.954497]

[18.954554]

                put_inodes_with_rev(txn, &inode, &vertex)?;

Replacement in libpijul/src/apply.rs at line 384 [18.944089]

B:BD[18.954777] → [21.127822:127979]

            if let Some(parent) = txn.get_revtree(inode, None)?.map(|x| x.to_owned()) {
                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

[18.954777]

[18.954997]

            if let Some(parent) = txn.get_revtree(&inode, None)?.map(|x| x.to_owned()) {
                del_tree_with_rev(txn, &parent, &inode)?;

Replacement in libpijul/src/apply.rs at line 389 [18.944089]

B:BD[18.955037] → [18.955037:955259]

                (OwnedPathId {
                    parent_inode: inode,
                    basename: crate::small_string::SmallString::new(),
                })
                .as_file_id(),
                Some(inode),

[18.955037]

[21.127980]

                &OwnedPathId::inode(inode),
                Some(&inode),

Replacement in libpijul/src/apply.rs at line 392 [18.944089]

B:BD[21.127996] → [21.127996:128119]

            if let Some(vertex) = txn.get_inodes(inode, None)? {
                del_inodes_with_rev(txn, inode, vertex)?;

[21.127996]

[18.955450]

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

Replacement in libpijul/src/apply.rs at line 479 [18.944089]
B:BD[18.957945] → [22.65597:65645]
```
        let k = txn.find_block_end(graph, up)?;
```
[18.957945]
[18.957995]
```
        let k = *txn.find_block_end(graph, up)?;
```

Replacement in libpijul/src/apply.rs at line 487 [18.944089]

B:BD[63.18835] → [22.65646:65709]

            txn.split_block(graph, k, up.pos, &mut ws.adjbuf)?

[63.18835]

[18.958502]

            txn.split_block(graph, &k, up.pos, &mut ws.adjbuf)?

Replacement in libpijul/src/apply.rs at line 501 [18.944089]

∅:D[21.129170] → [63.18872:18973]

B:BD[27.68579] → [63.18872:18973]

        is_non_folder |= parent.flag & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;

[21.129170]

[27.68579]

        is_non_folder |= parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;

Replacement in libpijul/src/apply.rs at line 503 [18.944089]
B:BD[27.68597] → [27.68597:68615]
```
            .flag
```
[27.68597]
[27.68615]
```
            .flag()
```

Replacement in libpijul/src/apply.rs at line 506 [18.944089]

B:BD[27.68706] → [21.129171:129253]

            let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();

[27.68706]

[27.68849]

            let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();

Replacement in libpijul/src/apply.rs at line 508 [18.944089]

B:BD[27.68892] → [63.18974:19034]

                ws.deleted_by.insert(parent.introduced_by);

[27.68892]

[27.69008]

                ws.deleted_by.insert(parent.introduced_by());

Replacement in libpijul/src/apply.rs at line 523 [18.944089]
B:BD[21.129372] → [22.65710:65753]
```
    let k = txn.find_block(&graph, down)?;
```
[21.129372]
[18.959540]
```
    let k = *txn.find_block(&graph, down)?;
```

Replacement in libpijul/src/apply.rs at line 530 [18.944089]

B:BD[63.19263] → [22.65754:65815]

        txn.split_block(graph, k, down.pos, &mut ws.adjbuf)?

[63.19263]

[18.960115]

        txn.split_block(graph, &k, down.pos, &mut ws.adjbuf)?

Replacement in libpijul/src/apply.rs at line 544 [18.944089]

∅:D[21.129585] → [63.19296:19378]

B:BD[27.69437] → [63.19296:19378]

∅:D[63.19378] → [27.69437:69509]

B:BD[27.69437] → [27.69437:69509]

∅:D[27.69509] → [18.960555:960613]

B:BD[18.960555] → [18.960555:960613]

B:BD[18.960613] → [21.129586:129672]

        is_folder |= parent.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);
        if parent.flag.contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {
            if parent.flag.contains(EdgeFlags::DELETED) {
                let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();

[21.129585]

[18.960764]

        is_folder |= parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);
        if parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {
            if parent.flag().contains(EdgeFlags::DELETED) {
                let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();

Replacement in libpijul/src/apply.rs at line 549 [18.944089]

B:BD[18.960811] → [63.19379:19443]

                    ws.deleted_by.insert(parent.introduced_by);

[18.960811]

[18.960935]

                    ws.deleted_by.insert(parent.introduced_by());

Replacement in libpijul/src/apply.rs at line 562 [18.944089]

B:BD[18.961276] → [18.961276:961343]

    pseudo: Vec<(Vertex<ChangeId>, Edge, Position<Option<Hash>>)>,

[18.961276]

[63.19463]

    pseudo: Vec<(Vertex<ChangeId>, SerializedEdge, Position<Option<Hash>>)>,

Replacement in libpijul/src/apply.rs at line 568 [18.944089]
B:BD[18.961591] → [21.129673:129696]
```
    adjbuf: Vec<Edge>,
```
[18.961591]
[18.961591]
```
    adjbuf: Vec<SerializedEdge>,
```

Replacement in libpijul/src/apply.rs at line 644 [18.944089]

B:BD[63.20045] → [64.404:475]

            txn.split_block(graph, target, n.to.end, &mut ws.adjbuf)?;

[63.20045]

[18.964696]

            txn.split_block(graph, &target, n.to.end, &mut ws.adjbuf)?;

Replacement in libpijul/src/apply.rs at line 671 [18.944089]
B:BD[18.966024] → [22.65886:65907]
```
        target = txn
```
[18.966024]
[22.65907]
```
        target = *txn
```

Replacement in libpijul/src/apply.rs at line 689 [18.944089]

B:BD[18.966496] → [22.66003:66090]

    let mut source = txn.find_block_end(&channel, internal_pos(txn, &from, change)?)?;

[18.966496]

[18.966582]

    let mut source = *txn.find_block_end(&channel, internal_pos(txn, &from, change)?)?;

Replacement in libpijul/src/apply.rs at line 694 [18.944089]

B:BD[63.20332] → [22.66091:66160]

        txn.split_block(channel, source, from.pos, &mut ws.adjbuf)?;

[63.20332]

[18.967333]

        txn.split_block(channel, &source, from.pos, &mut ws.adjbuf)?;

Replacement in libpijul/src/apply.rs at line 711 [18.944089]

B:BD[63.20382] → [22.66161:66216]

    let mut target = txn.find_block(channel, to_pos)?;

[63.20382]

[18.967800]

    let mut target = *txn.find_block(channel, to_pos)?;

Replacement in libpijul/src/apply.rs at line 716 [18.944089]

B:BD[63.20449] → [22.66217:66286]

        txn.split_block(channel, target, to.start, &mut ws.adjbuf)?;

[63.20449]

[18.968526]

        txn.split_block(channel, &target, to.start, &mut ws.adjbuf)?;

Replacement in libpijul/src/apply.rs at line 738 [18.944089]

B:BD[18.969041] → [4.0:49]

∅:D[4.49] → [18.969090:969142]

∅:D[98.396] → [18.969090:969142]

B:BD[18.969090] → [18.969090:969142]

B:BD[18.969142] → [22.66287:66349]

        if !e.flag.contains(EdgeFlags::FOLDER) {
            if e.flag.contains(EdgeFlags::PARENT) {
                let p = txn.find_block_end(channel, e.dest)?;

[18.969041]

[21.131679]

        if !e.flag().contains(EdgeFlags::FOLDER) {
            if e.flag().contains(EdgeFlags::PARENT) {
                let p = txn.find_block_end(channel, e.dest())?;

Replacement in libpijul/src/apply.rs at line 742 [18.944089]
∅:D[27.70514] → [18.969250:969295]
∅:D[21.131727] → [18.969250:969295]
B:BD[18.969250] → [18.969250:969295]
```
                    apply.parents.insert(p);
```
[21.131727]
[18.969295]
```
                    apply.parents.insert(*p);
```

Replacement in libpijul/src/apply.rs at line 745 [18.944089]

B:BD[18.969334] → [22.66350:66408]

B:BD[22.66408] → [7.0:53]

                let p = txn.find_block(channel, e.dest)?;
                if e.flag.contains(EdgeFlags::BLOCK)

[18.969334]

[7.53]

                let p = txn.find_block(channel, e.dest())?;
                if e.flag().contains(EdgeFlags::BLOCK)

Replacement in libpijul/src/apply.rs at line 750 [18.944089]
∅:D[7.165] → [22.66503:66549]
B:BD[22.66503] → [22.66503:66549]
```
                    apply.children.insert(p);
```
[7.165]
[22.66549]
```
                    apply.children.insert(*p);
```

Replacement in libpijul/src/apply.rs at line 754 [18.944089]

B:BD[18.969458] → [18.969458:969552]

        if e.flag.contains(EdgeFlags::PSEUDO) {
            apply.pseudo.push((v, e, inode));

[18.969458]

[18.969552]

        if e.flag().contains(EdgeFlags::PSEUDO) {
            apply.pseudo.push((v, *e, inode));

Replacement in libpijul/src/apply.rs at line 792 [18.944089]

B:BD[63.20607] → [21.132023:132082]

        debug_assert!(is_alive(txn, channel, p).unwrap());

[63.20607]

[63.20657]

        debug_assert!(is_alive(txn, channel, &p).unwrap());

Replacement in libpijul/src/apply.rs at line 795 [18.944089]

B:BD[63.20720] → [7.166:233]

                debug_assert!(is_alive(txn, channel, c).unwrap());

[63.20720]

[21.132150]

                debug_assert!(is_alive(txn, channel, &c).unwrap());

Replacement in libpijul/src/apply.rs at line 810 [18.944089]

B:BD[18.971508] → [63.20895:20940]

B:BD[63.20940] → [22.66568:66636]

        let (a, b) = if p.flag.is_parent() {
            if let Ok(dest) = txn.find_block_end(channel, p.dest) {

[18.971508]

[18.971765]

        let (a, b) = if p.flag().is_parent() {
            if let Ok(&dest) = txn.find_block_end(channel, p.dest()) {

Replacement in libpijul/src/apply.rs at line 816 [18.944089]

B:BD[18.971862] → [22.66637:66704]

        } else if let Ok(dest) = txn.find_block(channel, p.dest) {

[18.971862]

[70.1656]

        } else if let Ok(&dest) = txn.find_block(channel, p.dest()) {

Replacement in libpijul/src/apply.rs at line 821 [18.944089]

B:BD[18.972051] → [21.132384:132490]

        let a_is_alive = is_alive(txn, channel, a)?;
        let b_is_alive = is_alive(txn, channel, b)?;

[18.972051]

[63.20941]

        let a_is_alive = is_alive(txn, channel, &a)?;
        let b_is_alive = is_alive(txn, channel, &b)?;

Replacement in libpijul/src/apply.rs at line 828 [18.944089]

B:BD[8.230] → [8.230:272]

            a, b, p.introduced_by, p.flag

[8.230]

[8.272]

            a, b, p.introduced_by(), p.flag()

Replacement in libpijul/src/apply.rs at line 833 [18.944089]
B:BD[63.21077] → [63.21077:21117]
```
            p.flag - EdgeFlags::PARENT,
```
[63.21077]
[63.21117]
```
            p.flag() - EdgeFlags::PARENT,
```
Replacement in libpijul/src/apply.rs at line 836 [18.944089]
B:BD[63.21147] → [63.21147:21176]
```
            p.introduced_by,
```
[63.21147]
[21.132491]
```
            p.introduced_by(),
```

Replacement in libpijul/src/apply.rs at line 850 [18.944089]

B:BD[63.21475] → [8.320:374]

        } else if b_is_alive && !p.flag.is_folder() {

[63.21475]

[8.374]

        } else if b_is_alive && !p.flag().is_folder() {

Replacement in libpijul/src/apply.rs at line 909 [18.944089]

B:BD[63.22391] → [22.66705:66788]

∅:D[22.66788] → [21.132761:132803]

B:BD[63.22475] → [21.132761:132803]

        let up = txn.find_block_end(channel, internal_pos(txn, &up, change_id)?)?;
        if !is_alive(txn, channel, up)? {

[63.22391]

[63.22516]

        let up = *txn.find_block_end(channel, internal_pos(txn, &up, change_id)?)?;
        if !is_alive(txn, channel, &up)? {

Replacement in libpijul/src/apply.rs at line 940 [18.944089]

B:BD[21.132985] → [22.66789:66872]

        let down = txn.find_block(channel, internal_pos(txn, &down, change_id)?)?;

[21.132985]

[21.132986]

        let down = *txn.find_block(channel, internal_pos(txn, &down, change_id)?)?;

Replacement in libpijul/src/apply.rs at line 949 [18.944089]
B:BD[21.133056] → [21.133056:133102]
```
            if e.introduced_by != change_id {
```
[21.133056]
[21.133102]
```
            if e.introduced_by() != change_id {
```
Replacement in libpijul/src/apply.rs at line 1024 [18.944089]
∅:D[21.133550] → [63.25622:25673]
B:BD[63.25622] → [63.25622:25673]
```
                let dest = ee.dest.inode_vertex();
```
[21.133550]
[63.25673]
```
                let dest = ee.dest().inode_vertex();
```

Replacement in libpijul/src/apply.rs at line 1065 [18.944089]

∅:D[21.133782] → [63.26609:26650]

B:BD[63.26609] → [63.26609:26650]

B:BD[63.26650] → [22.66873:66942]

            if parent.flag.is_parent() {
                let anc = txn.find_block_end(channel, parent.dest)?;

[21.133782]

[63.26720]

            if parent.flag().is_parent() {
                let anc = txn.find_block_end(channel, parent.dest())?;

Replacement in libpijul/src/apply.rs at line 1071 [18.944089]
B:BD[63.26874] → [63.26874:26899]
```
                    anc,
```
[63.26874]
[63.26899]
```
                    *anc,
```

Replacement in libpijul/src/apply.rs at line 1082 [18.944089]

∅:D[21.133998] → [63.27054:27193]

B:BD[63.27054] → [63.27054:27193]

                debug!("al = {:?}, flag = {:?}", al, parent.flag);
                stack.push((anc, false, parent.flag.is_deleted(), al));

[21.133998]

[63.27193]

                debug!("al = {:?}, flag = {:?}", al, parent.flag());
                stack.push((*anc, false, parent.flag().is_deleted(), al));

Replacement in libpijul/src/apply.rs at line 1122 [18.944089]

∅:D[21.134232] → [63.27956:28092]

B:BD[63.27956] → [63.27956:28092]

        if e.flag.contains(EdgeFlags::PARENT) {
            if e.flag & (EdgeFlags::FOLDER | EdgeFlags::DELETED) == EdgeFlags::FOLDER {

[21.134232]

[63.28092]

        if e.flag().contains(EdgeFlags::PARENT) {
            if e.flag() & (EdgeFlags::FOLDER | EdgeFlags::DELETED) == EdgeFlags::FOLDER {

Replacement in libpijul/src/apply.rs at line 1127 [18.944089]
B:BD[63.28159] → [63.28159:28200]
```
        } else if !e.flag.is_deleted() {
```
[63.28159]
[63.28200]
```
        } else if !e.flag().is_deleted() {
```

Replacement in libpijul/src/apply.rs at line 1176 [18.944089]

B:BD[18.982036] → [22.66968:67034]

            stack.push(txn.find_block_end(channel, parent.dest)?)

[18.982036]

[18.982135]

            stack.push(*txn.find_block_end(channel, parent.dest())?)

Replacement in libpijul/src/alive/retrieve.rs at line 43 [18.984582]
∅:D[21.134461] → [18.985970:986025]
B:BD[18.985970] → [18.985970:986025]
```
            let dest_vid = match cache.entry(e.dest) {
```
[21.134461]
[18.986025]
```
            let dest_vid = match cache.entry(e.dest()) {
```

Replacement in libpijul/src/alive/retrieve.rs at line 45 [18.984582]

B:BD[18.986065] → [21.134462:134539]

                    if let Some(alive) = new_vertex(txn, channel, e.dest)? {

[18.986065]

[27.72734]

                    if let Some(alive) = new_vertex(txn, channel, e.dest())? {

Replacement in libpijul/src/alive/retrieve.rs at line 58 [18.984582]

B:BD[18.986467] → [18.986467:986530]

            assert_ne!(graph[vid].vertex.start_pos(), e.dest);

[18.986467]

[9.755]

            assert_ne!(graph[vid].vertex.start_pos(), e.dest());

Replacement in libpijul/src/alive/retrieve.rs at line 60 [18.984582]
∅:D[9.799] → [18.986574:986628]
B:BD[18.986574] → [18.986574:986628]
```
            graph.children.push((Some(e), dest_vid));
```
[9.799]
[18.986628]
```
            graph.children.push((Some(*e), dest_vid));
```

Replacement in libpijul/src/alive/retrieve.rs at line 75 [18.984582]

B:BD[21.134666] → [22.67035:67089]

∅:D[22.67089] → [21.134738:134778]

B:BD[21.134738] → [21.134738:134778]

    let vertex = txn.find_block(graph, pos).unwrap();
    if !is_alive(txn, graph, vertex)? {

[21.134666]

[9.800]

    let vertex = *txn.find_block(graph, pos).unwrap();
    if !is_alive(txn, graph, &vertex)? {

Replacement in libpijul/src/alive/retrieve.rs at line 89 [18.984582]
B:BD[21.135050] → [21.135050:135068]
```
            .flag
```
[21.135050]
[21.135068]
```
            .flag()
```

Replacement in libpijul/src/alive/retrieve.rs at line 119 [18.984582]

B:BD[18.988137] → [22.67090:67154]

        let dest = txn.find_block(channel, edge.dest).unwrap();

[18.988137]

[18.988202]

        let dest = *txn.find_block(channel, edge.dest()).unwrap();

Replacement in libpijul/src/alive/retrieve.rs at line 121 [18.984582]

B:BD[18.988306] → [27.74066:74154]

        del_graph_with_rev(txn, channel, edge.flag, vertex, dest, edge.introduced_by)?;

[18.988306]

[18.988393]

        del_graph_with_rev(txn, channel, edge.flag(), vertex, dest, edge.introduced_by())?;

Replacement in libpijul/src/alive/output.rs at line 101 [18.988425]

B:BD[21.136074] → [21.136074:136123]

                let mut min: Option<u64> = None;

[21.136074]

[21.136123]

                let mut min: Option<L64> = None;

Replacement in libpijul/src/alive/output.rs at line 104 [18.988425]

B:BD[18.991876] → [43.8134:8225]

                        txn.get_changeset(txn.changes(&channel), graph[*x].vertex.change)?

[18.991876]

[18.991967]

                        txn.get_changeset(txn.changes(&channel), &graph[*x].vertex.change)?

Replacement in libpijul/src/alive/output.rs at line 107 [18.988425]

B:BD[21.136317] → [21.136317:136362]

                            *m = (*m).min(t)

[21.136317]

[21.136362]

                            *m = (*m).min(*t)

Replacement in libpijul/src/alive/output.rs at line 109 [18.988425]

B:BD[21.136395] → [21.136395:136437]

                            min = Some(t)

[21.136395]

[21.136437]

                            min = Some(*t)

Replacement in libpijul/src/alive/output.rs at line 121 [18.988425]
B:BD[21.136645] → [21.136645:136678]
```
                Ok(min.unwrap())
```
[21.136645]
[21.136678]
```
                Ok(u64::from_le(min.unwrap().0))
```

Replacement in libpijul/src/alive/output.rs at line 163 [18.988425]

B:BD[23.100647] → [21.137372:137449]

                .get_contents(|p| txn.get_external(p).unwrap(), vertex, buf)

[23.100647]

[23.100715]

                .get_contents(|p| txn.get_external(&p).unwrap().map(|x| x.into()), vertex, buf)

Replacement in libpijul/src/alive/output.rs at line 192 [18.988425]
B:BD[18.994445] → [18.994445:994494]
```
    forward: &mut Vec<(Vertex<ChangeId>, Edge)>,
```
[18.994445]
[21.137521]
```
    forward: &mut Vec<(Vertex<ChangeId>, SerializedEdge)>,
```
Replacement in libpijul/src/alive/mod.rs at line 1 [18.995164]
B:BD[18.995220] → [18.995220:995267]
```
use crate::pristine::{ChangeId, Edge, Vertex};
```
[18.995164]
[18.995267]
```
use crate::pristine::{ChangeId, SerializedEdge, Vertex};
```
Replacement in libpijul/src/alive/mod.rs at line 51 [18.995164]
B:BD[18.996315] → [18.996315:996360]
```
    children: Vec<(Option<Edge>, VertexId)>,
```
[18.996315]
[18.996360]
```
    children: Vec<(Option<SerializedEdge>, VertexId)>,
```

Replacement in libpijul/src/alive/mod.rs at line 77 [18.995164]

B:BD[18.996938] → [18.996938:997018]

    pub(crate) fn children(&self, i: VertexId) -> &[(Option<Edge>, VertexId)] {

[18.996938]

[37.7904]

    pub(crate) fn children(&self, i: VertexId) -> &[(Option<SerializedEdge>, VertexId)] {

Replacement in libpijul/src/alive/mod.rs at line 82 [18.995164]

B:BD[18.997128] → [18.997128:997202]

    fn child(&self, i: VertexId, j: usize) -> &(Option<Edge>, VertexId) {

[18.997128]

[18.997202]

    fn child(&self, i: VertexId, j: usize) -> &(Option<SerializedEdge>, VertexId) {

Replacement in libpijul/src/alive/dfs.rs at line 79 [18.1000429]

B:BD[18.1002414] → [18.1002414:1002544]

                    change: ChangeId(1),
                    start: ChangePosition(0),
                    end: ChangePosition(1)

[18.1002414]

[18.1002544]

                    change: ChangeId(1u64.into()),
                    start: ChangePosition(0u64.into()),
                    end: ChangePosition(1u64.into())

Replacement in libpijul/src/alive/dfs.rs at line 96 [18.1000429]

B:BD[18.1002870] → [18.1002870:1002929]

        graph.lines[i].vertex.change = ChangeId(i as u64);

[18.1002870]

[18.1002929]

        graph.lines[i].vertex.change = ChangeId((i as u64).into());

Replacement in libpijul/src/alive/dfs.rs at line 120 [18.1000429]
B:BD[18.1003461] → [18.1003461:1003489]
```
                Some(Edge {
```
[18.1003461]
[18.1003489]
```
                Some((Edge {
```

Replacement in libpijul/src/alive/dfs.rs at line 123 [18.1000429]

B:BD[18.1003598] → [18.1003598:1003669]

                    introduced_by: ChangeId(4165),
                }),

[18.1003598]

[18.1003669]

                    introduced_by: ChangeId(4165u64.into()),
                }).into()),

Replacement in libpijul/src/alive/dfs.rs at line 365 [18.1000429]

B:BD[18.1013332] → [18.1013332:1013385]

        forward: &mut Vec<(Vertex<ChangeId>, Edge)>,

[18.1013332]

[21.137761]

        forward: &mut Vec<(Vertex<ChangeId>, SerializedEdge)>,

Replacement in libpijul/src/alive/dfs.rs at line 374 [18.1000429]

B:BD[18.1013774] → [18.1013774:1013839]

                        if edge.flag.contains(EdgeFlags::PSEUDO)

[18.1013695]

[27.74155]

                        if edge.flag().contains(EdgeFlags::PSEUDO)

Replacement in libpijul/src/alive/dfs.rs at line 382 [18.1000429]

B:BD[18.1014147] → [18.1014147:1014190]

                                edge.dest,

[18.1014147]

[18.1014190]

                                edge.dest(),

Replacement in libpijul/src/alive/debug.rs at line 36 [18.1014531]

B:BD[23.101031] → [21.137996:138083]

                .get_contents(|h| txn.get_external(h).unwrap(), line.vertex, &mut buf)

[23.101031]

[23.101109]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), line.vertex, &mut buf)

Replacement in libpijul/src/alive/debug.rs at line 65 [18.1014531]
∅:D[22.67642] → [18.1016807:1016868]
∅:D[21.138322] → [18.1016807:1016868]
B:BD[18.1016807] → [18.1016807:1016868]
```
                    if let Some(dest) = cache.get(&v.dest) {
```
[22.67642]
[18.1016868]
```
                    if let Some(dest) = cache.get(&v.dest()) {
```

Replacement in libpijul/src/alive/debug.rs at line 71 [18.1014531]

B:BD[18.1017073] → [18.1017073:1017116]

                            v.flag.bits(),

[18.1017073]

[18.1017116]

                            v.flag().bits(),

Replacement in libpijul/src/alive/debug.rs at line 74 [18.1014531]

B:BD[18.1017229] → [18.1017229:1017289]

                                v.introduced_by.to_base32()

[18.1017229]

[18.1017289]

                                v.introduced_by().to_base32()

Replacement in libpijul/src/alive/debug.rs at line 80 [18.1014531]

B:BD[18.1017459] → [18.1017459:1017565]

                        if !others.contains(&v.dest) {
                            others.insert(v.dest);

[18.1017459]

[18.1017565]

                        if !others.contains(&v.dest()) {
                            others.insert(v.dest());

Replacement in libpijul/src/alive/debug.rs at line 85 [18.1014531]

B:BD[18.1017709] → [18.1017709:1017918]

                                v.dest.change.to_base32(),
                                v.dest.pos.0,
                                v.dest.change.to_base32(),
                                v.dest.pos.0

[18.1017709]

[18.1017918]

                                v.dest().change.to_base32(),
                                v.dest().pos.0,
                                v.dest().change.to_base32(),
                                v.dest().pos.0

Replacement in libpijul/src/alive/debug.rs at line 95 [18.1014531]

B:BD[18.1018150] → [18.1018150:1018290]

                            v.dest.change.to_base32(),
                            v.dest.pos.0,
                            v.flag.bits(),

[18.1018150]

[18.1018290]

                            v.dest().change.to_base32(),
                            v.dest().pos.0,
                            v.flag().bits(),

Replacement in libpijul/src/alive/debug.rs at line 100 [18.1014531]

B:BD[18.1018403] → [18.1018403:1018463]

                                v.introduced_by.to_base32()

[18.1018403]

[18.1018463]

                                v.introduced_by().to_base32()

Replacement in libpijul/src/alive/debug.rs at line 117 [18.1014531]

B:BD[18.1019008] → [18.1019008:1019050]

                        edge.flag.bits(),

[18.1019008]

[18.1019050]

                        edge.flag().bits(),

Replacement in libpijul/src/alive/debug.rs at line 120 [18.1014531]

B:BD[18.1019155] → [18.1019155:1019214]

                            edge.introduced_by.to_base32()

[18.1019155]

[18.1019214]

                            edge.introduced_by().to_base32()

Replacement in libpijul/src/alive/debug.rs at line 159 [18.1014531]

B:BD[18.1020424] → [18.1020424:1020521]

                        edge.flag.bits(),
                        edge.introduced_by.to_base32()

[18.1020424]

[18.1020521]

                        edge.flag().bits(),
                        edge.introduced_by().to_base32()

Replacement in libpijul/Cargo.toml at line 97 [18.1020742]
B:BD[18.1022980] → [59.58:117]
```
sanakirja = { version = "0.15.8", features = [ "crc32" ] }
```
[18.1022980]
[18.1023001]
```
sanakirja = "1.1.2"
```
Replacement in Cargo.lock at line 64 [18.1030385]
B:BD[18.1032392] → [99.0:19]
```
version = "0.3.55"
```
[18.1032392]
[18.1032411]
```
version = "0.3.56"
```

Replacement in Cargo.lock at line 66 [18.1030385]

B:BD[18.1032476] → [99.20:98]

checksum = "ef5140344c85b01f9bbb4d4b7288a8aa4b3287ccef913a14bcc78a1063623598"

[18.1032476]

[18.1032554]

checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc"

Replacement in Cargo.lock at line 84 [18.1030385]
B:BD[18.1032880] → [18.1032880:1032898]
```
version = "1.3.1"
```
[18.1032880]
[18.1032898]
```
version = "1.3.2"
```

Replacement in Cargo.lock at line 86 [18.1030385]

B:BD[18.1032963] → [18.1032963:1033041]

checksum = "f30d3a39baa26f9651f17b375061f3233dde33424a8b72b0dbe93a68a0bc896d"

[18.1032963]

[18.1033041]

checksum = "d175dfa69e619905c4c3cdb7c3c203fa3bdd5d51184e3afdb2742c0280493772"

Replacement in Cargo.lock at line 132 [18.1030385]
B:BD[18.1034498] → [18.1034498:1034517]
```
version = "0.2.14"
```
[18.1034498]
[18.1034517]
```
version = "0.2.15"
```

Replacement in Cargo.lock at line 134 [18.1030385]

B:BD[18.1034582] → [18.1034582:1034660]

checksum = "473fc6b38233f9af7baa94fb5852dca389e3d95b8e21c8e3719301462c5d9faf"

[18.1034582]

[18.1034660]

checksum = "a40b47ad93e1a5404e6c18dec46b628214fee441c70f4ab5d6942142cc268a3d"

Replacement in Cargo.lock at line 141 [18.1030385]
B:BD[18.1034720] → [18.1034720:1034738]
```
version = "3.4.0"
```
[18.1034720]
[18.1034738]
```
version = "3.6.1"
```

Replacement in Cargo.lock at line 143 [18.1030385]

B:BD[18.1034803] → [18.1034803:1034881]

checksum = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820"

[18.1034803]

[18.1034881]

checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe"

Replacement in Cargo.lock at line 147 [18.1030385]
B:BD[18.1034913] → [100.99:117]
```
version = "1.4.2"
```
[18.1034913]
[18.1034931]
```
version = "1.3.4"
```

Replacement in Cargo.lock at line 149 [18.1030385]

B:BD[18.1034996] → [100.118:196]

checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b"

[18.1034996]

[18.1035074]

checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"

Replacement in Cargo.lock at line 165 [18.1030385]
B:BD[18.1035288] → [101.10885:10904]
```
version = "1.0.66"
```
[18.1035288]
[18.1035307]
```
version = "1.0.67"
```

Replacement in Cargo.lock at line 167 [18.1030385]

B:BD[18.1035372] → [101.10905:10983]

checksum = "4c0496836a84f8d0495758516b8621a622beb77c0fed418570e50764093ced48"

[18.1035372]

[18.1035450]

checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"

Replacement in Cargo.lock at line 278 [18.1030385]
B:BD[99.902] → [102.995:1013]
```
version = "0.8.1"
```
[99.902]
[99.920]
```
version = "0.8.2"
```

Replacement in Cargo.lock at line 280 [18.1030385]

B:BD[99.985] → [102.1014:1092]

checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d"

[99.985]

[99.1063]

checksum = "bae8f328835f8f5a6ceb6a7842a7f2d0c03692adb5c889347235d59194731fe3"

Insertion in Cargo.lock at line 285 [18.1030385]
[18.1039172]
[18.1039172]
```
 "loom",
```
Replacement in Cargo.lock at line 310 [18.1030385]
B:BD[103.520] → [103.520:538]
```
version = "3.1.7"
```
[103.520]
[103.538]
```
version = "3.1.8"
```

Replacement in Cargo.lock at line 312 [18.1030385]

B:BD[103.603] → [103.603:681]

checksum = "b57a92e9749e10f25a171adcebfafe72991d45e7ec2dcb853e8f83d9dafaeb08"

[103.603]

[103.681]

checksum = "c15b8ec3b5755a188c141c1f6a98e76de31b936209bf066b647979e2a84764a9"

Replacement in Cargo.lock at line 334 [18.1030385]
B:BD[18.1039998] → [18.1039998:1040016]
```
version = "2.3.1"
```
[18.1039998]
[18.1040016]
```
version = "2.3.2"
```

Replacement in Cargo.lock at line 336 [18.1030385]

B:BD[18.1040081] → [18.1040081:1040159]

checksum = "993a608597367c6377b258c25d7120740f00ed23a2252b729b1932dd7866f908"

[18.1040081]

[18.1040159]

checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"

Replacement in Cargo.lock at line 340 [18.1030385]
B:BD[18.1040187] → [18.1040187:1040205]
```
version = "0.4.0"
```
[18.1040187]
[18.1040205]
```
version = "0.4.1"
```

Replacement in Cargo.lock at line 342 [18.1030385]

B:BD[18.1040270] → [18.1040270:1040348]

checksum = "bb4e4582f27b475e229dc0926b12082a6fb8662c7cb25ed1465243486fe181a2"

[18.1040270]

[18.1040348]

checksum = "a8117b4111dc8d9e88d92ec2ee1cda48318af35c3e6b4f8599add5048189971d"

Replacement in Cargo.lock at line 412 [18.1030385]
B:BD[18.1042023] → [18.1042023:1042042]
```
version = "0.8.26"
```
[18.1042023]
[18.1042042]
```
version = "0.8.28"
```

Replacement in Cargo.lock at line 414 [18.1030385]

B:BD[18.1042107] → [18.1042107:1042185]

checksum = "801bbab217d7f79c0062f4f7205b5d4427c6d1a7bd7aafdd1475f7c59d62b283"

[18.1042107]

[18.1042185]

checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"

Replacement in Cargo.lock at line 421 [18.1030385]
B:BD[18.1042528] → [104.644:662]
```
version = "0.8.2"
```
[18.1042254]
[18.1042546]
```
version = "0.8.3"
```

Replacement in Cargo.lock at line 423 [18.1030385]

B:BD[18.1042611] → [104.663:741]

checksum = "f26ecb66b4bdca6c1409b40fb255eefc2bd4f6d135dab3c3124f80ffa2a9661e"

[18.1042611]

[18.1042689]

checksum = "17392a012ea30ef05a610aa97dfb49496e71c9f676b27879922ea5bdf60d9d3f"

Replacement in Cargo.lock at line 455 [18.1030385]
B:BD[18.1042800] → [18.1042800:1042819]
```
version = "0.2.13"
```
[18.1042800]
[18.1042819]
```
version = "0.2.14"
```

Replacement in Cargo.lock at line 457 [18.1030385]

B:BD[18.1042884] → [18.1042884:1042962]

checksum = "0c122a393ea57648015bf06fbd3d372378992e86b9ff5a7a497b076a28c79efe"

[18.1042884]

[18.1042962]

checksum = "1d34cfa13a63ae058bfa601fe9e313bbdb3746427c1459185464ce0fcf62e1e8"

Replacement in Cargo.lock at line 461 [18.1030385]
B:BD[18.1043005] → [100.439:464]
```
 "redox_syscall 0.1.57",
```
[18.1043005]
[105.827]
```
 "redox_syscall 0.2.5",
```
Replacement in Cargo.lock at line 467 [18.1030385]
B:BD[18.1043071] → [18.1043071:1043090]
```
version = "1.0.19"
```
[18.1043071]
[18.1043090]
```
version = "1.0.20"
```

Replacement in Cargo.lock at line 469 [18.1030385]

B:BD[18.1043155] → [18.1043155:1043233]

checksum = "7411863d55df97a419aa64cb4d2f167103ea9d767e2c54a1868b7ac3f6b47129"

[18.1043155]

[18.1043233]

checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0"

Replacement in Cargo.lock at line 500 [18.1030385]
B:BD[18.1043978] → [18.1043978:1043996]
```
version = "1.0.0"
```
[18.1043978]
[18.1043996]
```
version = "1.0.1"
```

Replacement in Cargo.lock at line 502 [18.1030385]

B:BD[18.1044061] → [18.1044061:1044139]

checksum = "ece68d15c92e84fa4f19d3780f1294e5ca82a78a6d515f1efaabcc144688be00"

[18.1044061]

[18.1044139]

checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"

Replacement in Cargo.lock at line 520 [18.1030385]
B:BD[18.1044908] → [25.16986:17005]
```
version = "0.3.10"
```
[18.1044908]
[18.1044926]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 522 [18.1030385]

B:BD[18.1044991] → [25.17006:17084]

checksum = "309f13e3f4be6d5917178c84db67c0b9a09177ac16d4f9a7313a767a68adaa77"

[18.1044991]

[18.1045069]

checksum = "7f55667319111d593ba876406af7c409c0ebb44dc4be6132a783ccf163ea14c1"

Replacement in Cargo.lock at line 535 [18.1030385]
B:BD[18.1045250] → [25.17085:17104]
```
version = "0.3.10"
```
[18.1045250]
[18.1045268]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 537 [18.1030385]

B:BD[18.1045333] → [25.17105:17183]

checksum = "7a3b03bd32f6ec7885edeb99acd1e47e20e34fd4dfd3c6deed6fcac8a9d28f6a"

[18.1045333]

[18.1045411]

checksum = "8c2dd2df839b57db9ab69c2c9d8f3e8c81984781937fe2807dc6dcf3b2ad2939"

Replacement in Cargo.lock at line 545 [18.1030385]
B:BD[18.1045499] → [25.17184:17203]
```
version = "0.3.10"
```
[18.1045499]
[18.1045517]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 547 [18.1030385]

B:BD[18.1045582] → [25.17204:17282]

checksum = "ed8aeae2b6ab243ebabe6f54cd4cf53054d98883d5d326128af7d57a9ca5cd3d"

[18.1045582]

[18.1045660]

checksum = "15496a72fabf0e62bdc3df11a59a3787429221dd0710ba8ef163d6f7a9112c94"

Replacement in Cargo.lock at line 551 [18.1030385]
B:BD[18.1045699] → [25.17283:17302]
```
version = "0.3.10"
```
[18.1045699]
[18.1045717]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 553 [18.1030385]

B:BD[18.1045782] → [25.17303:17381]

checksum = "3f7836b36b7533d16fd5937311d98ba8965ab81030de8b0024c299dd5d51fb9b"

[18.1045782]

[18.1045860]

checksum = "891a4b7b96d84d5940084b2a37632dd65deeae662c114ceaa2c879629c9c0ad1"

Replacement in Cargo.lock at line 562 [18.1030385]
B:BD[18.1045963] → [25.17382:17401]
```
version = "0.3.10"
```
[18.1045963]
[18.1045981]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 564 [18.1030385]

B:BD[18.1046046] → [25.17402:17480]

checksum = "d41234e71d5e8ca73d01563974ef6f50e516d71e18f1a2f1184742e31f5d469f"

[18.1046046]

[18.1046124]

checksum = "d71c2c65c57704c32f5241c1223167c2c3294fd34ac020c807ddbe6db287ba59"

Replacement in Cargo.lock at line 568 [18.1030385]
B:BD[18.1046160] → [25.17481:17500]
```
version = "0.3.10"
```
[18.1046160]
[18.1046178]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 570 [18.1030385]

B:BD[18.1046243] → [25.17501:17579]

checksum = "3520e0eb4e704e88d771b92d51273ee212997f0d8282f17f5d8ff1cb39104e42"

[18.1046243]

[18.1046321]

checksum = "ea405816a5139fb39af82c2beb921d52143f556038378d6db21183a5c37fbfb7"

Replacement in Cargo.lock at line 580 [18.1030385]
B:BD[18.1046429] → [25.17580:17599]
```
version = "0.3.10"
```
[18.1046429]
[18.1046447]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 582 [18.1030385]

B:BD[18.1046512] → [25.17600:17678]

checksum = "c72d188479368953c6c8c7140e40d7a4401674ab3b98a41e60e515d6cbdbe5de"

[18.1046512]

[18.1046590]

checksum = "85754d98985841b7d4f5e8e6fbfa4a4ac847916893ec511a2917ccd8525b8bb3"

Replacement in Cargo.lock at line 586 [18.1030385]
B:BD[18.1046625] → [25.17679:17698]
```
version = "0.3.10"
```
[18.1046625]
[18.1046643]
```
version = "0.3.13"
```
Replacement in Cargo.lock at line 588 [18.1030385]
B:BD[18.1046708] → [25.17699:17777]
∅:D[100.1248] → [18.1046786:1046819]
∅:D[25.17777] → [18.1046786:1046819]
B:BD[18.1046786] → [18.1046786:1046819]
```
checksum = "08944cea9021170d383287169859c0ca8147d9ec285978393109954448f33cc7"
dependencies = [
 "once_cell",
]
```
[18.1046708]
[18.1046819]
```
checksum = "fa189ef211c15ee602667a6fcfe1c1fd9e07d42250d2156382820fba33c9df80"
```
Replacement in Cargo.lock at line 592 [18.1030385]
B:BD[18.1046854] → [25.17778:17797]
```
version = "0.3.10"
```
[18.1046854]
[18.1046872]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 594 [18.1030385]

B:BD[18.1046937] → [25.17798:17876]

checksum = "d3dd206efbe2ca683b2ce138ccdf61e1b0a63f5816dcedc9d8654c500ba0cea6"

[18.1046937]

[18.1047015]

checksum = "1812c7ab8aedf8d6f2701a43e1243acdbcc2b36ab26e2ad421eb99ac963d96d1"

Insertion in Cargo.lock at line 617 [18.1030385]

[18.1047249]

name = "generator"
version = "0.6.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a9fed24fd1e18827652b4d55652899a1e9da8e54d91624dc3437a5bc3a9f9a9c"
dependencies = [
 "cc",
 "libc",
 "log",
 "rustversion",
 "winapi",
]
[[package]]

Replacement in Cargo.lock at line 652 [18.1030385]
B:BD[106.242] → [107.2091:2109]
```
version = "0.2.1"
```
[106.242]
[106.260]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 654 [18.1030385]

B:BD[106.325] → [107.2110:2188]

checksum = "4060f4657be78b8e766215b02b18a2e862d83745545de804638e2b545e81aee6"

[106.325]

[18.1047677]

checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"

Replacement in Cargo.lock at line 658 [18.1030385]
B:BD[18.1047721] → [100.1369:1408]
```
 "wasi 0.10.1+wasi-snapshot-preview1",
```
[18.1047721]
[18.1047759]
```
 "wasi 0.10.2+wasi-snapshot-preview1",
```
Replacement in Cargo.lock at line 669 [18.1030385]
B:BD[18.1047978] → [21.141830:141850]
```
version = "0.13.15"
```
[18.1047978]
[18.1047998]
```
version = "0.13.17"
```

Replacement in Cargo.lock at line 671 [18.1030385]

B:BD[18.1048063] → [21.141851:141929]

checksum = "44f267c9da8a4de3c615b59e23606c75f164f84896e97f4dd6c15a4294de4359"

[18.1048063]

[18.1048141]

checksum = "1d250f5f82326884bd39c2853577e70a121775db76818ffa452ed1e80de12986"

Replacement in Cargo.lock at line 732 [18.1030385]
B:BD[18.1049518] → [18.1049518:1049537]
```
version = "0.1.17"
```
[18.1049518]
[18.1049537]
```
version = "0.1.18"
```

Replacement in Cargo.lock at line 734 [18.1030385]

B:BD[18.1049602] → [18.1049602:1049680]

checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"

[18.1049602]

[18.1049680]

checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"

Replacement in Cargo.lock at line 762 [18.1030385]
B:BD[18.1050204] → [18.1050204:1050222]
```
version = "1.3.4"
```
[18.1050204]
[18.1050222]
```
version = "1.3.5"
```

Replacement in Cargo.lock at line 764 [18.1030385]

B:BD[18.1050287] → [18.1050287:1050365]

checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"

[18.1050287]

[18.1050365]

checksum = "615caabe2c3160b313d52ccc905335f4ed5f10881dd63dc5699d47e90be85691"

Replacement in Cargo.lock at line 795 [18.1030385]
B:BD[18.1051305] → [105.1092:1111]
```
version = "0.14.2"
```
[18.1051305]
[18.1051324]
```
version = "0.14.4"
```

Replacement in Cargo.lock at line 797 [18.1030385]

B:BD[18.1051389] → [105.1112:1190]

checksum = "12219dc884514cb4a6a03737f4413c0e01c23a1b059b0156004b23f1e19dccbe"

[18.1051389]

[18.1051467]

checksum = "e8e946c2b1349055e0b72ae281b238baf1a3ea7307c7e9f9d64673bdd9c26ac7"

Replacement in Cargo.lock at line 809 [18.1030385]
B:BD[18.1051613] → [100.1551:1573]
```
 "pin-project 1.0.4",
```
[18.1051613]
[18.1051635]
```
 "pin-project",
```
Replacement in Cargo.lock at line 832 [18.1030385]
B:BD[18.1051996] → [18.1051996:1052014]
```
version = "0.2.0"
```
[18.1051996]
[18.1052014]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 834 [18.1030385]

B:BD[18.1052079] → [18.1052079:1052157]

checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"

[18.1052079]

[18.1052157]

checksum = "89829a5d69c23d348314a7ac337fe39173b61149a9864deabd260983aed48c21"

Replacement in Cargo.lock at line 913 [18.1030385]
B:BD[18.1053886] → [101.11378:11397]
```
version = "0.3.46"
```
[18.1053886]
[18.1053905]
```
version = "0.3.47"
```

Replacement in Cargo.lock at line 915 [18.1030385]

B:BD[18.1053970] → [101.11398:11476]

checksum = "cf3d7383929f7c9c7c2d0fa596f325832df98c3704f2c60553080f7127a58175"

[18.1053970]

[18.1054048]

checksum = "5cfb73131c35423a367daf8cbd24100af0d077668c8c2943f0e7dd775fef0f65"

Replacement in Cargo.lock at line 928 [18.1030385]
B:BD[18.1054747] → [100.1585:1604]
```
version = "0.2.82"
```
[18.1054747]
[18.1054766]
```
version = "0.2.86"
```

Replacement in Cargo.lock at line 930 [18.1030385]

B:BD[18.1054831] → [100.1605:1683]

checksum = "89203f3fba0a3795506acaad8ebce3c80c0af93f994d5a1d7a0b1eeb23271929"

[18.1054831]

[18.1054909]

checksum = "b7282d924be3275cec7f6756ff4121987bc6481325397dde6ba3e7802b1a8b1c"

Replacement in Cargo.lock at line 934 [18.1030385]
B:BD[18.1054943] → [21.142028:142054]
```
version = "0.12.17+1.1.0"
```
[18.1054943]
[18.1054969]
```
version = "0.12.18+1.1.0"
```

Replacement in Cargo.lock at line 936 [18.1030385]

B:BD[18.1055034] → [21.142055:142133]

checksum = "f4ebdf65ca745126df8824688637aa0535a88900b83362d8ca63893bcf4e8841"

[18.1055034]

[18.1055112]

checksum = "3da6a42da88fc37ee1ecda212ffa254c25713532980005d5f7c0b0fbe7e6e885"

Replacement in Cargo.lock at line 993 [18.1030385]
B:BD[18.1056162] → [99.1249:1268]
```
version = "0.2.20"
```
[18.1056162]
[18.1056181]
```
version = "0.2.21"
```

Replacement in Cargo.lock at line 995 [18.1030385]

B:BD[18.1056246] → [99.1269:1347]

checksum = "df40b13fe7ea1be9b9dffa365a51273816c345fc1811478b57ed7d964fbfc4ce"

[18.1056246]

[18.1056324]

checksum = "e0186af0d8f171ae6b9c4c90ec51898bad5d08a2d5e470903a50d9ad8959cbee"

Replacement in Cargo.lock at line 1034 [18.1030385]

B:BD[18.1057116] → [100.1782:1801]

version = "0.4.13"

[18.1057116]

[18.1057135]

version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
dependencies = [
 "cfg-if 1.0.0",
]
[[package]]
name = "loom"
version = "0.4.0"

Replacement in Cargo.lock at line 1045 [18.1030385]

B:BD[18.1057200] → [100.1802:1880]

checksum = "fcf3805d4480bb5b86070dcfeb9e2cb2ebc148adb753c5cca5f884d1d65a42b2"

[18.1057200]

[18.1057278]

checksum = "d44c73b4636e497b4917eb21c33539efa3816741a2d3ff26c6316f1b529481a4"

Replacement in Cargo.lock at line 1047 [18.1030385]
B:BD[18.1057295] → [18.1057295:1057313]
```
 "cfg-if 0.1.10",
```
[18.1057295]
[18.1057313]
```
 "cfg-if 1.0.0",
 "generator",
 "scoped-tls",
```
Replacement in Cargo.lock at line 1101 [18.1030385]
B:BD[107.2460] → [107.2460:2478]
```
version = "0.7.7"
```
[107.2460]
[18.1059225]
```
version = "0.7.9"
```

Replacement in Cargo.lock at line 1103 [18.1030385]

B:BD[18.1059290] → [107.2479:2557]

checksum = "e50ae3f04d169fcc9bde0b547d1c205219b7157e07ded9c5aff03e0637cb3ed7"

[18.1059290]

[18.1059368]

checksum = "a5dede4e2065b3842b8b0af444119f3aa331cc7cc2dd20388bfb0f5d5a38823a"

Replacement in Cargo.lock at line 1142 [18.1030385]
B:BD[103.735] → [103.735:754]
```
version = "0.18.0"
```
[103.735]
[103.754]
```
version = "0.20.0"
```

Replacement in Cargo.lock at line 1144 [18.1030385]

B:BD[103.819] → [103.819:897]

checksum = "83450fe6a6142ddd95fb064b746083fc4ef1705fe81f64a64e1d4b39f54a1055"

[103.819]

[103.897]

checksum = "fa9b4819da1bc61c0ea48b63b7bc8604064dd43013e7cc325df098d49cd7c18a"

Replacement in Cargo.lock at line 1148 [18.1030385]
B:BD[103.934] → [103.934:952]
```
 "cfg-if 0.1.10",
```
[103.934]
[103.952]
```
 "cfg-if 1.0.0",
```
Replacement in Cargo.lock at line 1209 [18.1030385]
B:BD[18.1061523] → [18.1061523:1061542]
```
version = "0.22.0"
```
[18.1061523]
[18.1061542]
```
version = "0.23.0"
```

Replacement in Cargo.lock at line 1211 [18.1030385]

B:BD[18.1061607] → [18.1061607:1061685]

checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"

[18.1061607]

[18.1061685]

checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"

Replacement in Cargo.lock at line 1215 [18.1030385]
B:BD[18.1061717] → [18.1061717:1061735]
```
version = "1.5.2"
```
[18.1061717]
[18.1061735]
```
version = "1.7.0"
```

Replacement in Cargo.lock at line 1217 [18.1030385]

B:BD[18.1061800] → [18.1061800:1061878]

checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0"

[18.1061800]

[18.1061878]

checksum = "10acf907b94fc1b1a152d08ef97e7759650268cf986bf127f387e602b02c7e5a"

Replacement in Cargo.lock at line 1290 [18.1030385]
B:BD[18.1063361] → [101.12223:12241]
```
version = "0.8.2"
```
[18.1063361]
[18.1063379]
```
version = "0.8.3"
```

Replacement in Cargo.lock at line 1292 [18.1030385]

B:BD[18.1063444] → [101.12242:12320]

checksum = "9ccb628cad4f84851442432c60ad8e1f607e29752d0bf072cbd0baf28aa34272"

[18.1063444]

[18.1063522]

checksum = "fa7a782938e745763fe6907fc6ba86946d72f49fe7e21de074e08128a99fb018"

Replacement in Cargo.lock at line 1297 [18.1030385]
B:BD[18.1063591] → [100.1881:1906]
```
 "redox_syscall 0.1.57",
```
[18.1063591]
[18.1063609]
```
 "redox_syscall 0.2.5",
```
Replacement in Cargo.lock at line 1365 [18.1030385]
B:BD[18.1064689] → [18.1064689:1064936]
B:BD[18.1064936] → [100.1907:1925]
∅:D[59.182] → [18.1064954:1065019]
∅:D[104.1122] → [18.1064954:1065019]
∅:D[100.1925] → [18.1064954:1065019]
B:BD[18.1064954] → [18.1064954:1065019]
B:BD[18.1065019] → [100.1926:2004]
∅:D[59.261] → [18.1065097:1065114]
∅:D[104.1201] → [18.1065097:1065114]
∅:D[100.2004] → [18.1065097:1065114]
B:BD[18.1065097] → [18.1065097:1065114]
B:BD[18.1065114] → [100.2005:2036]
∅:D[59.293] → [18.1065145:1065209]
∅:D[104.1233] → [18.1065145:1065209]
∅:D[100.2036] → [18.1065145:1065209]
B:BD[18.1065145] → [18.1065145:1065209]
```
version = "0.4.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ffbc8e94b38ea3d2d8ba92aea2983b503cd75d0888d75b86bb37970b5698e15"
dependencies = [
 "pin-project-internal 0.4.27",
]
[[package]]
name = "pin-project"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95b70b68509f17aa2857863b6fa00bf21fc93674c7a8893de2f469f6aa7ca2f2"
dependencies = [
 "pin-project-internal 1.0.4",
]
[[package]]
name = "pin-project-internal"
version = "0.4.27"
```
[18.1064689]
[18.1065209]
```
version = "1.0.5"
```

Replacement in Cargo.lock at line 1367 [18.1030385]

B:BD[18.1065274] → [18.1065274:1065352]

checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895"

[18.1065274]

[18.1065352]

checksum = "96fa8ebb90271c4477f144354485b8068bd8f6b78b428b01ba892ca26caf0b63"

Replacement in Cargo.lock at line 1369 [18.1030385]
B:BD[18.1065369] → [18.1065369:1065403]
```
 "proc-macro2",
 "quote",
 "syn",
```
[18.1065369]
[18.1065403]
```
 "pin-project-internal",
```
Replacement in Cargo.lock at line 1374 [18.1030385]
B:BD[18.1065448] → [100.2037:2055]
```
version = "1.0.4"
```
[18.1065448]
[18.1065466]
```
version = "1.0.5"
```

Replacement in Cargo.lock at line 1376 [18.1030385]

B:BD[18.1065531] → [100.2056:2134]

checksum = "caa25a6393f22ce819b0f50e0be89287292fda8d425be38ee0ca14c4931d9e71"

[18.1065531]

[18.1065609]

checksum = "758669ae3558c6f74bd2a18b41f7ac0b5a195aea6639d6a9b5e5d1ad5ba24c0b"

Replacement in Cargo.lock at line 1454 [18.1030385]
B:BD[18.1067866] → [101.12367:12385]
```
version = "1.0.8"
```
[18.1067866]
[18.1067884]
```
version = "1.0.9"
```

Replacement in Cargo.lock at line 1456 [18.1030385]

B:BD[18.1067949] → [101.12386:12464]

checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"

[18.1067949]

[18.1068027]

checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"

Replacement in Cargo.lock at line 1463 [18.1030385]
B:BD[18.1068089] → [108.9133:9151]
```
version = "0.8.2"
```
[18.1068089]
[18.1068107]
```
version = "0.8.3"
```

Replacement in Cargo.lock at line 1465 [18.1030385]

B:BD[18.1068172] → [108.9152:9230]

checksum = "18519b42a40024d661e1714153e9ad0c3de27cd495760ceb09710920f1098b1e"

[18.1068172]

[18.1068250]

checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"

Replacement in Cargo.lock at line 1469 [18.1030385]
∅:D[108.9247] → [109.4491:4511]
B:BD[106.812] → [109.4491:4511]
```
 "rand_core 0.6.1",
```
[108.9247]
[108.9248]
```
 "rand_core 0.6.2",
```
Replacement in Cargo.lock at line 1480 [18.1030385]
B:BD[106.1100] → [109.4512:4532]
```
 "rand_core 0.6.1",
```
[106.1100]
[18.1068575]
```
 "rand_core 0.6.2",
```
Replacement in Cargo.lock at line 1494 [18.1030385]
B:BD[106.1162] → [109.4533:4551]
```
version = "0.6.1"
```
[106.1162]
[106.1180]
```
version = "0.6.2"
```

Replacement in Cargo.lock at line 1496 [18.1030385]

B:BD[106.1245] → [109.4552:4630]

checksum = "c026d7df8b298d90ccbbc5190bd04d85e159eaf5576caeacf8741da93ccbd2e5"

[106.1245]

[106.1323]

checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"

Replacement in Cargo.lock at line 1498 [18.1030385]
B:BD[106.1340] → [107.3109:3129]
```
 "getrandom 0.2.1",
```
[106.1340]
[106.1396]
```
 "getrandom 0.2.2",
```
Replacement in Cargo.lock at line 1507 [18.1030385]
B:BD[106.1606] → [109.4631:4651]
```
 "rand_core 0.6.1",
```
[106.1606]
[18.1069025]
```
 "rand_core 0.6.2",
```
Replacement in Cargo.lock at line 1518 [18.1030385]
B:BD[100.2256] → [108.9261:9279]
```
version = "0.2.4"
```
[100.2256]
[100.2274]
```
version = "0.2.5"
```

Replacement in Cargo.lock at line 1520 [18.1030385]

B:BD[100.2339] → [108.9280:9358]

checksum = "05ec8ca9416c5ea37062b502703cd7fcb207736bc294f6e0cf367ac6fc234570"

[100.2339]

[100.2417]

checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9"

Replacement in Cargo.lock at line 1542 [18.1030385]
B:BD[100.2688] → [100.2688:2708]
B:BD[100.2708] → [108.9359:9383]
```
 "getrandom 0.2.1",
 "redox_syscall 0.2.4",
```
[100.2688]
[100.2732]
```
 "getrandom 0.2.2",
 "redox_syscall 0.2.5",
```
Replacement in Cargo.lock at line 1575 [18.1030385]
B:BD[18.1070218] → [105.1526:1545]
```
version = "0.11.0"
```
[18.1070218]
[18.1070237]
```
version = "0.11.1"
```

Replacement in Cargo.lock at line 1577 [18.1030385]

B:BD[18.1070302] → [105.1546:1624]

checksum = "fd281b1030aa675fb90aa994d07187645bb3c8fc756ca766e7c3070b439de9de"

[18.1070302]

[18.1070380]

checksum = "0460542b551950620a3648c6aa23318ac6b3cd779114bd873209e6e8b5eb1c34"

Replacement in Cargo.lock at line 1609 [18.1030385]
B:BD[18.1070803] → [18.1070803:1070821]
```
version = "5.0.0"
```
[18.1070803]
[18.1070821]
```
version = "5.0.1"
```

Replacement in Cargo.lock at line 1611 [18.1030385]

B:BD[18.1070886] → [18.1070886:1070964]

checksum = "d755237fc0f99d98641540e66abac8bc46a0652f19148ac9e21de2da06b326c9"

[18.1070886]

[18.1070964]

checksum = "ffc936cf8a7ea60c58f030fd36a612a48f440610214dc54bc36431f9ea0c3efb"

Insertion in Cargo.lock at line 1636 [18.1030385]

[18.1071504]

[18.1071698]

name = "rustversion"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb5d2a036dc6d2d8fd16fde3498b04306e29bd193bf306a57427019b823d5acd"
[[package]]

Replacement in Cargo.lock at line 1658 [18.1030385]
B:BD[18.1072132] → [59.490:509]
```
version = "0.15.8"
```
[18.1072132]
[18.1072151]
```
version = "1.1.2"
```

Replacement in Cargo.lock at line 1660 [18.1030385]

B:BD[18.1072216] → [59.510:588]

checksum = "3dc2f1481f4fd49edfc47d14f83d2b3b15c342d27adafd7b78488179ca7df27e"

[18.1072216]

[18.1072294]

checksum = "d79085dae1bd13359b250c18ba037ff6f40bdaabf1abc88317f726e57287eb52"

Replacement in Cargo.lock at line 1664 [18.1030385]
B:BD[18.1072319] → [18.1072319:1072328]
```
 "git2",
```
[18.1072319]
[18.1072328]
```
 "lazy_static",
```
Replacement in Cargo.lock at line 1668 [18.1030385]
B:BD[18.1072363] → [108.9384:9393]
```
 "rand",
```
[18.1072363]
[110.1128]
```
 "sanakirja-core",
```

Insertion in Cargo.lock at line 1670 [18.1030385]

[110.1142]

[18.1072372]

]
[[package]]
name = "sanakirja-core"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a55d6fcfbb77ae7c8ebd0e7a100ea94f00e47dd302aa1b7216a1b72524cfdce0"
dependencies = [
 "crc32fast",

Insertion in Cargo.lock at line 1690 [18.1030385]

[18.1072619]


[[package]]
name = "scoped-tls"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"

Replacement in Cargo.lock at line 1705 [18.1030385]
B:BD[18.1072854] → [18.1072854:1072872]
```
version = "2.0.0"
```
[18.1072854]
[18.1072872]
```
version = "2.1.0"
```

Replacement in Cargo.lock at line 1707 [18.1030385]

B:BD[18.1072937] → [18.1072937:1073015]

checksum = "c1759c2e3c8580017a484a7ac56d3abc5a6c1feadf88db2f3633f12ae4268c69"

[18.1072937]

[18.1073015]

checksum = "c6af1b6204f89cf0069736daf8b852573e3bc34898eee600e95d3dd855c12e81"

Replacement in Cargo.lock at line 1718 [18.1030385]
B:BD[18.1073172] → [18.1073172:1073190]
```
version = "2.0.0"
```
[18.1073172]
[18.1073190]
```
version = "2.1.0"
```

Replacement in Cargo.lock at line 1720 [18.1030385]

B:BD[18.1073255] → [18.1073255:1073333]

checksum = "f99b9d5e26d2a71633cc4f2ebae7cc9f874044e0c351a27e17892d76dce5678b"

[18.1073255]

[18.1073333]

checksum = "31531d257baab426203cf81c5ce1b0b55159dda7ed602ac81b582ccd62265741"

Replacement in Cargo.lock at line 1728 [18.1030385]
B:BD[18.1073413] → [108.9394:9414]
```
version = "1.0.119"
```
[18.1073413]
[18.1073433]
```
version = "1.0.123"
```

Replacement in Cargo.lock at line 1730 [18.1030385]

B:BD[18.1073498] → [108.9415:9493]

checksum = "9bdd36f49e35b61d49efd8aa7fc068fd295961fd2286d0b2ee9a4c7a14e99cc3"

[18.1073498]

[18.1073576]

checksum = "92d5161132722baa40d802cc70b15262b98258453e85e5d1d365c757c73869ae"

Replacement in Cargo.lock at line 1737 [18.1030385]
B:BD[18.1073647] → [108.9494:9514]
```
version = "1.0.119"
```
[18.1073647]
[18.1073667]
```
version = "1.0.123"
```

Replacement in Cargo.lock at line 1739 [18.1030385]

B:BD[18.1073732] → [108.9515:9593]

checksum = "552954ce79a059ddd5fd68c271592374bd15cab2274970380c000118aeffe1cd"

[18.1073732]

[18.1073810]

checksum = "9391c295d64fc0abb2c556bad848f33cb8296276b1ad2677d1ae1ace4f258f31"

Replacement in Cargo.lock at line 1748 [18.1030385]
B:BD[18.1073896] → [21.142487:142506]
```
version = "1.0.61"
```
[18.1073896]
[18.1073915]
```
version = "1.0.62"
```

Replacement in Cargo.lock at line 1750 [18.1030385]

B:BD[18.1073980] → [21.142507:142585]

checksum = "4fceb2595057b6891a4ee808f70054bd2d12f0e97f1cbb78689b59f676df325a"

[18.1073980]

[18.1074058]

checksum = "ea1c6153794552ea7cf7cf63b1231a25de00ec90db326ba6264440fa08e31486"

Replacement in Cargo.lock at line 1815 [18.1030385]
B:BD[18.1075798] → [59.589:608]
```
version = "1.0.58"
```
[18.1075798]
[18.1075817]
```
version = "1.0.60"
```

Replacement in Cargo.lock at line 1817 [18.1030385]

B:BD[18.1075882] → [59.609:687]

checksum = "cc60a3d73ea6594cd712d830cc1f0390fd71542d8c8cd24e70cc54cdfd5e05d5"

[18.1075882]

[18.1075960]

checksum = "c700597eca8a5a762beb35753ef6b94df201c81cca676604f547495a0d7f0081"

Replacement in Cargo.lock at line 1826 [18.1030385]
B:BD[18.1076047] → [18.1076047:1076066]
```
version = "0.4.30"
```
[18.1076047]
[18.1076066]
```
version = "0.4.33"
```

Replacement in Cargo.lock at line 1828 [18.1030385]

B:BD[18.1076131] → [18.1076131:1076209]

checksum = "489997b7557e9a43e192c527face4feacc78bfbe6eed67fd55c4c9e381cba290"

[18.1076131]

[18.1076209]

checksum = "c0bcfbd6a598361fda270d82469fff3d65089dc33e175c9a131f7b4cd395f228"

Deletion in Cargo.lock at line 1832 [18.1030385]
B:BD[18.1076248] → [100.3054:3079]
```
 "redox_syscall 0.1.57",
```
Replacement in Cargo.lock at line 1844 [18.1030385]
B:BD[108.9952] → [108.9952:9976]
```
 "redox_syscall 0.2.4",
```
[108.9952]
[18.1076541]
```
 "redox_syscall 0.2.5",
```
Replacement in Cargo.lock at line 1860 [18.1030385]
B:BD[30.5506] → [30.5506:5525]
```
version = "0.1.15"
```
[30.5506]
[30.5525]
```
version = "0.1.16"
```

Replacement in Cargo.lock at line 1862 [18.1030385]

B:BD[30.5590] → [30.5590:5668]

checksum = "4bd2d183bd3fac5f5fe38ddbeb4dc9aec4a39a9d7d59e7491d900302da01cbe1"

[30.5590]

[30.5668]

checksum = "86ca8ced750734db02076f44132d802af0b33b09942331f4459dde8636fd2406"

Replacement in Cargo.lock at line 1879 [18.1030385]
B:BD[18.1077299] → [21.142685:142704]
```
version = "1.0.23"
```
[18.1077299]
[18.1077318]
```
version = "1.0.24"
```

Replacement in Cargo.lock at line 1881 [18.1030385]

B:BD[18.1077383] → [21.142705:142783]

checksum = "76cc616c6abf8c8928e2fdcc0dbfab37175edd8fb49a4641066ad1364fdab146"

[18.1077383]

[18.1077461]

checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"

Replacement in Cargo.lock at line 1888 [18.1030385]
B:BD[18.1077536] → [21.142784:142803]
```
version = "1.0.23"
```
[18.1077536]
[18.1077555]
```
version = "1.0.24"
```

Replacement in Cargo.lock at line 1890 [18.1030385]

B:BD[18.1077620] → [21.142804:142882]

checksum = "9be73a2caec27583d0046ef3796c3794f868a5bc813db689eed00c7631275cd1"

[18.1077620]

[18.1077698]

checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"

Replacement in Cargo.lock at line 1899 [18.1030385]
B:BD[18.1077786] → [100.3106:3124]
```
version = "1.1.0"
```
[18.1077786]
[18.1077804]
```
version = "1.1.3"
```

Replacement in Cargo.lock at line 1901 [18.1030385]

B:BD[18.1077869] → [100.3125:3203]

checksum = "bb9bc092d0d51e76b2b19d9d85534ffc9ec2db959a2523cdae0697e2972cd447"

[18.1077869]

[18.1077947]

checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd"

Replacement in Cargo.lock at line 1903 [18.1030385]
B:BD[18.1077964] → [18.1077964:1077980]
```
 "lazy_static",
```
[18.1077964]
[18.1077980]
```
 "once_cell",
```
Replacement in Cargo.lock at line 1917 [18.1030385]
B:BD[18.1078238] → [108.9977:9996]
```
version = "0.32.4"
```
[18.1078238]
[111.351]
```
version = "0.32.6"
```

Replacement in Cargo.lock at line 1919 [18.1030385]

B:BD[111.416] → [108.9997:10075]

checksum = "d1fde6e64bc24109d09e43cb192df54d0d0d2b26d8d0d3e4b5fd7111b1a41141"

[111.416]

[18.1078400]

checksum = "49ea1ae114bff83c24c862ef3d2d01e28fa524d6ac70a32c9ef01d5c7440f56f"

Replacement in Cargo.lock at line 1945 [18.1030385]
∅:D[105.1777] → [21.142883:142900]
∅:D[107.3691] → [21.142883:142900]
B:BD[18.1078575] → [21.142883:142900]
```
 "whoami 1.0.3",
```
[105.1777]
[18.1078575]
```
 "whoami 1.1.0",
```
Replacement in Cargo.lock at line 1997 [18.1030385]
B:BD[18.1079608] → [99.2303:2321]
```
version = "1.1.0"
```
[18.1079608]
[18.1079626]
```
version = "1.1.1"
```

Replacement in Cargo.lock at line 1999 [18.1030385]

B:BD[18.1079691] → [99.2322:2400]

checksum = "ccf8dbc19eb42fba10e8feaaec282fb50e2c14b2726d6301dbfeed0f73306a6f"

[18.1079691]

[18.1079769]

checksum = "317cca572a0e89c3ce0ca1f1bdc9369547fe318a683418e42ac8f59d14701023"

Replacement in Cargo.lock at line 2012 [18.1030385]
B:BD[107.4135] → [107.4135:4153]
```
version = "1.0.1"
```
[18.1080033]
[107.4153]
```
version = "1.2.0"
```

Replacement in Cargo.lock at line 2014 [18.1030385]

B:BD[107.4218] → [107.4218:4296]

checksum = "d258221f566b6c803c7b4714abadc080172b272090cdc5e244a6d4dd13c3a6bd"

[107.4218]

[107.4296]

checksum = "e8190d04c665ea9e6b6a0dc45523ade572c088d2e6566244c1122671dbf4ae3a"

Replacement in Cargo.lock at line 2031 [18.1030385]
B:BD[18.1080410] → [107.4726:4744]
```
version = "1.0.0"
```
[18.1080410]
[18.1080428]
```
version = "1.1.0"
```

Replacement in Cargo.lock at line 2033 [18.1030385]

B:BD[18.1080493] → [107.4745:4823]

checksum = "42517d2975ca3114b22a16192634e8241dc5cc1f130be194645970cc1c371494"

[18.1080493]

[18.1080571]

checksum = "caf7b11a536f46a809a8a9f0bb4237020f70ecbf115b842360afb127ea2fda57"

Deletion in Cargo.lock at line 2051 [18.1030385]
B:BD[105.2080] → [105.2080:2102]
B:BD[105.2102] → [108.10129:10147]
∅:D[108.10147] → [105.2120:2185]
B:BD[105.2120] → [105.2120:2185]
B:BD[105.2185] → [108.10148:10226]
∅:D[108.10226] → [105.2263:2328]
B:BD[105.2263] → [105.2263:2328]
∅:D[105.2328] → [18.1080859:1080874]
∅:D[107.4841] → [18.1080859:1080874]
B:BD[18.1080859] → [18.1080859:1080874]
```
name = "tokio-stream"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "76066865172052eb8796c686f0b441a93df8b08d40a950b062ffb9a426f00edd"
dependencies = [
 "futures-core",
 "pin-project-lite",
 "tokio",
]
[[package]]
```
Replacement in Cargo.lock at line 2052 [18.1030385]
B:BD[18.1080894] → [108.10227:10245]
```
version = "0.6.1"
```
[18.1080894]
[18.1080912]
```
version = "0.6.3"
```

Replacement in Cargo.lock at line 2054 [18.1030385]

B:BD[18.1080977] → [108.10246:10324]

checksum = "12ae4751faa60b9f96dd8344d74592e5a17c0c9a220413dbc6942d14139bbfcc"

[18.1080977]

[18.1081055]

checksum = "ebb7cb2f00c5ae8df755b252306272cd1790d39728363936e01827e11f0b017b"

Deletion in Cargo.lock at line 2062 [18.1030385]
B:BD[105.2475] → [105.2475:2492]
```
 "tokio-stream",
```
Replacement in Cargo.lock at line 2075 [18.1030385]
B:BD[18.1081410] → [18.1081410:1081428]
```
version = "0.3.0"
```
[18.1081410]
[18.1081428]
```
version = "0.3.1"
```

Replacement in Cargo.lock at line 2077 [18.1030385]

B:BD[18.1081493] → [18.1081493:1081571]

checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"

[18.1081493]

[18.1081571]

checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"

Replacement in Cargo.lock at line 2081 [18.1030385]
B:BD[18.1081601] → [102.1356:1375]
```
version = "0.1.22"
```
[18.1081601]
[18.1081620]
```
version = "0.1.25"
```

Replacement in Cargo.lock at line 2083 [18.1030385]

B:BD[18.1081685] → [102.1376:1454]

checksum = "9f47026cdc4080c07e49b37087de021820269d996f581aac150ef9e5583eefe3"

[18.1081685]

[18.1081763]

checksum = "01ebdc2bb4498ab1ab5f5b73c5803825e60199229ccba0698170e3be0e7f959f"

Replacement in Cargo.lock at line 2101 [18.1030385]
B:BD[18.1082116] → [18.1082116:1082134]
```
version = "0.2.4"
```
[18.1082116]
[18.1082134]
```
version = "0.2.5"
```

Replacement in Cargo.lock at line 2103 [18.1030385]

B:BD[18.1082199] → [18.1082199:1082277]

checksum = "ab7bb6f14721aa00656086e9335d363c5c8747bae02ebe32ea2c7dece5689b4c"

[18.1082199]

[18.1082277]

checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"

Replacement in Cargo.lock at line 2105 [18.1030385]
B:BD[18.1082294] → [18.1082294:1082317]
```
 "pin-project 0.4.27",
```
[18.1082294]
[18.1082317]
```
 "pin-project",
```
Replacement in Cargo.lock at line 2132 [18.1030385]
B:BD[18.1083214] → [104.1768:1787]
```
version = "0.1.16"
```
[18.1083214]
[18.1083233]
```
version = "0.1.17"
```

Replacement in Cargo.lock at line 2134 [18.1030385]

B:BD[18.1083298] → [104.1788:1866]

checksum = "a13e63ab62dbe32aeee58d1c5408d35c36c392bba5d9d3142287219721afe606"

[18.1083298]

[18.1083376]

checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"

Replacement in Cargo.lock at line 2159 [18.1030385]
B:BD[18.1084029] → [18.1084029:1084047]
```
version = "2.2.0"
```
[18.1084029]
[18.1084047]
```
version = "2.2.1"
```

Replacement in Cargo.lock at line 2161 [18.1030385]

B:BD[18.1084112] → [18.1084112:1084190]

checksum = "5909f2b0817350449ed73e8bcd81c8c3c8d9a7a5d8acba4b27db277f1868976e"

[18.1084112]

[18.1084190]

checksum = "9ccd964113622c8e9322cfac19eb1004a07e636c545f325da085d5cdde6f1f8b"

Replacement in Cargo.lock at line 2175 [18.1030385]
B:BD[18.1084476] → [100.3522:3542]
```
 "getrandom 0.2.1",
```
[18.1084476]
[18.1084485]
```
 "getrandom 0.2.2",
```
Replacement in Cargo.lock at line 2225 [18.1030385]
B:BD[18.1085788] → [100.3543:3585]
```
version = "0.10.1+wasi-snapshot-preview1"
```
[18.1085788]
[18.1085830]
```
version = "0.10.2+wasi-snapshot-preview1"
```

Replacement in Cargo.lock at line 2227 [18.1030385]

B:BD[18.1085895] → [100.3586:3664]

checksum = "93c6c3420963c5c64bca373b25e77acb562081b9bb4dd5bb864187742186cea9"

[18.1085895]

[18.1085973]

checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

Replacement in Cargo.lock at line 2231 [18.1030385]
B:BD[18.1086008] → [101.13771:13790]
```
version = "0.2.69"
```
[18.1086008]
[18.1086027]
```
version = "0.2.70"
```

Replacement in Cargo.lock at line 2233 [18.1030385]

B:BD[18.1086092] → [101.13791:13869]

checksum = "3cd364751395ca0f68cafb17666eee36b63077fb5ecd972bbcd74c90c4bf736e"

[18.1086092]

[18.1086170]

checksum = "55c0f7123de74f0dab9b7d00fd614e7b19349cd1e2f5252bbe9b1754b59433be"

Replacement in Cargo.lock at line 2243 [18.1030385]
B:BD[18.1086298] → [101.13888:13907]
```
version = "0.2.69"
```
[18.1086298]
[18.1086317]
```
version = "0.2.70"
```

Replacement in Cargo.lock at line 2245 [18.1030385]

B:BD[18.1086382] → [101.13908:13986]

checksum = "1114f89ab1f4106e5b55e688b828c0ab0ea593a1ea7c094b141b14cbaaec2d62"

[18.1086382]

[18.1086460]

checksum = "7bc45447f0d4573f3d65720f636bbcc3dd6ce920ed704670118650bcd47764c7"

Replacement in Cargo.lock at line 2258 [18.1030385]
B:BD[18.1086616] → [101.13987:14006]
```
version = "0.4.19"
```
[18.1086616]
[18.1086635]
```
version = "0.4.20"
```

Replacement in Cargo.lock at line 2260 [18.1030385]

B:BD[18.1086700] → [101.14007:14085]

checksum = "1fe9756085a84584ee9457a002b7cdfe0bfff169f45d2591d8be1345a6780e35"

[18.1086700]

[18.1086778]

checksum = "3de431a2910c86679c34283a33f66f4e4abd7e0aec27b6669060148872aadf94"

Replacement in Cargo.lock at line 2270 [18.1030385]
B:BD[18.1086896] → [101.14104:14123]
```
version = "0.2.69"
```
[18.1086896]
[18.1086915]
```
version = "0.2.70"
```

Replacement in Cargo.lock at line 2272 [18.1030385]

B:BD[18.1086980] → [101.14124:14202]

checksum = "7a6ac8995ead1f084a8dea1e65f194d0973800c7f571f6edd70adf06ecf77084"

[18.1086980]

[18.1087058]

checksum = "3b8853882eef39593ad4174dd26fc9865a64e84026d223f63bb2c42affcbba2c"

Replacement in Cargo.lock at line 2280 [18.1030385]
B:BD[18.1087167] → [101.14203:14222]
```
version = "0.2.69"
```
[18.1087167]
[18.1087186]
```
version = "0.2.70"
```

Replacement in Cargo.lock at line 2282 [18.1030385]

B:BD[18.1087251] → [101.14223:14301]

checksum = "b5a48c72f299d80557c7c62e37e7225369ecc0c963964059509fbafe917c7549"

[18.1087251]

[18.1087329]

checksum = "4133b5e7f2a531fa413b3a1695e925038a05a71cf67e87dafa295cb645a01385"

Replacement in Cargo.lock at line 2293 [18.1030385]
B:BD[18.1087473] → [101.14302:14321]
```
version = "0.2.69"
```
[18.1087473]
[18.1087492]
```
version = "0.2.70"
```

Replacement in Cargo.lock at line 2295 [18.1030385]

B:BD[18.1087557] → [101.14322:14400]

checksum = "7e7811dd7f9398f14cc76efd356f98f03aa30419dea46aa810d71e819fc97158"

[18.1087557]

[18.1087635]

checksum = "dd4945e4943ae02d15c13962b38a5b1e81eadd4b71214eee75af64a4d6a4fd64"

Replacement in Cargo.lock at line 2299 [18.1030385]
B:BD[18.1087665] → [101.14401:14420]
```
version = "0.3.46"
```
[18.1087665]
[18.1087684]
```
version = "0.3.47"
```

Replacement in Cargo.lock at line 2301 [18.1030385]

B:BD[18.1087749] → [101.14421:14499]

checksum = "222b1ef9334f92a21d3fb53dc3fd80f30836959a90f9274a626d7e06315ba3c3"

[18.1087749]

[18.1087827]

checksum = "c40dc691fc48003eba817c38da7113c15698142da971298003cac3ef175680b3"

Replacement in Cargo.lock at line 2324 [18.1030385]
B:BD[113.893] → [21.142901:142919]
```
version = "1.0.3"
```
[113.893]
[113.911]
```
version = "1.1.0"
```

Replacement in Cargo.lock at line 2326 [18.1030385]

B:BD[113.976] → [21.142920:142998]

checksum = "d595b2e146f36183d6a590b8d41568e2bc84c922267f43baf61c956330eeb436"

[113.976]

[113.1054]

checksum = "1a921c0ad578a51c0b6c0bbb9b95f0ed11e90d61da506139e48a946edd11ee1e"